@socketsecurity/cli-with-sentry 0.15.11 → 0.15.12

package/external/blessed/lib/tput.js

@@ -23,10 +23,10 @@
  * Modules
  */
 
-const assert = require('assert'),
-  path = require('path'),
-  fs = require('fs'),
-  cp = require('child_process')
+var assert = require('assert')
+  , path = require('path')
+  , fs = require('fs')
+  , cp = require('child_process');
 
 /**
  * Tput
@@ -34,110 +34,101 @@ const assert = require('assert'),
 
 function Tput(options) {
   if (!(this instanceof Tput)) {
-    return new Tput(options)
+    return new Tput(options);
   }
 
-  options = options || {}
+  options = options || {};
   if (typeof options === 'string') {
-    options = { terminal: options }
+    options = { terminal: options };
   }
 
-  this.options = options
-  this.terminal =
-    options.terminal ||
-    options.term ||
-    process.env.TERM ||
-    (process.platform === 'win32' ? 'windows-ansi' : 'xterm')
+  this.options = options;
+  this.terminal = options.terminal
+    || options.term
+    || process.env.TERM
+    || (process.platform === 'win32' ? 'windows-ansi' : 'xterm');
 
-  this.terminal = this.terminal.toLowerCase()
+  this.terminal = this.terminal.toLowerCase();
 
-  this.debug = options.debug
-  this.padding = options.padding
-  this.extended = options.extended
-  this.printf = options.printf
-  this.termcap = options.termcap
-  this.error = null
+  this.debug = options.debug;
+  this.padding = options.padding;
+  this.extended = options.extended;
+  this.printf = options.printf;
+  this.termcap = options.termcap;
+  this.error = null;
 
-  this.terminfoPrefix = options.terminfoPrefix
-  this.terminfoFile = options.terminfoFile
-  this.termcapFile = options.termcapFile
+  this.terminfoPrefix = options.terminfoPrefix;
+  this.terminfoFile = options.terminfoFile;
+  this.termcapFile = options.termcapFile;
 
   if (options.terminal || options.term) {
-    this.setup()
+    this.setup();
   }
 }
 
-Tput.prototype.setup = function () {
-  this.error = null
+Tput.prototype.setup = function() {
+  this.error = null;
   try {
     if (this.termcap) {
       try {
-        this.injectTermcap()
+        this.injectTermcap();
       } catch (e) {
-        if (this.debug) {
-          throw e
-        }
-        this.error = new Error('Termcap parse error.')
-        this._useInternalCap(this.terminal)
+        if (this.debug) throw e;
+        this.error = new Error('Termcap parse error.');
+        this._useInternalCap(this.terminal);
       }
     } else {
       try {
-        this.injectTerminfo()
+        this.injectTerminfo();
       } catch (e) {
-        if (this.debug) {
-          throw e
-        }
-        this.error = new Error('Terminfo parse error.')
-        this._useInternalInfo(this.terminal)
+        if (this.debug) throw e;
+        this.error = new Error('Terminfo parse error.');
+        this._useInternalInfo(this.terminal);
       }
     }
   } catch (e) {
     // If there was an error, fallback
     // to an internally stored terminfo/cap.
-    if (this.debug) {
-      throw e
-    }
-    this.error = new Error('Terminfo not found.')
-    this._useXtermInfo()
+    if (this.debug) throw e;
+    this.error = new Error('Terminfo not found.');
+    this._useXtermInfo();
   }
-}
+};
 
-Tput.prototype.term = function (is) {
-  return this.terminal.indexOf(is) === 0
-}
+Tput.prototype.term = function(is) {
+  return this.terminal.indexOf(is) === 0;
+};
 
-Tput.prototype._debug = function () {
-  if (!this.debug) {
-    return
-  }
-  return console.log.apply(console, arguments)
-}
+Tput.prototype._debug = function() {
+  if (!this.debug) return;
+  return console.log.apply(console, arguments);
+};
 
 /**
  * Fallback
  */
 
-Tput.prototype._useVt102Cap = function () {
-  return this.injectTermcap('vt102')
-}
+Tput.prototype._useVt102Cap = function() {
+  return this.injectTermcap('vt102');
+};
 
-Tput.prototype._useXtermCap = function () {
-  return this.injectTermcap(__dirname + '/../usr/xterm.termcap')
-}
+Tput.prototype._useXtermCap = function() {
+  return this.injectTermcap(__dirname + '/../usr/xterm.termcap');
+};
 
-Tput.prototype._useXtermInfo = function () {
-  return this.injectTerminfo(__dirname + '/../usr/xterm')
-}
+Tput.prototype._useXtermInfo = function() {
+  return this.injectTerminfo(__dirname + '/../usr/xterm');
+};
 
-Tput.prototype._useInternalInfo = function (name) {
-  name = path.basename(name)
-  return this.injectTerminfo(__dirname + '/../usr/' + name)
-}
+Tput.prototype._useInternalInfo = function(name) {
+  name = path.basename(name);
+  return this.injectTerminfo(__dirname + '/../usr/' + name);
+};
 
-Tput.prototype._useInternalCap = function (name) {
-  name = path.basename(name)
-  return this.injectTermcap(__dirname + '/../usr/' + name + '.termcap')
-}
+Tput.prototype._useInternalCap = function(name) {
+  name = path.basename(name);
+  return this.injectTermcap(__dirname + '/../usr/' + name + '.termcap');
+};
 
 /**
  * Terminfo
@@ -155,160 +146,167 @@ Tput.ipaths = [
   '/usr/local/lib/terminfo',
   '/usr/local/ncurses/lib/terminfo',
   '/lib/terminfo'
-]
+];
 
-Tput.prototype.readTerminfo = function (term) {
-  let data, file, info
+Tput.prototype.readTerminfo = function(term) {
+  var data
+    , file
+    , info;
 
-  term = term || this.terminal
+  term = term || this.terminal;
 
-  file = path.normalize(this._prefix(term))
-  data = fs.readFileSync(file)
-  info = this.parseTerminfo(data, file)
+  file = path.normalize(this._prefix(term));
+  data = fs.readFileSync(file);
+  info = this.parseTerminfo(data, file);
 
   if (this.debug) {
-    this._terminfo = info
+    this._terminfo = info;
   }
 
-  return info
-}
+  return info;
+};
 
-Tput._prefix = Tput.prototype._prefix = function (term) {
+Tput._prefix =
+Tput.prototype._prefix = function(term) {
   // If we have a terminfoFile, or our
   // term looks like a filename, use it.
   if (term) {
     if (~term.indexOf(path.sep)) {
-      return term
+      return term;
     }
     if (this.terminfoFile) {
-      return this.terminfoFile
+      return this.terminfoFile;
     }
   }
 
-  let paths = Tput.ipaths.slice(),
-    file
+  var paths = Tput.ipaths.slice()
+    , file;
 
   if (this.terminfoPrefix) {
-    paths.unshift(this.terminfoPrefix)
+    paths.unshift(this.terminfoPrefix);
   }
 
   // Try exact matches.
-  file = this._tprefix(paths, term)
-  if (file) {
-    return file
-  }
+  file = this._tprefix(paths, term);
+  if (file) return file;
 
   // Try similar matches.
-  file = this._tprefix(paths, term, true)
-  if (file) {
-    return file
-  }
+  file = this._tprefix(paths, term, true);
+  if (file) return file;
 
   // Not found.
-  throw new Error('Terminfo directory not found.')
-}
+  throw new Error('Terminfo directory not found.');
+};
 
-Tput._tprefix = Tput.prototype._tprefix = function (prefix, term, soft) {
-  if (!prefix) {
-    return
-  }
+Tput._tprefix =
+Tput.prototype._tprefix = function(prefix, term, soft) {
+  if (!prefix) return;
 
-  let file, dir, i, sdiff, sfile, list
+  var file
+    , dir
+    , i
+    , sdiff
+    , sfile
+    , list;
 
   if (Array.isArray(prefix)) {
     for (i = 0; i < prefix.length; i++) {
-      file = this._tprefix(prefix[i], term, soft)
-      if (file) {
-        return file
-      }
+      file = this._tprefix(prefix[i], term, soft);
+      if (file) return file;
     }
-    return
+    return;
   }
 
-  const find = function (word) {
-    let file, ch
+  var find = function(word) {
+    var file, ch;
 
-    file = path.resolve(prefix, word[0])
+    file = path.resolve(prefix, word[0]);
     try {
-      fs.statSync(file)
-      return file
-    } catch (e) {}
-
-    ch = word[0].charCodeAt(0).toString(16)
-    if (ch.length < 2) {
-      ch = '0' + ch
+      fs.statSync(file);
+      return file;
+    } catch (e) {
+      ;
     }
 
-    file = path.resolve(prefix, ch)
+    ch = word[0].charCodeAt(0).toString(16);
+    if (ch.length < 2) ch = '0' + ch;
+
+    file = path.resolve(prefix, ch);
     try {
-      fs.statSync(file)
-      return file
-    } catch (e) {}
-  }
+      fs.statSync(file);
+      return file;
+    } catch (e) {
+      ;
+    }
+  };
 
   if (!term) {
     // Make sure the directory's sub-directories
     // are all one-letter, or hex digits.
     // return find('x') ? prefix : null;
     try {
-      dir = fs.readdirSync(prefix).filter(function (file) {
-        return file.length !== 1 && !/^[0-9a-fA-F]{2}$/.test(file)
-      })
+      dir = fs.readdirSync(prefix).filter(function(file) {
+        return file.length !== 1 && !/^[0-9a-fA-F]{2}$/.test(file);
+      });
       if (!dir.length) {
-        return prefix
+        return prefix;
       }
-    } catch (e) {}
-    return
+    } catch (e) {
+      ;
+    }
+    return;
   }
 
-  term = path.basename(term)
-  dir = find(term)
+  term = path.basename(term);
+  dir = find(term);
 
-  if (!dir) {
-    return
-  }
+  if (!dir) return;
 
   if (soft) {
     try {
-      list = fs.readdirSync(dir)
+      list = fs.readdirSync(dir);
     } catch (e) {
-      return
+      return;
     }
 
-    list.forEach(function (file) {
+    list.forEach(function(file) {
       if (file.indexOf(term) === 0) {
-        const diff = file.length - term.length
+        var diff = file.length - term.length;
         if (!sfile || diff < sdiff) {
-          sdiff = diff
-          sfile = file
+          sdiff = diff;
+          sfile = file;
         }
       }
-    })
+    });
 
-    return sfile && (soft || sdiff === 0) ? path.resolve(dir, sfile) : null
+    return sfile && (soft || sdiff === 0)
+      ? path.resolve(dir, sfile)
+      : null;
   }
 
-  file = path.resolve(dir, term)
+  file = path.resolve(dir, term);
   try {
-    fs.statSync(file)
-    return file
-  } catch (e) {}
-}
+    fs.statSync(file);
+    return file;
+  } catch (e) {
+    ;
+  }
+};
 
 /**
  * Terminfo Parser
  * All shorts are little-endian
  */
 
-Tput.prototype.parseTerminfo = function (data, file) {
-  let info = {},
-    extended,
-    l = data.length,
-    i = 0,
-    v,
-    o
+Tput.prototype.parseTerminfo = function(data, file) {
+  var info = {}
+    , extended
+    , l = data.length
+    , i = 0
+    , v
+    , o;
 
-  const h = (info.header = {
+  var h = info.header = {
     dataSize: data.length,
     headerSize: 12,
     magicNumber: (data[1] << 8) | data[0],
@@ -317,85 +315,84 @@ Tput.prototype.parseTerminfo = function (data, file) {
     numCount: (data[7] << 8) | data[6],
     strCount: (data[9] << 8) | data[8],
     strTableSize: (data[11] << 8) | data[10]
-  })
+  };
 
-  h.total =
-    h.headerSize +
-    h.namesSize +
-    h.boolCount +
-    h.numCount * 2 +
-    h.strCount * 2 +
-    h.strTableSize
+  h.total = h.headerSize
+    + h.namesSize
+    + h.boolCount
+    + h.numCount * 2
+    + h.strCount * 2
+    + h.strTableSize;
 
-  i += h.headerSize
+  i += h.headerSize;
 
   // Names Section
-  const names = data.toString('ascii', i, i + h.namesSize - 1),
-    parts = names.split('|'),
-    name = parts[0],
-    desc = parts.pop()
+  var names = data.toString('ascii', i, i + h.namesSize - 1)
+    , parts = names.split('|')
+    , name = parts[0]
+    , desc = parts.pop();
 
-  info.name = name
-  info.names = parts
-  info.desc = desc
+  info.name = name;
+  info.names = parts;
+  info.desc = desc;
 
-  info.dir = path.resolve(file, '..', '..')
-  info.file = file
+  info.dir = path.resolve(file, '..', '..');
+  info.file = file;
 
-  i += h.namesSize - 1
+  i += h.namesSize - 1;
 
   // Names is nul-terminated.
-  assert.equal(data[i], 0)
-  i++
+  assert.equal(data[i], 0);
+  i++;
 
   // Booleans Section
   // One byte for each flag
   // Same order as <term.h>
-  info.bools = {}
-  l = i + h.boolCount
-  o = 0
+  info.bools = {};
+  l = i + h.boolCount;
+  o = 0;
   for (; i < l; i++) {
-    v = Tput.bools[o++]
-    info.bools[v] = data[i] === 1
+    v = Tput.bools[o++];
+    info.bools[v] = data[i] === 1;
   }
 
   // Null byte in between to make sure numbers begin on an even byte.
   if (i % 2) {
-    assert.equal(data[i], 0)
-    i++
+    assert.equal(data[i], 0);
+    i++;
   }
 
   // Numbers Section
-  info.numbers = {}
-  l = i + h.numCount * 2
-  o = 0
+  info.numbers = {};
+  l = i + h.numCount * 2;
+  o = 0;
   for (; i < l; i += 2) {
-    v = Tput.numbers[o++]
-    if (data[i + 1] === 0xff && data[i] === 0xff) {
-      info.numbers[v] = -1
+    v = Tput.numbers[o++];
+    if (data[i + 1] === 0xFF && data[i] === 0xFF) {
+      info.numbers[v] = -1;
     } else {
-      info.numbers[v] = (data[i + 1] << 8) | data[i]
+      info.numbers[v] = (data[i + 1] << 8) | data[i];
     }
   }
 
   // Strings Section
-  info.strings = {}
-  l = i + h.strCount * 2
-  o = 0
+  info.strings = {};
+  l = i + h.strCount * 2;
+  o = 0;
   for (; i < l; i += 2) {
-    v = Tput.strings[o++]
-    if (data[i + 1] === 0xff && data[i] === 0xff) {
-      info.strings[v] = -1
+    v = Tput.strings[o++];
+    if (data[i + 1] === 0xFF && data[i] === 0xFF) {
+      info.strings[v] = -1;
     } else {
-      info.strings[v] = (data[i + 1] << 8) | data[i]
+      info.strings[v] = (data[i + 1] << 8) | data[i];
     }
   }
 
   // String Table
-  Object.keys(info.strings).forEach(function (key) {
+  Object.keys(info.strings).forEach(function(key) {
     if (info.strings[key] === -1) {
-      delete info.strings[key]
-      return
+      delete info.strings[key];
+      return;
     }
 
     // Workaround: fix an odd bug in the screen-256color terminfo where it tries
@@ -403,49 +400,47 @@ Tput.prototype.parseTerminfo = function (data, file) {
     // TODO: Possibly handle errors gracefully below, as well as in the
     // extended info. Also possibly do: `if (info.strings[key] >= data.length)`.
     if (info.strings[key] === 65534) {
-      delete info.strings[key]
-      return
+      delete info.strings[key];
+      return;
     }
 
-    let s = i + info.strings[key],
-      j = s
+    var s = i + info.strings[key]
+      , j = s;
 
-    while (data[j]) {
-      j++
-    }
+    while (data[j]) j++;
 
-    assert(j < data.length)
+    assert(j < data.length);
 
-    info.strings[key] = data.toString('ascii', s, j)
-  })
+    info.strings[key] = data.toString('ascii', s, j);
+  });
 
   // Extended Header
   if (this.extended !== false) {
-    i--
-    i += h.strTableSize
+    i--;
+    i += h.strTableSize;
     if (i % 2) {
-      assert.equal(data[i], 0)
-      i++
+      assert.equal(data[i], 0);
+      i++;
     }
-    l = data.length
+    l = data.length;
     if (i < l - 1) {
       try {
-        extended = this.parseExtended(data.slice(i))
+        extended = this.parseExtended(data.slice(i));
       } catch (e) {
         if (this.debug) {
-          throw e
+          throw e;
         }
-        return info
+        return info;
       }
-      info.header.extended = extended.header
-      ;['bools', 'numbers', 'strings'].forEach(function (key) {
-        merge(info[key], extended[key])
-      })
+      info.header.extended = extended.header;
+      ['bools', 'numbers', 'strings'].forEach(function(key) {
+        merge(info[key], extended[key]);
+      });
     }
   }
 
-  return info
-}
+  return info;
+};
 
 /**
  * Extended Parsing
@@ -497,12 +492,12 @@ Tput.prototype.parseTerminfo = function (data, file) {
 //   h.symOffsetCount = h.strTableSize - h.strCount;
 //   h.symOffsetSize = (h.strTableSize - h.strCount) * 2;
 
-Tput.prototype.parseExtended = function (data) {
-  let info = {},
-    l = data.length,
-    i = 0
+Tput.prototype.parseExtended = function(data) {
+  var info = {}
+    , l = data.length
+    , i = 0;
 
-  const h = (info.header = {
+  var h = info.header = {
     dataSize: data.length,
     headerSize: 10,
     boolCount: (data[i + 1] << 8) | data[i + 0],
@@ -510,253 +505,240 @@ Tput.prototype.parseExtended = function (data) {
     strCount: (data[i + 5] << 8) | data[i + 4],
     strTableSize: (data[i + 7] << 8) | data[i + 6],
     lastStrTableOffset: (data[i + 9] << 8) | data[i + 8]
-  })
+  };
 
   // h.symOffsetCount = h.strTableSize - h.strCount;
 
-  h.total =
-    h.headerSize +
-    h.boolCount +
-    h.numCount * 2 +
-    h.strCount * 2 +
-    h.strTableSize
+  h.total = h.headerSize
+    + h.boolCount
+    + h.numCount * 2
+    + h.strCount * 2
+    + h.strTableSize;
 
-  i += h.headerSize
+  i += h.headerSize;
 
   // Booleans Section
   // One byte for each flag
-  const _bools = []
-  l = i + h.boolCount
+  var _bools = [];
+  l = i + h.boolCount;
   for (; i < l; i++) {
-    _bools.push(data[i] === 1)
+    _bools.push(data[i] === 1);
   }
 
   // Null byte in between to make sure numbers begin on an even byte.
   if (i % 2) {
-    assert.equal(data[i], 0)
-    i++
+    assert.equal(data[i], 0);
+    i++;
   }
 
   // Numbers Section
-  const _numbers = []
-  l = i + h.numCount * 2
+  var _numbers = [];
+  l = i + h.numCount * 2;
   for (; i < l; i += 2) {
-    if (data[i + 1] === 0xff && data[i] === 0xff) {
-      _numbers.push(-1)
+    if (data[i + 1] === 0xFF && data[i] === 0xFF) {
+      _numbers.push(-1);
     } else {
-      _numbers.push((data[i + 1] << 8) | data[i])
+      _numbers.push((data[i + 1] << 8) | data[i]);
     }
   }
 
   // Strings Section
-  const _strings = []
-  l = i + h.strCount * 2
+  var _strings = [];
+  l = i + h.strCount * 2;
   for (; i < l; i += 2) {
-    if (data[i + 1] === 0xff && data[i] === 0xff) {
-      _strings.push(-1)
+    if (data[i + 1] === 0xFF && data[i] === 0xFF) {
+      _strings.push(-1);
     } else {
-      _strings.push((data[i + 1] << 8) | data[i])
+      _strings.push((data[i + 1] << 8) | data[i]);
     }
   }
 
   // Pass over the sym offsets and get to the string table.
-  i = data.length - h.lastStrTableOffset
+  i = data.length - h.lastStrTableOffset;
   // Might be better to do this instead if the file has trailing bytes:
   // i += h.symOffsetCount * 2;
 
   // String Table
-  let high = 0
-  _strings.forEach(function (offset, k) {
+  var high = 0;
+  _strings.forEach(function(offset, k) {
     if (offset === -1) {
-      _strings[k] = ''
-      return
+      _strings[k] = '';
+      return;
     }
 
-    let s = i + offset,
-      j = s
+    var s = i + offset
+      , j = s;
 
-    while (data[j]) {
-      j++
-    }
+    while (data[j]) j++;
 
-    assert(j < data.length)
+    assert(j < data.length);
 
     // Find out where the string table ends by
     // getting the highest string length.
     if (high < j - i) {
-      high = j - i
+      high = j - i;
     }
 
-    _strings[k] = data.toString('ascii', s, j)
-  })
+    _strings[k] = data.toString('ascii', s, j);
+  });
 
   // Symbol Table
   // Add one to the highest string length because we didn't count \0.
-  i += high + 1
-  l = data.length
+  i += high + 1;
+  l = data.length;
 
-  let sym = [],
-    j
+  var sym = []
+    , j;
 
   for (; i < l; i++) {
-    j = i
-    while (data[j]) {
-      j++
-    }
-    sym.push(data.toString('ascii', i, j))
-    i = j
+    j = i;
+    while (data[j]) j++;
+    sym.push(data.toString('ascii', i, j));
+    i = j;
   }
 
   // Identify by name
-  j = 0
+  j = 0;
 
-  info.bools = {}
-  _bools.forEach(function (bool) {
-    info.bools[sym[j++]] = bool
-  })
+  info.bools = {};
+  _bools.forEach(function(bool) {
+    info.bools[sym[j++]] = bool;
+  });
 
-  info.numbers = {}
-  _numbers.forEach(function (number) {
-    info.numbers[sym[j++]] = number
-  })
+  info.numbers = {};
+  _numbers.forEach(function(number) {
+    info.numbers[sym[j++]] = number;
+  });
 
-  info.strings = {}
-  _strings.forEach(function (string) {
-    info.strings[sym[j++]] = string
-  })
+  info.strings = {};
+  _strings.forEach(function(string) {
+    info.strings[sym[j++]] = string;
+  });
 
   // Should be the very last bit of data.
-  assert.equal(i, data.length)
+  assert.equal(i, data.length);
 
-  return info
-}
+  return info;
+};
 
-Tput.prototype.compileTerminfo = function (term) {
-  return this.compile(this.readTerminfo(term))
-}
+Tput.prototype.compileTerminfo = function(term) {
+  return this.compile(this.readTerminfo(term));
+};
 
-Tput.prototype.injectTerminfo = function (term) {
-  return this.inject(this.compileTerminfo(term))
-}
+Tput.prototype.injectTerminfo = function(term) {
+  return this.inject(this.compileTerminfo(term));
+};
 
 /**
  * Compiler - terminfo cap->javascript
  */
 
-Tput.prototype.compile = function (info) {
-  const self = this
+Tput.prototype.compile = function(info) {
+  var self = this;
 
   if (!info) {
-    throw new Error('Terminal not found.')
+    throw new Error('Terminal not found.');
   }
 
-  this.detectFeatures(info)
+  this.detectFeatures(info);
 
-  this._debug(info)
+  this._debug(info);
 
-  info.all = {}
-  info.methods = {}
+  info.all = {};
+  info.methods = {};
 
-  ;['bools', 'numbers', 'strings'].forEach(function (type) {
-    Object.keys(info[type]).forEach(function (key) {
-      info.all[key] = info[type][key]
-      info.methods[key] = self._compile(info, key, info.all[key])
-    })
-  })
+  ['bools', 'numbers', 'strings'].forEach(function(type) {
+    Object.keys(info[type]).forEach(function(key) {
+      info.all[key] = info[type][key];
+      info.methods[key] = self._compile(info, key, info.all[key]);
+    });
+  });
 
-  Tput.bools.forEach(function (key) {
-    if (info.methods[key] == null) {
-      info.methods[key] = false
-    }
-  })
+  Tput.bools.forEach(function(key) {
+    if (info.methods[key] == null) info.methods[key] = false;
+  });
 
-  Tput.numbers.forEach(function (key) {
-    if (info.methods[key] == null) {
-      info.methods[key] = -1
-    }
-  })
+  Tput.numbers.forEach(function(key) {
+    if (info.methods[key] == null) info.methods[key] = -1;
+  });
 
-  Tput.strings.forEach(function (key) {
-    if (!info.methods[key]) {
-      info.methods[key] = noop
-    }
-  })
+  Tput.strings.forEach(function(key) {
+    if (!info.methods[key]) info.methods[key] = noop;
+  });
 
-  Object.keys(info.methods).forEach(function (key) {
-    if (!Tput.alias[key]) {
-      return
-    }
-    Tput.alias[key].forEach(function (alias) {
-      info.methods[alias] = info.methods[key]
-    })
+  Object.keys(info.methods).forEach(function(key) {
+    if (!Tput.alias[key]) return;
+    Tput.alias[key].forEach(function(alias) {
+      info.methods[alias] = info.methods[key];
+    });
     // Could just use:
     // Object.keys(Tput.aliasMap).forEach(function(key) {
     //   info.methods[key] = info.methods[Tput.aliasMap[key]];
     // });
-  })
+  });
 
-  return info
-}
+  return info;
+};
 
-Tput.prototype.inject = function (info) {
-  const self = this,
-    methods = info.methods || info
+Tput.prototype.inject = function(info) {
+  var self = this
+    , methods = info.methods || info;
 
-  Object.keys(methods).forEach(function (key) {
+  Object.keys(methods).forEach(function(key) {
     if (typeof methods[key] !== 'function') {
-      self[key] = methods[key]
-      return
-    }
-    self[key] = function () {
-      const args = Array.prototype.slice.call(arguments)
-      return methods[key].call(self, args)
-    }
-  })
-
-  this.info = info
-  this.all = info.all
-  this.methods = info.methods
-  this.bools = info.bools
-  this.numbers = info.numbers
-  this.strings = info.strings
+      self[key] = methods[key];
+      return;
+    }
+    self[key] = function() {
+      var args = Array.prototype.slice.call(arguments);
+      return methods[key].call(self, args);
+    };
+  });
+
+  this.info = info;
+  this.all = info.all;
+  this.methods = info.methods;
+  this.bools = info.bools;
+  this.numbers = info.numbers;
+  this.strings = info.strings;
 
   if (!~info.names.indexOf(this.terminal)) {
-    this.terminal = info.name
+    this.terminal = info.name;
   }
 
-  this.features = info.features
-  Object.keys(info.features).forEach(function (key) {
+  this.features = info.features;
+  Object.keys(info.features).forEach(function(key) {
     if (key === 'padding') {
       if (!info.features.padding && self.options.padding !== true) {
-        self.padding = false
+        self.padding = false;
       }
-      return
+      return;
     }
-    self[key] = info.features[key]
-  })
-}
+    self[key] = info.features[key];
+  });
+};
 
 // See:
 // ~/ncurses/ncurses/tinfo/lib_tparm.c
 // ~/ncurses/ncurses/tinfo/comp_scan.c
-Tput.prototype._compile = function (info, key, str) {
-  let v
+Tput.prototype._compile = function(info, key, str) {
+  var v;
 
-  this._debug('Compiling %s: %s', key, JSON.stringify(str))
+  this._debug('Compiling %s: %s', key, JSON.stringify(str));
 
   switch (typeof str) {
     case 'boolean':
-      return str
+      return str;
     case 'number':
-      return str
+      return str;
     case 'string':
-      break
+      break;
     default:
-      return noop
+      return noop;
   }
 
   if (!str) {
-    return noop
+    return noop;
   }
 
   // See:
@@ -764,183 +746,171 @@ Tput.prototype._compile = function (info, key, str) {
   // ~/ncurses/progs/tset.c - set_init() - L992
   if (key === 'init_file' || key === 'reset_file') {
     try {
-      str = fs.readFileSync(str, 'utf8')
+      str = fs.readFileSync(str, 'utf8');
       if (this.debug) {
         v = ('return ' + JSON.stringify(str) + ';')
           .replace(/\x1b/g, '\\x1b')
           .replace(/\r/g, '\\r')
-          .replace(/\n/g, '\\n')
-        process.stdout.write(v + '\n')
-      }
-      return function () {
-        return str
+          .replace(/\n/g, '\\n');
+        process.stdout.write(v + '\n');
       }
+      return function() { return str; };
     } catch (e) {
-      return noop
+      return noop;
     }
   }
 
-  let tkey = info.name + '.' + key,
-    header = 'var v, dyn = {}, stat = {}, stack = [], out = [];',
-    footer = ';return out.join("");',
-    code = header,
-    val = str,
-    buff = '',
-    cap,
-    ch,
-    fi,
-    then,
-    els,
-    end
+  var tkey = info.name + '.' + key
+    , header = 'var v, dyn = {}, stat = {}, stack = [], out = [];'
+    , footer = ';return out.join("");'
+    , code = header
+    , val = str
+    , buff = ''
+    , cap
+    , ch
+    , fi
+    , then
+    , els
+    , end;
 
   function read(regex, no) {
-    cap = regex.exec(val)
-    if (!cap) {
-      return
-    }
-    val = val.substring(cap[0].length)
-    ch = cap[1]
-    if (!no) {
-      clear()
-    }
-    return cap
+    cap = regex.exec(val);
+    if (!cap) return;
+    val = val.substring(cap[0].length);
+    ch = cap[1];
+    if (!no) clear();
+    return cap;
   }
 
   function stmt(c) {
     if (code[code.length - 1] === ',') {
-      code = code.slice(0, -1)
+      code = code.slice(0, -1);
     }
-    code += c
+    code += c;
   }
 
   function expr(c) {
-    code += c + ','
+    code += c + ',';
   }
 
   function echo(c) {
-    if (c === '""') {
-      return
-    }
-    expr('out.push(' + c + ')')
+    if (c === '""') return;
+    expr('out.push(' + c + ')');
   }
 
   function print(c) {
-    buff += c
+    buff += c;
   }
 
   function clear() {
     if (buff) {
-      echo(JSON.stringify(buff).replace(/\\u00([0-9a-fA-F]{2})/g, '\\x$1'))
-      buff = ''
+      echo(JSON.stringify(buff).replace(/\\u00([0-9a-fA-F]{2})/g, '\\x$1'));
+      buff = '';
     }
   }
 
   while (val) {
     // Ignore newlines
     if (read(/^\n /, true)) {
-      continue
+      continue;
     }
 
     // '^A' -> ^A
     if (read(/^\^(.)/i, true)) {
       if (!(ch >= ' ' && ch <= '~')) {
-        this._debug('%s: bad caret char.', tkey)
+        this._debug('%s: bad caret char.', tkey);
         // NOTE: ncurses appears to simply
         // continue in this situation, but
         // I could be wrong.
-        print(cap[0])
-        continue
+        print(cap[0]);
+        continue;
       }
       if (ch === '?') {
-        ch = '\x7f'
+        ch = '\x7f';
       } else {
-        ch = ch.charCodeAt(0) & 31
-        if (ch === 0) {
-          ch = 128
-        }
-        ch = String.fromCharCode(ch)
+        ch = ch.charCodeAt(0) & 31;
+        if (ch === 0) ch = 128;
+        ch = String.fromCharCode(ch);
       }
-      print(ch)
-      continue
+      print(ch);
+      continue;
     }
 
     // 3 octal digits -> character
     if (read(/^\\([0-7]{3})/, true)) {
-      print(String.fromCharCode(parseInt(ch, 8)))
-      continue
+      print(String.fromCharCode(parseInt(ch, 8)));
+      continue;
     }
 
     // '\e' -> ^[
     // '\n' -> \n
     // '\r' -> \r
     // '\0' -> \x80 (special case)
-    if (read(/^\\([eEnlrtbfs^\\,:0]|.)/, true)) {
+    if (read(/^\\([eEnlrtbfs\^\\,:0]|.)/, true)) {
       switch (ch) {
         case 'e':
         case 'E':
-          ch = '\x1b'
-          break
+          ch = '\x1b';
+          break;
         case 'n':
-          ch = '\n'
-          break
+          ch = '\n';
+          break;
         case 'l':
-          ch = '\x85'
-          break
+          ch = '\x85';
+          break;
         case 'r':
-          ch = '\r'
-          break
+          ch = '\r';
+          break;
         case 't':
-          ch = '\t'
-          break
+          ch = '\t';
+          break;
         case 'b':
-          ch = '\x08'
-          break
+          ch = '\x08';
+          break;
         case 'f':
-          ch = '\x0c'
-          break
+          ch = '\x0c';
+          break;
         case 's':
-          ch = ' '
-          break
+          ch = ' ';
+          break;
         case '^':
-          ch = '^'
-          break
+          ch = '^';
+          break;
         case '\\':
-          ch = '\\'
-          break
+          ch = '\\';
+          break;
         case ',':
-          ch = ','
-          break
+          ch = ',';
+          break;
         case ':':
-          ch = ':'
-          break
+          ch = ':';
+          break;
         case '0':
-          ch = '\x80'
-          break
+          ch = '\x80';
+          break;
         case 'a':
-          ch = '\x07'
-          break
+          ch = '\x07';
+          break;
         default:
-          this._debug('%s: bad backslash char.', tkey)
-          ch = cap[0]
-          break
+          this._debug('%s: bad backslash char.', tkey);
+          ch = cap[0];
+          break;
       }
-      print(ch)
-      continue
+      print(ch);
+      continue;
     }
 
     // $<5> -> padding
     // e.g. flash_screen: '\u001b[?5h$<100/>\u001b[?5l',
-    if (read(/^\$<(\d+)([*/]{0,2})>/, true)) {
-      if (this.padding) {
-        print(cap[0])
-      }
-      continue
+    if (read(/^\$<(\d+)([*\/]{0,2})>/, true)) {
+      if (this.padding) print(cap[0]);
+      continue;
     }
 
     // %%   outputs `%'
     if (read(/^%%/, true)) {
-      print('%')
-      continue
+      print('%');
+      continue;
     }
 
     // %[[:]flags][width[.precision]][doxXs]
@@ -955,44 +925,42 @@ Tput.prototype._compile = function (info, key, str) {
     // %s   print pop() like %s in printf
     if (read(/^%((?::-|[+# ]){1,4})?(\d+(?:\.\d+)?)?([doxXsc])/)) {
       if (this.printf || cap[1] || cap[2] || ~'oxX'.indexOf(cap[3])) {
-        echo('sprintf("' + cap[0].replace(':-', '-') + '", stack.pop())')
+        echo('sprintf("'+ cap[0].replace(':-', '-') + '", stack.pop())');
       } else if (cap[3] === 'c') {
-        echo(
-          '(v = stack.pop(), isFinite(v) ' +
-            '? String.fromCharCode(v || 0200) : "")'
-        )
+        echo('(v = stack.pop(), isFinite(v) '
+          + '? String.fromCharCode(v || 0200) : "")');
       } else {
-        echo('stack.pop()')
+        echo('stack.pop()');
       }
-      continue
+      continue;
     }
 
     // %p[1-9]
     //   push i'th parameter
     if (read(/^%p([1-9])/)) {
-      expr('(stack.push(v = params[' + (ch - 1) + ']), v)')
-      continue
+      expr('(stack.push(v = params[' + (ch - 1) + ']), v)');
+      continue;
     }
 
     // %P[a-z]
     //   set dynamic variable [a-z] to pop()
     if (read(/^%P([a-z])/)) {
-      expr('dyn.' + ch + ' = stack.pop()')
-      continue
+      expr('dyn.' + ch + ' = stack.pop()');
+      continue;
     }
 
     // %g[a-z]
     //   get dynamic variable [a-z] and push it
     if (read(/^%g([a-z])/)) {
-      expr('(stack.push(dyn.' + ch + '), dyn.' + ch + ')')
-      continue
+      expr('(stack.push(dyn.' + ch + '), dyn.' + ch + ')');
+      continue;
     }
 
     // %P[A-Z]
     //   set static variable [a-z] to pop()
     if (read(/^%P([A-Z])/)) {
-      expr('stat.' + ch + ' = stack.pop()')
-      continue
+      expr('stat.' + ch + ' = stack.pop()');
+      continue;
     }
 
     // %g[A-Z]
@@ -1003,29 +971,29 @@ Tput.prototype._compile = function (info, key, str) {
     //   documented in other implementations.  Relying on it will adversely
     //   impact portability to other implementations.
     if (read(/^%g([A-Z])/)) {
-      expr('(stack.push(v = stat.' + ch + '), v)')
-      continue
+      expr('(stack.push(v = stat.' + ch + '), v)');
+      continue;
     }
 
     // %'c' char constant c
     // NOTE: These are stored as c chars, exemplified by:
     // cursor_address: "\u001b=%p1%' '%+%c%p2%' '%+%c"
     if (read(/^%'(.)'/)) {
-      expr('(stack.push(v = ' + ch.charCodeAt(0) + '), v)')
-      continue
+      expr('(stack.push(v = ' + ch.charCodeAt(0) + '), v)');
+      continue;
     }
 
     // %{nn}
     //   integer constant nn
     if (read(/^%\{(\d+)\}/)) {
-      expr('(stack.push(v = ' + ch + '), v)')
-      continue
+      expr('(stack.push(v = ' + ch + '), v)');
+      continue;
     }
 
     // %l   push strlen(pop)
     if (read(/^%l/)) {
-      expr('(stack.push(v = (stack.pop() || "").length || 0), v)')
-      continue
+      expr('(stack.push(v = (stack.pop() || "").length || 0), v)');
+      continue;
     }
 
     // %+ %- %* %/ %m
@@ -1034,39 +1002,30 @@ Tput.prototype._compile = function (info, key, str) {
     //   bit operations (AND, OR and exclusive-OR): push(pop() op pop())
     // %= %> %<
     //   logical operations: push(pop() op pop())
-    if (read(/^%([+\-*/m&|^=><])/)) {
-      if (ch === '=') {
-        ch = '==='
-      } else if (ch === 'm') {
-        ch = '%'
-      }
-      expr(
-        '(v = stack.pop(),' +
-          ' stack.push(v = (stack.pop() ' +
-          ch +
-          ' v) || 0),' +
-          ' v)'
-      )
-      continue
+    if (read(/^%([+\-*\/m&|\^=><])/)) {
+      if (ch === '=') ch = '===';
+      else if (ch === 'm') ch = '%';
+      expr('(v = stack.pop(),'
+        + ' stack.push(v = (stack.pop() ' + ch + ' v) || 0),'
+        + ' v)');
+      continue;
     }
 
     // %A, %O
     //   logical AND and OR operations (for conditionals)
     if (read(/^%([AO])/)) {
       // Are we supposed to store the result on the stack?
-      expr(
-        '(stack.push(v = (stack.pop() ' +
-          (ch === 'A' ? '&&' : '||') +
-          ' stack.pop())), v)'
-      )
-      continue
+      expr('(stack.push(v = (stack.pop() '
+        + (ch === 'A' ? '&&' : '||')
+        + ' stack.pop())), v)');
+      continue;
     }
 
     // %! %~
     //   unary operations (logical and bit complement): push(op pop())
     if (read(/^%([!~])/)) {
-      expr('(stack.push(v = ' + ch + 'stack.pop()), v)')
-      continue
+      expr('(stack.push(v = ' + ch + 'stack.pop()), v)');
+      continue;
     }
 
     // %i   add 1 to first two parameters (for ANSI terminals)
@@ -1077,8 +1036,8 @@ Tput.prototype._compile = function (info, key, str) {
       // just be a bad terminfo string.
       // user6: "\u001b[%i%d;%dR" - possibly a termcap-style string.
       // expr('(params[0] |= 0, params[1] |= 0, params[0]++, params[1]++)');
-      expr('(params[0]++, params[1]++)')
-      continue
+      expr('(params[0]++, params[1]++)');
+      continue;
     }
 
     // %? expr %t thenpart %e elsepart %;
@@ -1090,13 +1049,13 @@ Tput.prototype._compile = function (info, key, str) {
     //     %? c1 %t b1 %e c2 %t b2 %e c3 %t b3 %e c4 %t b4 %e %;
     //   where ci are conditions, bi are bodies.
     if (read(/^%\?/)) {
-      end = -1
-      stmt(';if (')
-      continue
+      end = -1;
+      stmt(';if (');
+      continue;
     }
 
     if (read(/^%t/)) {
-      end = -1
+      end = -1;
       // Technically this is supposed to pop everything off the stack that was
       // pushed onto the stack after the if statement, see man terminfo.
       // Right now, we don't pop anything off. This could cause compat issues.
@@ -1104,165 +1063,150 @@ Tput.prototype._compile = function (info, key, str) {
       // is added, to the time the then statement is added, and pop off
       // the appropriate number of elements.
       // while (pushed--) expr('stack.pop()');
-      stmt(') {')
-      continue
+      stmt(') {');
+      continue;
     }
 
     // Terminfo does elseif's like
     // this: %?[expr]%t...%e[expr]%t...%;
     if (read(/^%e/)) {
-      fi = val.indexOf('%?')
-      then = val.indexOf('%t')
-      els = val.indexOf('%e')
-      end = val.indexOf('%;')
-      if (end === -1) {
-        end = Infinity
-      }
-      if (
-        then !== -1 &&
-        then < end &&
-        (fi === -1 || then < fi) &&
-        (els === -1 || then < els)
-      ) {
-        stmt('} else if (')
+      fi = val.indexOf('%?');
+      then = val.indexOf('%t');
+      els = val.indexOf('%e');
+      end = val.indexOf('%;');
+      if (end === -1) end = Infinity;
+      if (then !== -1 && then < end
+          && (fi === -1 || then < fi)
+          && (els === -1 || then < els)) {
+        stmt('} else if (');
       } else {
-        stmt('} else {')
+        stmt('} else {');
       }
-      continue
+      continue;
     }
 
     if (read(/^%;/)) {
-      end = null
-      stmt('}')
-      continue
+      end = null;
+      stmt('}');
+      continue;
     }
 
-    buff += val[0]
-    val = val.substring(1)
+    buff += val[0];
+    val = val.substring(1);
   }
 
   // Clear the buffer of any remaining text.
-  clear()
+  clear();
 
   // Some terminfos (I'm looking at you, atari-color), don't end an if
   // statement. It's assumed terminfo will automatically end it for
   // them, because they are a bunch of lazy bastards.
   if (end != null) {
-    stmt('}')
+    stmt('}');
   }
 
   // Add the footer.
-  stmt(footer)
+  stmt(footer);
 
   // Optimize and cleanup generated code.
-  v = code.slice(header.length, -footer.length)
+  v = code.slice(header.length, -footer.length);
   if (!v.length) {
-    code = 'return "";'
-  } else if ((v = /^out\.push\(("(?:[^"]|\\")+")\)$/.exec(v))) {
-    code = 'return ' + v[1] + ';'
+    code = 'return "";';
+  } else if (v = /^out\.push\(("(?:[^"]|\\")+")\)$/.exec(v)) {
+    code = 'return ' + v[1] + ';';
   } else {
     // Turn `(stack.push(v = params[0]), v),out.push(stack.pop())`
     // into `out.push(params[0])`.
     code = code.replace(
       /\(stack\.push\(v = params\[(\d+)\]\), v\),out\.push\(stack\.pop\(\)\)/g,
-      'out.push(params[$1])'
-    )
+      'out.push(params[$1])');
 
     // Remove unnecessary variable initializations.
-    v = code.slice(header.length, -footer.length)
-    if (!~v.indexOf('v = ')) {
-      code = code.replace('v, ', '')
-    }
-    if (!~v.indexOf('dyn')) {
-      code = code.replace('dyn = {}, ', '')
-    }
-    if (!~v.indexOf('stat')) {
-      code = code.replace('stat = {}, ', '')
-    }
-    if (!~v.indexOf('stack')) {
-      code = code.replace('stack = [], ', '')
-    }
+    v = code.slice(header.length, -footer.length);
+    if (!~v.indexOf('v = ')) code = code.replace('v, ', '');
+    if (!~v.indexOf('dyn')) code = code.replace('dyn = {}, ', '');
+    if (!~v.indexOf('stat')) code = code.replace('stat = {}, ', '');
+    if (!~v.indexOf('stack')) code = code.replace('stack = [], ', '');
 
     // Turn `var out = [];out.push("foo"),` into `var out = ["foo"];`.
     code = code.replace(
       /out = \[\];out\.push\(("(?:[^"]|\\")+")\),/,
-      'out = [$1];'
-    )
+      'out = [$1];');
   }
 
   // Terminfos `wyse350-vb`, and `wy350-w`
   // seem to have a few broken strings.
   if (str === '\u001b%?') {
-    code = 'return "\\x1b";'
+    code = 'return "\\x1b";';
   }
 
   if (this.debug) {
     v = code
       .replace(/\x1b/g, '\\x1b')
       .replace(/\r/g, '\\r')
-      .replace(/\n/g, '\\n')
-    process.stdout.write(v + '\n')
+      .replace(/\n/g, '\\n');
+    process.stdout.write(v + '\n');
   }
 
   try {
     if (this.options.stringify && code.indexOf('return ') === 0) {
-      return new Function('', code)()
+      return new Function('', code)();
     }
     return this.printf || ~code.indexOf('sprintf(')
       ? new Function('sprintf, params', code).bind(null, sprintf)
-      : new Function('params', code)
+      : new Function('params', code);
   } catch (e) {
-    console.error('')
-    console.error('Error on %s:', tkey)
-    console.error(JSON.stringify(str))
-    console.error('')
-    console.error(code.replace(/(,|;)/g, '$1\n'))
-    e.stack = e.stack.replace(/\x1b/g, '\\x1b')
-    throw e
+    console.error('');
+    console.error('Error on %s:', tkey);
+    console.error(JSON.stringify(str));
+    console.error('');
+    console.error(code.replace(/(,|;)/g, '$1\n'));
+    e.stack = e.stack.replace(/\x1b/g, '\\x1b');
+    throw e;
   }
-}
+};
 
 // See: ~/ncurses/ncurses/tinfo/lib_tputs.c
-Tput.prototype._print = function (code, print, done) {
-  const xon = !this.bools.needs_xon_xoff || this.bools.xon_xoff
+Tput.prototype._print = function(code, print, done) {
+  var xon = !this.bools.needs_xon_xoff || this.bools.xon_xoff;
 
-  print = print || write
-  done = done || noop
+  print = print || write;
+  done = done || noop;
 
   if (!this.padding) {
-    print(code)
-    return done()
+    print(code);
+    return done();
   }
 
-  let parts = code.split(/(?=\$<[\d.]+[*/]{0,2}>)/),
-    i = 0
+  var parts = code.split(/(?=\$<[\d.]+[*\/]{0,2}>)/)
+    , i = 0;
 
-  ;(function next() {
+  (function next() {
     if (i === parts.length) {
-      return done()
+      return done();
     }
 
-    let part = parts[i++],
-      padding = /^\$<([\d.]+)([*/]{0,2})>/.exec(part),
-      amount,
-      suffix
-    // , affect;
+    var part = parts[i++]
+      , padding = /^\$<([\d.]+)([*\/]{0,2})>/.exec(part)
+      , amount
+      , suffix;
+      // , affect;
 
     if (!padding) {
-      print(part)
-      return next()
+      print(part);
+      return next();
     }
 
-    part = part.substring(padding[0].length)
-    amount = +padding[1]
-    suffix = padding[2]
+    part = part.substring(padding[0].length);
+    amount = +padding[1];
+    suffix = padding[2];
 
     // A `/'  suffix indicates  that  the  padding  is  mandatory and forces a
     // delay of the given number of milliseconds even on devices for which xon
     // is present to indicate flow control.
     if (xon && !~suffix.indexOf('/')) {
-      print(part)
-      return next()
+      print(part);
+      return next();
     }
 
     // A `*' indicates that the padding required is proportional to the number
@@ -1273,7 +1217,7 @@ Tput.prototype._print = function (code, print, done) {
     // computation but does not trigger delays.
     if (~suffix.indexOf('*')) {
       // XXX Disable this for now.
-      amount = amount
+      amount = amount;
       // if (affect = /\x1b\[(\d+)[LM]/.exec(part)) {
       //   amount *= +affect[1];
       // }
@@ -1288,22 +1232,22 @@ Tput.prototype._print = function (code, print, done) {
       // }
     }
 
-    return setTimeout(function () {
-      print(part)
-      return next()
-    }, amount)
-  })()
-}
+    return setTimeout(function() {
+      print(part);
+      return next();
+    }, amount);
+  })();
+};
 
 // A small helper function if we want
 // to easily output text with setTimeouts.
-Tput.print = function () {
-  const fake = {
+Tput.print = function() {
+  var fake = {
     padding: true,
     bools: { needs_xon_xoff: true, xon_xoff: false }
-  }
-  return Tput.prototype._print.apply(fake, arguments)
-}
+  };
+  return Tput.prototype._print.apply(fake, arguments);
+};
 
 /**
  * Termcap
@@ -1315,110 +1259,109 @@ Tput.cpaths = [
   (process.env.HOME || '') + '/.termcap',
   '/usr/share/misc/termcap',
   '/etc/termcap'
-]
+];
 
-Tput.prototype.readTermcap = function (term) {
-  let self = this,
-    terms,
-    term_,
-    root,
-    paths
+Tput.prototype.readTermcap = function(term) {
+  var self = this
+    , terms
+    , term_
+    , root
+    , paths;
 
-  term = term || this.terminal
+  term = term || this.terminal;
 
   // Termcap has a bunch of terminals usually stored in one file/string,
   // so we need to find the one containing our desired terminal.
   if (~term.indexOf(path.sep) && (terms = this._tryCap(path.resolve(term)))) {
-    term_ = path.basename(term).split('.')[0]
+    term_ = path.basename(term).split('.')[0];
     if (terms[process.env.TERM]) {
-      term = process.env.TERM
+      term = process.env.TERM;
     } else if (terms[term_]) {
-      term = term_
+      term = term_;
     } else {
-      term = Object.keys(terms)[0]
+      term = Object.keys(terms)[0];
     }
   } else {
-    paths = Tput.cpaths.slice()
+    paths = Tput.cpaths.slice();
 
     if (this.termcapFile) {
-      paths.unshift(this.termcapFile)
+      paths.unshift(this.termcapFile);
     }
 
-    paths.push(Tput.termcap)
+    paths.push(Tput.termcap);
 
-    terms = this._tryCap(paths, term)
+    terms = this._tryCap(paths, term);
   }
 
   if (!terms) {
-    throw new Error('Cannot find termcap for: ' + term)
+    throw new Error('Cannot find termcap for: ' + term);
   }
 
-  root = terms[term]
+  root = terms[term];
 
   if (this.debug) {
-    this._termcap = terms
+    this._termcap = terms;
   }
 
-  ;(function tc(term) {
+  (function tc(term) {
     if (term && term.strings.tc) {
-      root.inherits = root.inherits || []
-      root.inherits.push(term.strings.tc)
+      root.inherits = root.inherits || [];
+      root.inherits.push(term.strings.tc);
 
-      const names = terms[term.strings.tc]
+      var names = terms[term.strings.tc]
         ? terms[term.strings.tc].names
-        : [term.strings.tc]
+        : [term.strings.tc];
 
-      self._debug('%s inherits from %s.', term.names.join('/'), names.join('/'))
+      self._debug('%s inherits from %s.',
+        term.names.join('/'), names.join('/'));
 
-      const inherit = tc(terms[term.strings.tc])
+      var inherit = tc(terms[term.strings.tc]);
       if (inherit) {
-        ;['bools', 'numbers', 'strings'].forEach(function (type) {
-          merge(term[type], inherit[type])
-        })
+        ['bools', 'numbers', 'strings'].forEach(function(type) {
+          merge(term[type], inherit[type]);
+        });
       }
     }
-    return term
-  })(root)
+    return term;
+  })(root);
 
   // Translate termcap names to terminfo-style names.
-  root = this.translateTermcap(root)
+  root = this.translateTermcap(root);
 
-  return root
-}
+  return root;
+};
 
-Tput.prototype._tryCap = function (file, term) {
-  if (!file) {
-    return
-  }
+Tput.prototype._tryCap = function(file, term) {
+  if (!file) return;
 
-  let terms, data, i
+  var terms
+    , data
+    , i;
 
   if (Array.isArray(file)) {
     for (i = 0; i < file.length; i++) {
-      data = this._tryCap(file[i], term)
-      if (data) {
-        return data
-      }
+      data = this._tryCap(file[i], term);
+      if (data) return data;
     }
-    return
+    return;
   }
 
   // If the termcap string starts with `/`,
   // ncurses considers it a filename.
-  data = file[0] === '/' ? tryRead(file) : file
+  data = file[0] === '/'
+    ? tryRead(file)
+    : file;
 
-  if (!data) {
-    return
-  }
+  if (!data) return;
 
-  terms = this.parseTermcap(data, file)
+  terms = this.parseTermcap(data, file);
 
   if (term && !terms[term]) {
-    return
+    return;
   }
 
-  return terms
-}
+  return terms;
+};
 
 /**
  * Termcap Parser
@@ -1443,133 +1386,131 @@ Tput.prototype._tryCap = function (file, term) {
 //  :sc=\E7:rc=\E8:cs=\E[%i%d;%dr:vs=\E[?7l:ve=\E[?7h:\
 //  :mi:al=\E[L:dc=\E[P:dl=\E[M:ei=\E[4l:im=\E[4h:
 
-Tput.prototype.parseTermcap = function (data, file) {
-  let terms = {},
-    parts,
-    term,
-    entries,
-    fields,
-    field,
-    names,
-    i,
-    j,
-    k
+Tput.prototype.parseTermcap = function(data, file) {
+  var terms = {}
+    , parts
+    , term
+    , entries
+    , fields
+    , field
+    , names
+    , i
+    , j
+    , k;
 
   // remove escaped newlines
-  data = data.replace(/\\\n[ \t]*/g, '')
+  data = data.replace(/\\\n[ \t]*/g, '');
 
   // remove comments
-  data = data.replace(/^#[^\n]+/gm, '')
+  data = data.replace(/^#[^\n]+/gm, '');
 
   // split entries
-  entries = data.trim().split(/\n+/)
+  entries = data.trim().split(/\n+/);
 
   for (i = 0; i < entries.length; i++) {
-    fields = entries[i].split(/:+/)
+    fields = entries[i].split(/:+/);
     for (j = 0; j < fields.length; j++) {
-      field = fields[j].trim()
-      if (!field) {
-        continue
-      }
+      field = fields[j].trim();
+      if (!field) continue;
 
       if (j === 0) {
-        names = field.split('|')
+        names = field.split('|');
         term = {
           name: names[0],
           names: names,
           desc: names.pop(),
-          file: ~file.indexOf(path.sep) ? path.resolve(file) : file,
+          file: ~file.indexOf(path.sep)
+            ? path.resolve(file)
+            : file,
           termcap: true
-        }
+        };
 
         for (k = 0; k < names.length; k++) {
-          terms[names[k]] = term
+          terms[names[k]] = term;
         }
 
-        term.bools = {}
-        term.numbers = {}
-        term.strings = {}
+        term.bools = {};
+        term.numbers = {};
+        term.strings = {};
 
-        continue
+        continue;
       }
 
       if (~field.indexOf('=')) {
-        parts = field.split('=')
-        term.strings[parts[0]] = parts.slice(1).join('=')
+        parts = field.split('=');
+        term.strings[parts[0]] = parts.slice(1).join('=');
       } else if (~field.indexOf('#')) {
-        parts = field.split('#')
-        term.numbers[parts[0]] = +parts.slice(1).join('#')
+        parts = field.split('#');
+        term.numbers[parts[0]] = +parts.slice(1).join('#');
       } else {
-        term.bools[field] = true
+        term.bools[field] = true;
       }
     }
   }
 
-  return terms
-}
+  return terms;
+};
 
 /**
  * Termcap Compiler
  *  man termcap
  */
 
-Tput.prototype.translateTermcap = function (info) {
-  const self = this,
-    out = {}
+Tput.prototype.translateTermcap = function(info) {
+  var self = this
+    , out = {};
 
-  if (!info) {
-    return
-  }
+  if (!info) return;
 
-  this._debug(info)
+  this._debug(info);
 
-  ;['name', 'names', 'desc', 'file', 'termcap'].forEach(function (key) {
-    out[key] = info[key]
-  })
+  ['name', 'names', 'desc', 'file', 'termcap'].forEach(function(key) {
+    out[key] = info[key];
+  });
 
   // Separate aliases for termcap
-  const map = (function () {
-    const out = {}
+  var map = (function() {
+    var out = {};
 
-    Object.keys(Tput.alias).forEach(function (key) {
-      const aliases = Tput.alias[key]
-      out[aliases.termcap] = key
-    })
+    Object.keys(Tput.alias).forEach(function(key) {
+      var aliases = Tput.alias[key];
+      out[aliases.termcap] = key;
+    });
 
-    return out
-  })()
+    return out;
+  })();
 
   // Translate termcap cap names to terminfo cap names.
   // e.g. `up` -> `cursor_up`
-  ;['bools', 'numbers', 'strings'].forEach(function (key) {
-    out[key] = {}
-    Object.keys(info[key]).forEach(function (cap) {
+  ['bools', 'numbers', 'strings'].forEach(function(key) {
+    out[key] = {};
+    Object.keys(info[key]).forEach(function(cap) {
       if (key === 'strings') {
-        info.strings[cap] = self._captoinfo(cap, info.strings[cap], 1)
+        info.strings[cap] = self._captoinfo(cap, info.strings[cap], 1);
       }
       if (map[cap]) {
-        out[key][map[cap]] = info[key][cap]
+        out[key][map[cap]] = info[key][cap];
       } else {
         // NOTE: Possibly include all termcap names
         // in a separate alias.js file. Some are
         // missing from the terminfo alias.js file
         // which is why we have to do this:
         // See: $ man termcap
-        out[key][cap] = info[key][cap]
+        out[key][cap] = info[key][cap];
       }
-    })
-  })
+    });
+  });
 
-  return out
-}
+  return out;
+};
 
-Tput.prototype.compileTermcap = function (term) {
-  return this.compile(this.readTermcap(term))
-}
+Tput.prototype.compileTermcap = function(term) {
+  return this.compile(this.readTermcap(term));
+};
 
-Tput.prototype.injectTermcap = function (term) {
-  return this.inject(this.compileTermcap(term))
-}
+Tput.prototype.injectTermcap = function(term) {
+  return this.inject(this.compileTermcap(term));
+};
 
 /**
  * _nc_captoinfo - ported to javascript directly from ncurses.
@@ -1584,159 +1525,156 @@ Tput.prototype.injectTermcap = function (term) {
  *    pad translations if >=0
  */
 
-Tput.prototype._captoinfo = function (cap, s, parameterized) {
-  const self = this
+Tput.prototype._captoinfo = function(cap, s, parameterized) {
+  var self = this;
 
-  let capstart
+  var capstart;
 
   if (parameterized == null) {
-    parameterized = 0
+    parameterized = 0;
   }
 
-  const MAX_PUSHED = 16,
-    stack = []
+  var MAX_PUSHED = 16
+    , stack = [];
 
-  let stackptr = 0,
-    onstack = 0,
-    seenm = 0,
-    seenn = 0,
-    seenr = 0,
-    param = 1,
-    i = 0,
-    out = ''
+  var stackptr = 0
+    , onstack = 0
+    , seenm = 0
+    , seenn = 0
+    , seenr = 0
+    , param = 1
+    , i = 0
+    , out = '';
 
   function warn() {
-    const args = Array.prototype.slice.call(arguments)
-    args[0] = 'captoinfo: ' + (args[0] || '')
-    return self._debug.apply(self, args)
+    var args = Array.prototype.slice.call(arguments);
+    args[0] = 'captoinfo: ' + (args[0] || '');
+    return self._debug.apply(self, args);
   }
 
   function isdigit(ch) {
-    return ch >= '0' && ch <= '9'
+    return ch >= '0' && ch <= '9';
   }
 
   function isgraph(ch) {
-    return ch > ' ' && ch <= '~'
+    return ch > ' ' && ch <= '~';
   }
 
   // convert a character to a terminfo push
   function cvtchar(sp) {
-    let c = '\0',
-      len
+    var c = '\0'
+      , len;
 
-    let j = i
+    var j = i;
 
     switch (sp[j]) {
       case '\\':
         switch (sp[++j]) {
-          case "'":
+          case '\'':
           case '$':
           case '\\':
           case '%':
-            c = sp[j]
-            len = 2
-            break
+            c = sp[j];
+            len = 2;
+            break;
           case '\0':
-            c = '\\'
-            len = 1
-            break
+            c = '\\';
+            len = 1;
+            break;
           case '0':
           case '1':
           case '2':
           case '3':
-            len = 1
+            len = 1;
             while (isdigit(sp[j])) {
-              c = String.fromCharCode(
-                8 * c.charCodeAt(0) +
-                  (sp[j++].charCodeAt(0) - '0'.charCodeAt(0))
-              )
-              len++
+              c = String.fromCharCode(8 * c.charCodeAt(0)
+                + (sp[j++].charCodeAt(0) - '0'.charCodeAt(0)));
+              len++;
             }
-            break
+            break;
           default:
-            c = sp[j]
-            len = 2
-            break
+            c = sp[j];
+            len = 2;
+            break;
         }
-        break
+        break;
       case '^':
-        c = String.fromCharCode(sp[++j].charCodeAt(0) & 0x1f)
-        len = 2
-        break
+        c = String.fromCharCode(sp[++j].charCodeAt(0) & 0x1f);
+        len = 2;
+        break;
       default:
-        c = sp[j]
-        len = 1
+        c = sp[j];
+        len = 1;
     }
-    if (isgraph(c) && c !== ',' && c !== "'" && c !== '\\' && c !== ':') {
-      out += "%'"
-      out += c
-      out += "'"
+    if (isgraph(c) && c !== ',' && c !== '\'' && c !== '\\' && c !== ':') {
+      out += '%\'';
+      out += c;
+      out += '\'';
     } else {
-      out += '%{'
+      out += '%{';
       if (c.charCodeAt(0) > 99) {
         out += String.fromCharCode(
-          ((c.charCodeAt(0) / 100) | 0) + '0'.charCodeAt(0)
-        )
+          (c.charCodeAt(0) / 100 | 0) + '0'.charCodeAt(0));
       }
       if (c.charCodeAt(0) > 9) {
         out += String.fromCharCode(
-          (((c.charCodeAt(0) / 10) | 0) % 10) + '0'.charCodeAt(0)
-        )
+          (c.charCodeAt(0) / 10 | 0) % 10 + '0'.charCodeAt(0));
       }
-      out += String.fromCharCode((c.charCodeAt(0) % 10) + '0'.charCodeAt(0))
-      out += '}'
+      out += String.fromCharCode(
+        c.charCodeAt(0) % 10 + '0'.charCodeAt(0));
+      out += '}';
     }
 
-    return len
+    return len;
   }
 
   // push n copies of param on the terminfo stack if not already there
   function getparm(parm, n) {
     if (seenr) {
       if (parm === 1) {
-        parm = 2
+        parm = 2;
       } else if (parm === 2) {
-        parm = 1
+        parm = 1;
       }
     }
 
     if (onstack === parm) {
       if (n > 1) {
-        warn('string may not be optimal')
-        out += '%Pa'
+        warn('string may not be optimal');
+        out += '%Pa';
         while (n--) {
-          out += '%ga'
+          out += '%ga';
         }
       }
-      return
+      return;
     }
 
     if (onstack !== 0) {
-      push()
+      push();
     }
 
-    onstack = parm
+    onstack = parm;
 
     while (n--) {
-      out += '%p'
-      out += String.fromCharCode('0'.charCodeAt(0) + parm)
+      out += '%p';
+      out += String.fromCharCode('0'.charCodeAt(0) + parm);
     }
 
     if (seenn && parm < 3) {
-      out += '%{96}%^'
+      out += '%{96}%^';
     }
 
     if (seenm && parm < 3) {
-      out += '%{127}%^'
+      out += '%{127}%^';
     }
   }
 
   // push onstack on to the stack
   function push() {
     if (stackptr >= MAX_PUSHED) {
-      warn('string too complex to convert')
+      warn('string too complex to convert');
     } else {
-      stack[stackptr++] = onstack
+      stack[stackptr++] = onstack;
     }
   }
 
@@ -1744,43 +1682,37 @@ Tput.prototype._captoinfo = function (cap, s, parameterized) {
   function pop() {
     if (stackptr === 0) {
       if (onstack === 0) {
-        warn("I'm confused")
+        warn('I\'m confused');
       } else {
-        onstack = 0
+        onstack = 0;
       }
     } else {
-      onstack = stack[--stackptr]
+      onstack = stack[--stackptr];
     }
-    param++
+    param++;
   }
 
   function see03() {
-    getparm(param, 1)
-    out += '%3d'
-    pop()
+    getparm(param, 1);
+    out += '%3d';
+    pop();
   }
 
   function invalid() {
-    out += '%'
-    i--
-    warn(
-      'unknown %% code %s (%#x) in %s',
-      JSON.stringify(s[i]),
-      s[i].charCodeAt(0),
-      cap
-    )
+    out += '%';
+    i--;
+    warn('unknown %% code %s (%#x) in %s',
+      JSON.stringify(s[i]), s[i].charCodeAt(0), cap);
   }
 
   // skip the initial padding (if we haven't been told not to)
-  capstart = null
-  if (s == null) {
-    s = ''
-  }
+  capstart = null;
+  if (s == null) s = '';
 
   if (parameterized >= 0 && isdigit(s[i])) {
-    for (capstart = i; ; i++) {
+    for (capstart = i;; i++) {
       if (!(isdigit(s[i]) || s[i] === '*' || s[i] === '.')) {
-        break
+        break;
       }
     }
   }
@@ -1788,325 +1720,315 @@ Tput.prototype._captoinfo = function (cap, s, parameterized) {
   while (s[i]) {
     switch (s[i]) {
       case '%':
-        i++
+        i++;
         if (parameterized < 1) {
-          out += '%'
-          break
+          out += '%';
+          break;
         }
         switch (s[i++]) {
           case '%':
-            out += '%'
-            break
+            out += '%';
+            break;
           case 'r':
             if (seenr++ === 1) {
-              warn('saw %%r twice in %s', cap)
+              warn('saw %%r twice in %s', cap);
             }
-            break
+            break;
           case 'm':
             if (seenm++ === 1) {
-              warn('saw %%m twice in %s', cap)
+              warn('saw %%m twice in %s', cap);
             }
-            break
+            break;
           case 'n':
             if (seenn++ === 1) {
-              warn('saw %%n twice in %s', cap)
+              warn('saw %%n twice in %s', cap);
             }
-            break
+            break;
           case 'i':
-            out += '%i'
-            break
+            out += '%i';
+            break;
           case '6':
           case 'B':
-            getparm(param, 1)
-            out += '%{10}%/%{16}%*'
-            getparm(param, 1)
-            out += '%{10}%m%+'
-            break
+            getparm(param, 1);
+            out += '%{10}%/%{16}%*';
+            getparm(param, 1);
+            out += '%{10}%m%+';
+            break;
           case '8':
           case 'D':
-            getparm(param, 2)
-            out += '%{2}%*%-'
-            break
+            getparm(param, 2);
+            out += '%{2}%*%-';
+            break;
           case '>':
-            getparm(param, 2)
+            getparm(param, 2);
             // %?%{x}%>%t%{y}%+%;
-            out += '%?'
-            i += cvtchar(s)
-            out += '%>%t'
-            i += cvtchar(s)
-            out += '%+%;'
-            break
+            out += '%?';
+            i += cvtchar(s);
+            out += '%>%t';
+            i += cvtchar(s);
+            out += '%+%;';
+            break;
           case 'a':
-            if (
-              (s[i] === '=' ||
-                s[i] === '+' ||
-                s[i] === '-' ||
-                s[i] === '*' ||
-                s[i] === '/') &&
-              (s[i + 1] === 'p' || s[i + 1] === 'c') &&
-              s[i + 2] !== '\0' &&
-              s[i + 2]
-            ) {
-              let l
-              l = 2
+            if ((s[i] === '=' || s[i] === '+' || s[i] === '-'
+                || s[i] === '*' || s[i] === '/')
+                && (s[i + 1] === 'p' || s[i + 1] === 'c')
+                && s[i + 2] !== '\0' && s[i + 2]) {
+              var l;
+              l = 2;
               if (s[i] !== '=') {
-                getparm(param, 1)
+                getparm(param, 1);
               }
               if (s[i + 1] === 'p') {
-                getparm(param + s[i + 2].charCodeAt(0) - '@'.charCodeAt(0), 1)
+                getparm(param + s[i + 2].charCodeAt(0) - '@'.charCodeAt(0), 1);
                 if (param !== onstack) {
-                  pop()
-                  param--
+                  pop();
+                  param--;
                 }
-                l++
+                l++;
               } else {
-                ;(i += 2), (l += cvtchar(s)), (i -= 2)
+                i += 2, l += cvtchar(s), i -= 2;
               }
               switch (s[i]) {
                 case '+':
-                  out += '%+'
-                  break
+                  out += '%+';
+                  break;
                 case '-':
-                  out += '%-'
-                  break
+                  out += '%-';
+                  break;
                 case '*':
-                  out += '%*'
-                  break
+                  out += '%*';
+                  break;
                 case '/':
-                  out += '%/'
-                  break
+                  out += '%/';
+                  break;
                 case '=':
                   if (seenr) {
                     if (param === 1) {
-                      onstack = 2
+                      onstack = 2;
                     } else if (param === 2) {
-                      onstack = 1
+                      onstack = 1;
                     } else {
-                      onstack = param
+                      onstack = param;
                     }
                   } else {
-                    onstack = param
+                    onstack = param;
                   }
-                  break
+                  break;
               }
-              i += l
-              break
+              i += l;
+              break;
             }
-            getparm(param, 1)
-            i += cvtchar(s)
-            out += '%+'
-            break
+            getparm(param, 1);
+            i += cvtchar(s);
+            out += '%+';
+            break;
           case '+':
-            getparm(param, 1)
-            i += cvtchar(s)
-            out += '%+%c'
-            pop()
-            break
+            getparm(param, 1);
+            i += cvtchar(s);
+            out += '%+%c';
+            pop();
+            break;
           case 's':
-            // #ifdef WATERLOO
-            //          i += cvtchar(s);
-            //          getparm(param, 1);
-            //          out += '%-';
-            // #else
-            getparm(param, 1)
-            out += '%s'
-            pop()
-            // #endif /* WATERLOO */
-            break
+// #ifdef WATERLOO
+//          i += cvtchar(s);
+//          getparm(param, 1);
+//          out += '%-';
+// #else
+            getparm(param, 1);
+            out += '%s';
+            pop();
+// #endif /* WATERLOO */
+            break;
           case '-':
-            i += cvtchar(s)
-            getparm(param, 1)
-            out += '%-%c'
-            pop()
-            break
+            i += cvtchar(s);
+            getparm(param, 1);
+            out += '%-%c';
+            pop();
+            break;
           case '.':
-            getparm(param, 1)
-            out += '%c'
-            pop()
-            break
+            getparm(param, 1);
+            out += '%c';
+            pop();
+            break;
           case '0': // not clear any of the historical termcaps did this
             if (s[i] === '3') {
-              see03() // goto
-              break
+              see03(); // goto
+              break;
             } else if (s[i] !== '2') {
-              invalid() // goto
-              break
+              invalid(); // goto
+              break;
             }
-          // FALLTHRU
+            // FALLTHRU
           case '2':
-            getparm(param, 1)
-            out += '%2d'
-            pop()
-            break
+            getparm(param, 1);
+            out += '%2d';
+            pop();
+            break;
           case '3':
-            see03()
-            break
+            see03();
+            break;
           case 'd':
-            getparm(param, 1)
-            out += '%d'
-            pop()
-            break
+            getparm(param, 1);
+            out += '%d';
+            pop();
+            break;
           case 'f':
-            param++
-            break
+            param++;
+            break;
           case 'b':
-            param--
-            break
+            param--;
+            break;
           case '\\':
-            out += '%\\'
-            break
+            out += '%\\';
+            break;
           default:
-            invalid()
-            break
+            invalid();
+            break;
         }
-        break
-      // #ifdef REVISIBILIZE
-      //    case '\\':
-      //      out += s[i++];
-      //      out += s[i++];
-      //      break;
-      //    case '\n':
-      //      out += '\\n';
-      //      i++;
-      //      break;
-      //    case '\t':
-      //      out += '\\t';
-      //      i++;
-      //      break;
-      //    case '\r':
-      //      out += '\\r';
-      //      i++;
-      //      break;
-      //    case '\x80':
-      //      out += '\\0';
-      //      i++;
-      //      break;
-      //    case '\f':
-      //      out += '\\f';
-      //      i++;
-      //      break;
-      //    case '\b':
-      //      out += '\\b';
-      //      i++;
-      //      break;
-      //    case ' ':
-      //      out += '\\s';
-      //      i++;
-      //      break;
-      //    case '^':
-      //      out += '\\^';
-      //      i++;
-      //      break;
-      //    case ':':
-      //      out += '\\:';
-      //      i++;
-      //      break;
-      //    case ',':
-      //      out += '\\,';
-      //      i++;
-      //      break;
-      //    default:
-      //      if (s[i] === '\033') {
-      //        out += '\\E';
-      //        i++;
-      //      } else if (s[i].charCodeAt(0) > 0 && s[i].charCodeAt(0) < 32) {
-      //        out += '^';
-      //        out += String.fromCharCode(s[i].charCodeAt(0) + '@'.charCodeAt(0));
-      //        i++;
-      //      } else if (s[i].charCodeAt(0) <= 0 || s[i].charCodeAt(0) >= 127) {
-      //        out += '\\';
-      //        out += String.fromCharCode(
-      //          ((s[i].charCodeAt(0) & 0300) >> 6) + '0'.charCodeAt(0));
-      //        out += String.fromCharCode(
-      //          ((s[i].charCodeAt(0) & 0070) >> 3) + '0'.charCodeAt(0));
-      //        out += String.fromCharCode(
-      //          (s[i].charCodeAt(0) & 0007) + '0'.charCodeAt(0));
-      //        i++;
-      //      } else {
-      //        out += s[i++];
-      //      }
-      //      break;
-      // #else
+        break;
+// #ifdef REVISIBILIZE
+//    case '\\':
+//      out += s[i++];
+//      out += s[i++];
+//      break;
+//    case '\n':
+//      out += '\\n';
+//      i++;
+//      break;
+//    case '\t':
+//      out += '\\t';
+//      i++;
+//      break;
+//    case '\r':
+//      out += '\\r';
+//      i++;
+//      break;
+//    case '\x80':
+//      out += '\\0';
+//      i++;
+//      break;
+//    case '\f':
+//      out += '\\f';
+//      i++;
+//      break;
+//    case '\b':
+//      out += '\\b';
+//      i++;
+//      break;
+//    case ' ':
+//      out += '\\s';
+//      i++;
+//      break;
+//    case '^':
+//      out += '\\^';
+//      i++;
+//      break;
+//    case ':':
+//      out += '\\:';
+//      i++;
+//      break;
+//    case ',':
+//      out += '\\,';
+//      i++;
+//      break;
+//    default:
+//      if (s[i] === '\033') {
+//        out += '\\E';
+//        i++;
+//      } else if (s[i].charCodeAt(0) > 0 && s[i].charCodeAt(0) < 32) {
+//        out += '^';
+//        out += String.fromCharCode(s[i].charCodeAt(0) + '@'.charCodeAt(0));
+//        i++;
+//      } else if (s[i].charCodeAt(0) <= 0 || s[i].charCodeAt(0) >= 127) {
+//        out += '\\';
+//        out += String.fromCharCode(
+//          ((s[i].charCodeAt(0) & 0300) >> 6) + '0'.charCodeAt(0));
+//        out += String.fromCharCode(
+//          ((s[i].charCodeAt(0) & 0070) >> 3) + '0'.charCodeAt(0));
+//        out += String.fromCharCode(
+//          (s[i].charCodeAt(0) & 0007) + '0'.charCodeAt(0));
+//        i++;
+//      } else {
+//        out += s[i++];
+//      }
+//      break;
+// #else
       default:
-        out += s[i++]
-        break
-      // #endif
+        out += s[i++];
+        break;
+// #endif
     }
   }
 
   // Now, if we stripped off some leading padding, add it at the end
   // of the string as mandatory padding.
   if (capstart != null) {
-    out += '$<'
-    for (i = capstart; ; i++) {
+    out += '$<';
+    for (i = capstart;; i++) {
       if (isdigit(s[i]) || s[i] === '*' || s[i] === '.') {
-        out += s[i]
+        out += s[i];
       } else {
-        break
+        break;
       }
     }
-    out += '/>'
+    out += '/>';
   }
 
   if (s !== out) {
-    warn(
-      'Translating %s from %s to %s.',
-      cap,
-      JSON.stringify(s),
-      JSON.stringify(out)
-    )
+    warn('Translating %s from %s to %s.',
+      cap, JSON.stringify(s), JSON.stringify(out));
   }
 
-  return out
-}
+  return out;
+};
 
 /**
  * Compile All Terminfo
  */
 
-Tput.prototype.getAll = function () {
-  const dir = this._prefix(),
-    list = asort(fs.readdirSync(dir)),
-    infos = []
+Tput.prototype.getAll = function() {
+  var dir = this._prefix()
+    , list = asort(fs.readdirSync(dir))
+    , infos = [];
 
-  list.forEach(function (letter) {
-    const terms = asort(fs.readdirSync(path.resolve(dir, letter)))
-    infos.push.apply(infos, terms)
-  })
+  list.forEach(function(letter) {
+    var terms = asort(fs.readdirSync(path.resolve(dir, letter)));
+    infos.push.apply(infos, terms);
+  });
 
   function asort(obj) {
-    return obj.sort(function (a, b) {
-      a = a.toLowerCase().charCodeAt(0)
-      b = b.toLowerCase().charCodeAt(0)
-      return a - b
-    })
+    return obj.sort(function(a, b) {
+      a = a.toLowerCase().charCodeAt(0);
+      b = b.toLowerCase().charCodeAt(0);
+      return a - b;
+    });
   }
 
-  return infos
-}
+  return infos;
+};
 
-Tput.prototype.compileAll = function (start) {
-  const self = this,
-    all = {}
+Tput.prototype.compileAll = function(start) {
+  var self = this
+    , all = {};
 
-  this.getAll().forEach(function (name) {
+  this.getAll().forEach(function(name) {
     if (start && name !== start) {
-      return
+      return;
     } else {
-      start = null
+      start = null;
     }
-    all[name] = self.compileTerminfo(name)
-  })
+    all[name] = self.compileTerminfo(name);
+  });
 
-  return all
-}
+  return all;
+};
 
 /**
  * Detect Features / Quirks
  */
 
-Tput.prototype.detectFeatures = function (info) {
-  const data = this.parseACS(info)
+Tput.prototype.detectFeatures = function(info) {
+  var data = this.parseACS(info);
   info.features = {
     unicode: this.detectUnicode(info),
     brokenACS: this.detectBrokenACS(info),
@@ -2116,26 +2038,22 @@ Tput.prototype.detectFeatures = function (info) {
     setbuf: this.detectSetbuf(info),
     acsc: data.acsc,
     acscr: data.acscr
-  }
-  return info.features
-}
+  };
+  return info.features;
+};
 
-Tput.prototype.detectUnicode = function () {
+Tput.prototype.detectUnicode = function() {
   if (this.options.forceUnicode != null) {
-    return this.options.forceUnicode
+    return this.options.forceUnicode;
   }
 
-  const LANG =
-    process.env.LANG +
-    ':' +
-    process.env.LANGUAGE +
-    ':' +
-    process.env.LC_ALL +
-    ':' +
-    process.env.LC_CTYPE
+  var LANG = process.env.LANG
+    + ':' + process.env.LANGUAGE
+    + ':' + process.env.LC_ALL
+    + ':' + process.env.LC_CTYPE;
 
-  return /utf-?8/i.test(LANG) || this.GetConsoleCP() === 65001
-}
+  return /utf-?8/i.test(LANG) || (this.GetConsoleCP() === 65001);
+};
 
 // For some reason TERM=linux has smacs/rmacs, but it maps to `^[[11m`
 // and it does not switch to the DEC SCLD character set. What the hell?
@@ -2148,119 +2066,112 @@ Tput.prototype.detectUnicode = function () {
 // ~/ncurses/ncurses/tinfo/lib_acs.c
 // ~/ncurses/ncurses/tinfo/tinfo_driver.c
 // ~/ncurses/ncurses/tinfo/lib_setup.c
-Tput.prototype.detectBrokenACS = function (info) {
+Tput.prototype.detectBrokenACS = function(info) {
   // ncurses-compatible env variable.
   if (process.env.NCURSES_NO_UTF8_ACS != null) {
-    return !!+process.env.NCURSES_NO_UTF8_ACS
+    return !!+process.env.NCURSES_NO_UTF8_ACS;
   }
 
   // If the terminal supports unicode, we don't need ACS.
   if (info.numbers.U8 >= 0) {
-    return !!info.numbers.U8
+    return !!info.numbers.U8;
   }
 
   // The linux console is just broken for some reason.
   // Apparently the Linux console does not support ACS,
   // but it does support the PC ROM character set.
   if (info.name === 'linux') {
-    return true
+    return true;
   }
 
   // PC alternate charset
   // if (acsc.indexOf('+\x10,\x11-\x18.\x190') === 0) {
   if (this.detectPCRomSet(info)) {
-    return true
+    return true;
   }
 
   // screen termcap is bugged?
-  if (
-    this.termcap &&
-    info.name.indexOf('screen') === 0 &&
-    process.env.TERMCAP &&
-    ~process.env.TERMCAP.indexOf('screen') &&
-    ~process.env.TERMCAP.indexOf('hhII00')
-  ) {
-    if (
-      ~info.strings.enter_alt_charset_mode.indexOf('\x0E') ||
-      ~info.strings.enter_alt_charset_mode.indexOf('\x0F') ||
-      ~info.strings.set_attributes.indexOf('\x0E') ||
-      ~info.strings.set_attributes.indexOf('\x0F')
-    ) {
-      return true
-    }
-  }
-
-  return false
-}
+  if (this.termcap
+      && info.name.indexOf('screen') === 0
+      && process.env.TERMCAP
+      && ~process.env.TERMCAP.indexOf('screen')
+      && ~process.env.TERMCAP.indexOf('hhII00')) {
+    if (~info.strings.enter_alt_charset_mode.indexOf('\x0E')
+        || ~info.strings.enter_alt_charset_mode.indexOf('\x0F')
+        || ~info.strings.set_attributes.indexOf('\x0E')
+        || ~info.strings.set_attributes.indexOf('\x0F')) {
+      return true;
+    }
+  }
+
+  return false;
+};
 
 // If enter_pc_charset is the same as enter_alt_charset,
 // the terminal does not support SCLD as ACS.
 // See: ~/ncurses/ncurses/tinfo/lib_acs.c
-Tput.prototype.detectPCRomSet = function (info) {
-  const s = info.strings
-  if (
-    s.enter_pc_charset_mode &&
-    s.enter_alt_charset_mode &&
-    s.enter_pc_charset_mode === s.enter_alt_charset_mode &&
-    s.exit_pc_charset_mode === s.exit_alt_charset_mode
-  ) {
-    return true
-  }
-  return false
-}
+Tput.prototype.detectPCRomSet = function(info) {
+  var s = info.strings;
+  if (s.enter_pc_charset_mode && s.enter_alt_charset_mode
+      && s.enter_pc_charset_mode === s.enter_alt_charset_mode
+      && s.exit_pc_charset_mode === s.exit_alt_charset_mode) {
+    return true;
+  }
+  return false;
+};
 
-Tput.prototype.detectMagicCookie = function () {
-  return process.env.NCURSES_NO_MAGIC_COOKIE == null
-}
+Tput.prototype.detectMagicCookie = function() {
+  return process.env.NCURSES_NO_MAGIC_COOKIE == null;
+};
 
-Tput.prototype.detectPadding = function () {
-  return process.env.NCURSES_NO_PADDING == null
-}
+Tput.prototype.detectPadding = function() {
+  return process.env.NCURSES_NO_PADDING == null;
+};
 
-Tput.prototype.detectSetbuf = function () {
-  return process.env.NCURSES_NO_SETBUF == null
-}
+Tput.prototype.detectSetbuf = function() {
+  return process.env.NCURSES_NO_SETBUF == null;
+};
 
-Tput.prototype.parseACS = function (info) {
-  const data = {}
+Tput.prototype.parseACS = function(info) {
+  var data = {};
 
-  data.acsc = {}
-  data.acscr = {}
+  data.acsc = {};
+  data.acscr = {};
 
   // Possibly just return an empty object, as done here, instead of
   // specifically saying ACS is "broken" above. This would be more
   // accurate to ncurses logic. But it doesn't really matter.
   if (this.detectPCRomSet(info)) {
-    return data
+    return data;
   }
 
   // See: ~/ncurses/ncurses/tinfo/lib_acs.c: L208
-  Object.keys(Tput.acsc).forEach(function (ch) {
-    const acs_chars = info.strings.acs_chars || '',
-      i = acs_chars.indexOf(ch),
-      next = acs_chars[i + 1]
+  Object.keys(Tput.acsc).forEach(function(ch) {
+    var acs_chars = info.strings.acs_chars || ''
+      , i = acs_chars.indexOf(ch)
+      , next = acs_chars[i + 1];
 
     if (!next || i === -1 || !Tput.acsc[next]) {
-      return
+      return;
     }
 
-    data.acsc[ch] = Tput.acsc[next]
-    data.acscr[Tput.acsc[next]] = ch
-  })
+    data.acsc[ch] = Tput.acsc[next];
+    data.acscr[Tput.acsc[next]] = ch;
+  });
 
-  return data
-}
+  return data;
+};
 
-Tput.prototype.GetConsoleCP = function () {
-  let ccp
+Tput.prototype.GetConsoleCP = function() {
+  var ccp;
 
   if (process.platform !== 'win32') {
-    return -1
+    return -1;
   }
 
   // Allow unicode on all windows consoles for now:
   if (+process.env.NCURSES_UNICODE !== 0) {
-    return 65001
+    return 65001;
   }
 
   // cp.execSync('chcp 65001', { stdio: 'ignore', timeout: 1500 });
@@ -2271,64 +2182,62 @@ Tput.prototype.GetConsoleCP = function () {
       stdio: ['ignore', 'pipe', 'ignore'],
       encoding: 'ascii',
       timeout: 1500
-    })
+    });
     // ccp = cp.execSync('chcp', {
     //   stdio: ['ignore', 'pipe', 'ignore'],
     //   encoding: 'ascii',
     //   timeout: 1500
     // });
-  } catch (e) {}
+  } catch (e) {
+    ;
+  }
 
-  ccp = /\d+/.exec(ccp)
+  ccp = /\d+/.exec(ccp);
 
   if (!ccp) {
-    return -1
+    return -1;
   }
 
-  ccp = +ccp[0]
+  ccp = +ccp[0];
 
-  return ccp
-}
+  return ccp;
+};
 
 /**
  * Helpers
  */
 
 function noop() {
-  return ''
+  return '';
 }
 
-noop.unsupported = true
+noop.unsupported = true;
 
 function merge(a, b) {
-  Object.keys(b).forEach(function (key) {
-    a[key] = b[key]
-  })
-  return a
+  Object.keys(b).forEach(function(key) {
+    a[key] = b[key];
+  });
+  return a;
 }
 
 function write(data) {
-  return process.stdout.write(data)
+  return process.stdout.write(data);
 }
 
 function tryRead(file) {
   if (Array.isArray(file)) {
-    for (let i = 0; i < file.length; i++) {
-      const data = tryRead(file[i])
-      if (data) {
-        return data
-      }
+    for (var i = 0; i < file.length; i++) {
+      var data = tryRead(file[i]);
+      if (data) return data;
     }
-    return ''
-  }
-  if (!file) {
-    return ''
+    return '';
   }
-  file = path.resolve.apply(path, arguments)
+  if (!file) return '';
+  file = path.resolve.apply(path, arguments);
   try {
-    return fs.readFileSync(file, 'utf8')
+    return fs.readFileSync(file, 'utf8');
   } catch (e) {
-    return ''
+    return '';
   }
 }
 
@@ -2338,180 +2247,179 @@ function tryRead(file) {
  */
 
 function sprintf(src) {
-  let params = Array.prototype.slice.call(arguments, 1),
-    rule = /%([-+# ]{1,4})?(\d+(?:\.\d+)?)?([doxXsc])/g,
-    i = 0
-
-  return src.replace(rule, function (_, flag, width, type) {
-    let flags = (flag || '').split(''),
-      param = params[i] != null ? params[i] : '',
-      initial = param,
+  var params = Array.prototype.slice.call(arguments, 1)
+    , rule = /%([\-+# ]{1,4})?(\d+(?:\.\d+)?)?([doxXsc])/g
+    , i = 0;
+
+  return src.replace(rule, function(_, flag, width, type) {
+    var flags = (flag || '').split('')
+      , param = params[i] != null ? params[i] : ''
+      , initial = param
       // , width = +width
-      opt = {},
-      pre = ''
+      , opt = {}
+      , pre = '';
 
-    i++
+    i++;
 
     switch (type) {
       case 'd': // signed int
-        param = (+param).toString(10)
-        break
+        param = (+param).toString(10);
+        break;
       case 'o': // unsigned octal
-        param = (+param).toString(8)
-        break
+        param = (+param).toString(8);
+        break;
       case 'x': // unsigned hex int
-        param = (+param).toString(16)
-        break
+        param = (+param).toString(16);
+        break;
       case 'X': // unsigned hex int uppercase
-        param = (+param).toString(16).toUppercase()
-        break
+        param = (+param).toString(16).toUppercase();
+        break;
       case 's': // string
-        break
+        break;
       case 'c': // char
-        param = isFinite(param) ? String.fromCharCode(param || 0x80) : ''
-        break
+        param = isFinite(param)
+          ? String.fromCharCode(param || 0x80)
+          : '';
+        break;
     }
 
-    flags.forEach(function (flag) {
+    flags.forEach(function(flag) {
       switch (flag) {
         // left-justify by width
         case '-':
-          opt.left = true
-          break
+          opt.left = true;
+          break;
         // always precede numbers with their signs
         case '+':
-          opt.signs = true
-          break
+          opt.signs = true;
+          break;
         // used with o, x, X - value is preceded with 0, 0x, or 0X respectively.
         // used with a, A, e, E, f, F, g, G - forces written output to contain
         // a decimal point even if no more digits follow
         case '#':
-          opt.hexpoint = true
-          break
+          opt.hexpoint = true;
+          break;
         // if no sign is going to be written, black space in front of the value
         case ' ':
-          opt.space = true
-          break
+          opt.space = true;
+          break;
       }
-    })
+    });
 
-    width = +width.split('.')[0]
+    width = +width.split('.')[0];
 
     // Should this be for opt.left too?
     // Example: %2.2X - turns 0 into 00
     if (width && !opt.left) {
-      param = param + ''
+      param = param + '';
       while (param.length < width) {
-        param = '0' + param
+        param = '0' + param;
       }
     }
 
     if (opt.signs) {
       if (+initial >= 0) {
-        pre += '+'
+        pre += '+';
       }
     }
 
     if (opt.space) {
       if (!opt.signs && +initial >= 0) {
-        pre += ' '
+        pre += ' ';
       }
     }
 
     if (opt.hexpoint) {
       switch (type) {
         case 'o': // unsigned octal
-          pre += '0'
-          break
+          pre += '0';
+          break;
         case 'x': // unsigned hex int
-          pre += '0x'
-          break
+          pre += '0x';
+          break;
         case 'X': // unsigned hex int uppercase
-          pre += '0X'
-          break
+          pre += '0X';
+          break;
       }
     }
 
     if (opt.left) {
-      if (width > pre.length + param.length) {
-        width -= pre.length + param.length
-        pre = Array(width + 1).join(' ') + pre
+      if (width > (pre.length + param.length)) {
+        width -= pre.length + param.length;
+        pre = Array(width + 1).join(' ') + pre;
       }
     }
 
-    return pre + param
-  })
+    return pre + param;
+  });
 }
 
 /**
  * Aliases
  */
 
-Tput._alias = require('./alias')
+Tput._alias = require('./alias');
 
-Tput.alias = {}
+Tput.alias = {};
 
-;['bools', 'numbers', 'strings'].forEach(function (type) {
-  Object.keys(Tput._alias[type]).forEach(function (key) {
-    const aliases = Tput._alias[type][key]
-    Tput.alias[key] = [aliases[0]]
-    Tput.alias[key].terminfo = aliases[0]
-    Tput.alias[key].termcap = aliases[1]
-  })
-})
+['bools', 'numbers', 'strings'].forEach(function(type) {
+  Object.keys(Tput._alias[type]).forEach(function(key) {
+    var aliases = Tput._alias[type][key];
+    Tput.alias[key] = [aliases[0]];
+    Tput.alias[key].terminfo = aliases[0];
+    Tput.alias[key].termcap = aliases[1];
+  });
+});
 
 // Bools
-Tput.alias.no_esc_ctlc.push('beehive_glitch')
-Tput.alias.dest_tabs_magic_smso.push('teleray_glitch')
+Tput.alias.no_esc_ctlc.push('beehive_glitch');
+Tput.alias.dest_tabs_magic_smso.push('teleray_glitch');
 
 // Numbers
-Tput.alias.micro_col_size.push('micro_char_size')
+Tput.alias.micro_col_size.push('micro_char_size');
 
 /**
  * Feature Checking
  */
 
-Tput.aliasMap = {}
+Tput.aliasMap = {};
 
-Object.keys(Tput.alias).forEach(function (key) {
-  Tput.aliasMap[key] = key
-  Tput.alias[key].forEach(function (k) {
-    Tput.aliasMap[k] = key
-  })
-})
+Object.keys(Tput.alias).forEach(function(key) {
+  Tput.aliasMap[key] = key;
+  Tput.alias[key].forEach(function(k) {
+    Tput.aliasMap[k] = key;
+  });
+});
 
-Tput.prototype.has = function (name) {
-  name = Tput.aliasMap[name]
+Tput.prototype.has = function(name) {
+  name = Tput.aliasMap[name];
 
-  const val = this.all[name]
+  var val = this.all[name];
 
-  if (!name) {
-    return false
-  }
+  if (!name) return false;
 
   if (typeof val === 'number') {
-    return val !== -1
+    return val !== -1;
   }
 
-  return !!val
-}
+  return !!val;
+};
 
 /**
  * Fallback Termcap Entry
  */
 
-Tput.termcap =
-  '' +
-  'vt102|dec vt102:' +
-  ':do=^J:co#80:li#24:cl=50\\E[;H\\E[2J:' +
-  ':le=^H:bs:cm=5\\E[%i%d;%dH:nd=2\\E[C:up=2\\E[A:' +
-  ':ce=3\\E[K:cd=50\\E[J:so=2\\E[7m:se=2\\E[m:us=2\\E[4m:ue=2\\E[m:' +
-  ':md=2\\E[1m:mr=2\\E[7m:mb=2\\E[5m:me=2\\E[m:is=\\E[1;24r\\E[24;1H:' +
-  ':rs=\\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h:ks=\\E[?1h\\E=:ke=\\E[?1l\\E>:' +
-  ':ku=\\EOA:kd=\\EOB:kr=\\EOC:kl=\\EOD:kb=^H:\\\n' +
-  ':ho=\\E[H:k1=\\EOP:k2=\\EOQ:k3=\\EOR:k4=\\EOS:pt:sr=5\\EM:vt#3:' +
-  ':sc=\\E7:rc=\\E8:cs=\\E[%i%d;%dr:vs=\\E[?7l:ve=\\E[?7h:' +
-  ':mi:al=\\E[L:dc=\\E[P:dl=\\E[M:ei=\\E[4l:im=\\E[4h:'
+Tput.termcap = ''
+  + 'vt102|dec vt102:'
+  + ':do=^J:co#80:li#24:cl=50\\E[;H\\E[2J:'
+  + ':le=^H:bs:cm=5\\E[%i%d;%dH:nd=2\\E[C:up=2\\E[A:'
+  + ':ce=3\\E[K:cd=50\\E[J:so=2\\E[7m:se=2\\E[m:us=2\\E[4m:ue=2\\E[m:'
+  + ':md=2\\E[1m:mr=2\\E[7m:mb=2\\E[5m:me=2\\E[m:is=\\E[1;24r\\E[24;1H:'
+  + ':rs=\\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h:ks=\\E[?1h\\E=:ke=\\E[?1l\\E>:'
+  + ':ku=\\EOA:kd=\\EOB:kr=\\EOC:kl=\\EOD:kb=^H:\\\n'
+  + ':ho=\\E[H:k1=\\EOP:k2=\\EOQ:k3=\\EOR:k4=\\EOS:pt:sr=5\\EM:vt#3:'
+  + ':sc=\\E7:rc=\\E8:cs=\\E[%i%d;%dr:vs=\\E[?7l:ve=\\E[?7h:'
+  + ':mi:al=\\E[L:dc=\\E[P:dl=\\E[M:ei=\\E[4l:im=\\E[4h:';
 
 /**
  * Terminfo Data
@@ -2564,7 +2472,7 @@ Tput.bools = [
   'linefeed_is_newline',
   'has_hardware_tabs',
   'return_does_clr_eol'
-]
+];
 
 Tput.numbers = [
   'columns',
@@ -2608,7 +2516,7 @@ Tput.numbers = [
   'backspace_delay',
   'horizontal_tab_delay',
   'number_of_function_keys'
-]
+];
 
 Tput.strings = [
   'back_tab',
@@ -3027,44 +2935,43 @@ Tput.strings = [
   'memory_lock',
   'memory_unlock',
   'box_chars_1'
-]
+];
 
 // DEC Special Character and Line Drawing Set.
 // Taken from tty.js.
-Tput.acsc = {
-  // (0
+Tput.acsc = {    // (0
   '`': '\u25c6', // '◆'
-  a: '\u2592', // '▒'
-  b: '\u0009', // '\t'
-  c: '\u000c', // '\f'
-  d: '\u000d', // '\r'
-  e: '\u000a', // '\n'
-  f: '\u00b0', // '°'
-  g: '\u00b1', // '±'
-  h: '\u2424', // '\u2424' (NL)
-  i: '\u000b', // '\v'
-  j: '\u2518', // '┘'
-  k: '\u2510', // '┐'
-  l: '\u250c', // '┌'
-  m: '\u2514', // '└'
-  n: '\u253c', // '┼'
-  o: '\u23ba', // '⎺'
-  p: '\u23bb', // '⎻'
-  q: '\u2500', // '─'
-  r: '\u23bc', // '⎼'
-  s: '\u23bd', // '⎽'
-  t: '\u251c', // '├'
-  u: '\u2524', // '┤'
-  v: '\u2534', // '┴'
-  w: '\u252c', // '┬'
-  x: '\u2502', // '│'
-  y: '\u2264', // '≤'
-  z: '\u2265', // '≥'
+  'a': '\u2592', // '▒'
+  'b': '\u0009', // '\t'
+  'c': '\u000c', // '\f'
+  'd': '\u000d', // '\r'
+  'e': '\u000a', // '\n'
+  'f': '\u00b0', // '°'
+  'g': '\u00b1', // '±'
+  'h': '\u2424', // '\u2424' (NL)
+  'i': '\u000b', // '\v'
+  'j': '\u2518', // '┘'
+  'k': '\u2510', // '┐'
+  'l': '\u250c', // '┌'
+  'm': '\u2514', // '└'
+  'n': '\u253c', // '┼'
+  'o': '\u23ba', // '⎺'
+  'p': '\u23bb', // '⎻'
+  'q': '\u2500', // '─'
+  'r': '\u23bc', // '⎼'
+  's': '\u23bd', // '⎽'
+  't': '\u251c', // '├'
+  'u': '\u2524', // '┤'
+  'v': '\u2534', // '┴'
+  'w': '\u252c', // '┬'
+  'x': '\u2502', // '│'
+  'y': '\u2264', // '≤'
+  'z': '\u2265', // '≥'
   '{': '\u03c0', // 'π'
   '|': '\u2260', // '≠'
   '}': '\u00a3', // '£'
-  '~': '\u00b7' // '·'
-}
+  '~': '\u00b7'  // '·'
+};
 
 // Convert ACS unicode characters to the
 // most similar-looking ascii characters.
@@ -3099,15 +3006,15 @@ Tput.utoa = Tput.prototype.utoa = {
   '\u03c0': '?', // 'π'
   '\u2260': '=', // '≠'
   '\u00a3': '?', // '£'
-  '\u00b7': '*' // '·'
-}
+  '\u00b7': '*'  // '·'
+};
 
 /**
  * Expose
  */
 
-exports = Tput
-exports.sprintf = sprintf
-exports.tryRead = tryRead
+exports = Tput;
+exports.sprintf = sprintf;
+exports.tryRead = tryRead;
 
-module.exports = exports
+module.exports = exports;