zcatalyst-cli 1.12.1 → 1.13.0

package/lib/bin/catalyst.js

@@ -16,7 +16,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
 const fs_1 = require("../util_modules/fs");
 const runtime_store_1 = __importDefault(require("../runtime-store"));
-const pkg = fs_1.SYNC.readJSONFile(path_1.resolve(__dirname, '../../package.json'), {
+const pkg = fs_1.SYNC.readJSONFile((0, path_1.resolve)(__dirname, '../../package.json'), {
     checkpath: true,
     throws: false
 });
@@ -34,15 +34,15 @@ const env_1 = require("../util_modules/env");
 const js_1 = require("../util_modules/js");
 const logger_1 = require("../util_modules/logger");
 const errorOut_1 = __importDefault(require("../errorOut"));
-logger_1.debug();
-logger_1.debug(js_1.JS.repeat('-', 70));
-logger_1.debug(ansi_colors_1.bold('Command:      ') + process.argv.join(' '));
-logger_1.debug(ansi_colors_1.bold('CLI Version:  ') + pkg.version);
-logger_1.debug(ansi_colors_1.bold('Platform:     ') + process.platform);
-logger_1.debug(ansi_colors_1.bold('Node Version: ') + process.version);
-logger_1.debug(ansi_colors_1.bold('Time:         ') + new Date().toString());
-logger_1.debug(js_1.JS.repeat('-', 70));
-logger_1.debug();
+(0, logger_1.debug)();
+(0, logger_1.debug)(js_1.JS.repeat('-', 70));
+(0, logger_1.debug)((0, ansi_colors_1.bold)('Command:      ') + process.argv.join(' '));
+(0, logger_1.debug)((0, ansi_colors_1.bold)('CLI Version:  ') + pkg.version);
+(0, logger_1.debug)((0, ansi_colors_1.bold)('Platform:     ') + process.platform);
+(0, logger_1.debug)((0, ansi_colors_1.bold)('Node Version: ') + process.version);
+(0, logger_1.debug)((0, ansi_colors_1.bold)('Time:         ') + new Date().toString());
+(0, logger_1.debug)(js_1.JS.repeat('-', 70));
+(0, logger_1.debug)();
 process.on('beforeExit', (code) => __awaiter(void 0, void 0, void 0, function* () {
     code = process.exitCode || code;
     if (code > 0 && process.stdout.isTTY) {
@@ -53,7 +53,7 @@ process.on('beforeExit', (code) => __awaiter(void 0, void 0, void 0, function* (
             const cmd = yield cmdPromise;
             if (code === 1 && cmd) {
                 const commandName = js_1.JS.get(js_1.JS.last(cmd.args), '_name', '[command]');
-                help = 'Having trouble? Try ' + ansi_colors_1.bold('catalyst ' + commandName + ' --help');
+                help = 'Having trouble? Try ' + (0, ansi_colors_1.bold)('catalyst ' + commandName + ' --help');
             }
             else {
                 help =
@@ -71,10 +71,10 @@ process.on('beforeExit', (code) => __awaiter(void 0, void 0, void 0, function* (
     process.exit(code);
 }));
 process.on('exit', (code) => {
-    if (env_1.isPrimaryShell()) {
+    if ((0, env_1.isPrimaryShell)()) {
         fs_1.SYNC.deleteTempDir();
     }
-    const logFile = path_1.join(process.cwd(), constants_1.FILENAME.log);
+    const logFile = (0, path_1.join)(process.cwd(), constants_1.FILENAME.log);
     if (code < 2 && fs_1.SYNC.fileExists(logFile)) {
         fs_1.SYNC.deleteFile(logFile);
     }
@@ -84,9 +84,9 @@ process.on('exit', (code) => {
     }).notify({ defer: false, isGlobal: true });
 });
 process.on('uncaughtException', (err) => {
-    errorOut_1.default(err);
+    (0, errorOut_1.default)(err);
 });
 process.on('unhandledRejection', (reason, promise) => {
-    errorOut_1.default(util_1.inspect(reason || promise));
+    (0, errorOut_1.default)((0, util_1.inspect)(reason || promise));
 });
 const cmdPromise = __1.default.processArgs(process.argv);

package/lib/cli_table/src/cell.js

@@ -12,7 +12,7 @@ class Cell {
         }
         options = options || {};
         this.options = options;
-        let content = options.content;
+        const content = options.content;
         if (['boolean', 'number', 'string'].indexOf(typeof content) !== -1) {
             this.content = String(content);
         }
@@ -27,15 +27,15 @@ class Cell {
     }
     mergeTableOptions(tableOptions, cells) {
         this.cells = cells;
-        let optionsChars = this.options.chars || {};
-        let tableChars = tableOptions.chars;
-        let chars = (this.chars = {});
-        CHAR_NAMES.forEach(function (name) {
+        const optionsChars = this.options.chars || {};
+        const tableChars = tableOptions.chars;
+        const chars = (this.chars = {});
+        CHAR_NAMES.forEach((name) => {
             setOption(optionsChars, tableChars, name, chars);
         });
         this.truncate = this.options.truncate || tableOptions.truncate;
-        let style = (this.options.style = this.options.style || {});
-        let tableStyle = tableOptions.style;
+        const style = (this.options.style = this.options.style || {});
+        const tableStyle = tableOptions.style;
         setOption(style, tableStyle, 'padding-left', this);
         setOption(style, tableStyle, 'padding-right', this);
         this.head = style.head || tableStyle.head;
@@ -59,8 +59,8 @@ class Cell {
         this.desiredHeight = this.lines.length;
     }
     init(tableOptions) {
-        let x = this.x;
-        let y = this.y;
+        const x = this.x;
+        const y = this.y;
         this.widths = tableOptions.colWidths.slice(x, x + this.colSpan);
         this.heights = tableOptions.rowHeights.slice(y, y + this.rowSpan);
         this.width = this.widths.reduce(sumPlusOne, -1);
@@ -76,7 +76,7 @@ class Cell {
         if (lineNum == 'bottom') {
             return this.drawBottom(this.drawRight);
         }
-        let padLen = Math.max(this.height - this.lines.length, 0);
+        const padLen = Math.max(this.height - this.lines.length, 0);
         let padTop;
         switch (this.vAlign) {
             case 'center':
@@ -91,11 +91,11 @@ class Cell {
         if (lineNum < padTop || lineNum >= padTop + this.lines.length) {
             return this.drawEmpty(this.drawRight, spanningCell);
         }
-        let forceTruncation = this.lines.length > this.height && lineNum + 1 >= this.height;
+        const forceTruncation = this.lines.length > this.height && lineNum + 1 >= this.height;
         return this.drawLine(lineNum - padTop, this.drawRight, forceTruncation, spanningCell);
     }
     drawTop(drawRight) {
-        let content = [];
+        const content = [];
         if (this.cells) {
             this.widths.forEach(function (width, index) {
                 content.push(this._topLeftChar(index));
@@ -112,7 +112,7 @@ class Cell {
         return this.wrapWithStyleColors('border', content.join(''));
     }
     _topLeftChar(offset) {
-        let x = this.x + offset;
+        const x = this.x + offset;
         let leftChar;
         if (this.y == 0) {
             leftChar = x == 0 ? 'topLeft' : offset == 0 ? 'topMid' : 'top';
@@ -124,7 +124,7 @@ class Cell {
             else {
                 leftChar = offset == 0 ? 'midMid' : 'bottomMid';
                 if (this.cells) {
-                    let spanAbove = this.cells[this.y - 1][x] instanceof Cell.ColSpanCell;
+                    const spanAbove = this.cells[this.y - 1][x] instanceof Cell.ColSpanCell;
                     if (spanAbove) {
                         leftChar = offset == 0 ? 'topMid' : 'mid';
                     }
@@ -170,11 +170,11 @@ class Cell {
                 left = this.chars.rightMid;
             }
         }
-        let leftPadding = utils.repeat(' ', this.paddingLeft);
-        let right = drawRight ? this.chars.right : '';
-        let rightPadding = utils.repeat(' ', this.paddingRight);
+        const leftPadding = utils.repeat(' ', this.paddingLeft);
+        const right = drawRight ? this.chars.right : '';
+        const rightPadding = utils.repeat(' ', this.paddingRight);
         let line = this.lines[lineNum];
-        let len = this.width - (this.paddingLeft + this.paddingRight);
+        const len = this.width - (this.paddingLeft + this.paddingRight);
         if (forceTruncationSymbol) {
             line += this.truncate || '…';
         }
@@ -192,9 +192,9 @@ class Cell {
         return left + content + right;
     }
     drawBottom(drawRight) {
-        let left = this.chars[this.x == 0 ? 'bottomLeft' : 'bottomMid'];
-        let content = utils.repeat(this.chars.bottom, this.width);
-        let right = drawRight ? this.chars.bottomRight : '';
+        const left = this.chars[this.x == 0 ? 'bottomLeft' : 'bottomMid'];
+        const content = utils.repeat(this.chars.bottom, this.width);
+        const right = drawRight ? this.chars.bottomRight : '';
         return this.wrapWithStyleColors('border', left + content + right);
     }
     drawEmpty(drawRight, spanningCell) {
@@ -208,8 +208,8 @@ class Cell {
                 left = this.chars.rightMid;
             }
         }
-        let right = drawRight ? this.chars.right : '';
-        let content = utils.repeat(' ', this.width);
+        const right = drawRight ? this.chars.right : '';
+        const content = utils.repeat(' ', this.width);
         return this.stylizeLine(left, content, right);
     }
 }
@@ -226,8 +226,8 @@ class RowSpanCell {
         this.originalCell = originalCell;
     }
     init(tableOptions) {
-        let y = this.y;
-        let originalY = this.originalCell.y;
+        const y = this.y;
+        const originalY = this.originalCell.y;
         this.cellOffset = y - originalY;
         this.offset = findDimension(tableOptions.rowHeights, originalY, this.cellOffset);
     }
@@ -263,7 +263,7 @@ function findDimension(dimensionTable, startingIndex, span) {
 function sumPlusOne(a, b) {
     return a + b + 1;
 }
-let CHAR_NAMES = [
+const CHAR_NAMES = [
     'top',
     'top-mid',
     'top-left',

package/lib/cli_table/src/layout-manager.js

@@ -1,19 +1,18 @@
 "use strict";
-const objectAssign = require('object-assign');
 const Cell = require('./cell');
 const { ColSpanCell, RowSpanCell } = Cell;
 (function () {
     function layoutTable(table) {
-        table.forEach(function (row, rowIndex) {
+        table.forEach((row, rowIndex) => {
             let prevCell = null;
-            row.forEach(function (cell, columnIndex) {
+            row.forEach((cell, columnIndex) => {
                 cell.y = rowIndex;
                 cell.x = prevCell ? prevCell.x + 1 : columnIndex;
                 for (let y = rowIndex; y >= 0; y--) {
-                    let row2 = table[y];
-                    let xMax = y === rowIndex ? columnIndex : row2.length;
+                    const row2 = table[y];
+                    const xMax = y === rowIndex ? columnIndex : row2.length;
                     for (let x = 0; x < xMax; x++) {
-                        let cell2 = row2[x];
+                        const cell2 = row2[x];
                         while (cellsConflict(cell, cell2)) {
                             cell.x++;
                         }
@@ -25,8 +24,8 @@ const { ColSpanCell, RowSpanCell } = Cell;
     }
     function maxWidth(table) {
         let mw = 0;
-        table.forEach(function (row) {
-            row.forEach(function (cell) {
+        table.forEach((row) => {
+            row.forEach((cell) => {
                 mw = Math.max(mw, cell.x + (cell.colSpan || 1));
             });
         });
@@ -36,23 +35,23 @@ const { ColSpanCell, RowSpanCell } = Cell;
         return table.length;
     }
     function cellsConflict(cell1, cell2) {
-        let yMin1 = cell1.y;
-        let yMax1 = cell1.y - 1 + (cell1.rowSpan || 1);
-        let yMin2 = cell2.y;
-        let yMax2 = cell2.y - 1 + (cell2.rowSpan || 1);
-        let yConflict = !(yMin1 > yMax2 || yMin2 > yMax1);
-        let xMin1 = cell1.x;
-        let xMax1 = cell1.x - 1 + (cell1.colSpan || 1);
-        let xMin2 = cell2.x;
-        let xMax2 = cell2.x - 1 + (cell2.colSpan || 1);
-        let xConflict = !(xMin1 > xMax2 || xMin2 > xMax1);
+        const yMin1 = cell1.y;
+        const yMax1 = cell1.y - 1 + (cell1.rowSpan || 1);
+        const yMin2 = cell2.y;
+        const yMax2 = cell2.y - 1 + (cell2.rowSpan || 1);
+        const yConflict = !(yMin1 > yMax2 || yMin2 > yMax1);
+        const xMin1 = cell1.x;
+        const xMax1 = cell1.x - 1 + (cell1.colSpan || 1);
+        const xMin2 = cell2.x;
+        const xMax2 = cell2.x - 1 + (cell2.colSpan || 1);
+        const xConflict = !(xMin1 > xMax2 || xMin2 > xMax1);
         return yConflict && xConflict;
     }
     function conflictExists(rows, x, y) {
-        let i_max = Math.min(rows.length - 1, y);
-        let cell = { x: x, y: y };
+        const i_max = Math.min(rows.length - 1, y);
+        const cell = { x: x, y: y };
         for (let i = 0; i <= i_max; i++) {
-            let row = rows[i];
+            const row = rows[i];
             for (let j = 0; j < row.length; j++) {
                 if (cellsConflict(cell, row[j])) {
                     return true;
@@ -70,10 +69,10 @@ const { ColSpanCell, RowSpanCell } = Cell;
         return true;
     }
     function addRowSpanCells(table) {
-        table.forEach(function (row, rowIndex) {
-            row.forEach(function (cell) {
+        table.forEach((row, rowIndex) => {
+            row.forEach((cell) => {
                 for (let i = 1; i < cell.rowSpan; i++) {
-                    let rowSpanCell = new RowSpanCell(cell);
+                    const rowSpanCell = new RowSpanCell(cell);
                     rowSpanCell.x = cell.x;
                     rowSpanCell.y = cell.y + i;
                     rowSpanCell.colSpan = cell.colSpan;
@@ -84,11 +83,11 @@ const { ColSpanCell, RowSpanCell } = Cell;
     }
     function addColSpanCells(cellRows) {
         for (let rowIndex = cellRows.length - 1; rowIndex >= 0; rowIndex--) {
-            let cellColumns = cellRows[rowIndex];
+            const cellColumns = cellRows[rowIndex];
             for (let columnIndex = 0; columnIndex < cellColumns.length; columnIndex++) {
-                let cell = cellColumns[columnIndex];
+                const cell = cellColumns[columnIndex];
                 for (let k = 1; k < cell.colSpan; k++) {
-                    let colSpanCell = new ColSpanCell();
+                    const colSpanCell = new ColSpanCell();
                     colSpanCell.x = cell.x + k;
                     colSpanCell.y = cell.y;
                     cellColumns.splice(columnIndex + 1, 0, colSpanCell);
@@ -104,12 +103,12 @@ const { ColSpanCell, RowSpanCell } = Cell;
         row.splice(x, 0, cell);
     }
     function fillInTable(table) {
-        let h_max = maxHeight(table);
-        let w_max = maxWidth(table);
+        const h_max = maxHeight(table);
+        const w_max = maxWidth(table);
         for (let y = 0; y < h_max; y++) {
             for (let x = 0; x < w_max; x++) {
                 if (!conflictExists(table, x, y)) {
-                    let opts = { x: x, y: y, colSpan: 1, rowSpan: 1 };
+                    const opts = { x: x, y: y, colSpan: 1, rowSpan: 1 };
                     x++;
                     while (x < w_max && !conflictExists(table, x, y)) {
                         opts.colSpan++;
@@ -120,7 +119,7 @@ const { ColSpanCell, RowSpanCell } = Cell;
                         opts.rowSpan++;
                         y2++;
                     }
-                    let cell = new Cell(opts);
+                    const cell = new Cell(opts);
                     cell.x = opts.x;
                     cell.y = opts.y;
                     insertCell(cell, table[y]);
@@ -129,9 +128,9 @@ const { ColSpanCell, RowSpanCell } = Cell;
         }
     }
     function generateCells(rows) {
-        return rows.map(function (row) {
+        return rows.map((row) => {
             if (!Array.isArray(row)) {
-                let key = Object.keys(row)[0];
+                const key = Object.keys(row)[0];
                 row = row[key];
                 if (Array.isArray(row)) {
                     row = row.slice();
@@ -141,13 +140,13 @@ const { ColSpanCell, RowSpanCell } = Cell;
                     row = [key, row];
                 }
             }
-            return row.map(function (cell) {
+            return row.map((cell) => {
                 return new Cell(cell);
             });
         });
     }
     function makeTableLayout(rows) {
-        let cellRows = generateCells(rows);
+        const cellRows = generateCells(rows);
         layoutTable(cellRows);
         fillInTable(cellRows);
         addRowSpanCells(cellRows);
@@ -166,10 +165,10 @@ const { ColSpanCell, RowSpanCell } = Cell;
 })();
 function makeComputeWidths(colSpan, desiredWidth, x, forcedMin) {
     return function (vals, table) {
-        let result = [];
-        let spanners = [];
-        table.forEach(function (row) {
-            row.forEach(function (cell) {
+        const result = [];
+        const spanners = [];
+        table.forEach((row) => {
+            row.forEach((cell) => {
                 if ((cell[colSpan] || 1) > 1) {
                     spanners.push(cell);
                 }
@@ -178,15 +177,15 @@ function makeComputeWidths(colSpan, desiredWidth, x, forcedMin) {
                 }
             });
         });
-        vals.forEach(function (val, index) {
+        vals.forEach((val, index) => {
             if (typeof val === 'number') {
                 result[index] = val;
             }
         });
         for (let k = spanners.length - 1; k >= 0; k--) {
-            let cell = spanners[k];
-            let span = cell[colSpan];
-            let col = cell[x];
+            const cell = spanners[k];
+            const span = cell[colSpan];
+            const col = cell[x];
             let existingWidth = result[col];
             let editableCols = typeof vals[col] === 'number' ? 0 : 1;
             for (let i = 1; i < span; i++) {
@@ -199,7 +198,7 @@ function makeComputeWidths(colSpan, desiredWidth, x, forcedMin) {
                 let i = 0;
                 while (editableCols > 0 && cell[desiredWidth] > existingWidth) {
                     if (typeof vals[col + i] !== 'number') {
-                        let dif = Math.round((cell[desiredWidth] - existingWidth) / editableCols);
+                        const dif = Math.round((cell[desiredWidth] - existingWidth) / editableCols);
                         existingWidth += dif;
                         result[col + i] += dif;
                         editableCols--;
@@ -208,7 +207,7 @@ function makeComputeWidths(colSpan, desiredWidth, x, forcedMin) {
                 }
             }
         }
-        objectAssign(vals, result);
+        Object.assign(vals, result);
         for (let j = 0; j < vals.length; j++) {
             vals[j] = Math.max(forcedMin, vals[j] || 0);
         }

package/lib/cli_table/src/table.js

@@ -8,7 +8,7 @@ class Table extends Array {
     }
     toString() {
         let array = this;
-        let headersPresent = this.options.head && this.options.head.length;
+        const headersPresent = this.options.head && this.options.head.length;
         if (headersPresent) {
             array = [this.options.head];
             if (this.length) {
@@ -18,7 +18,7 @@ class Table extends Array {
         else {
             this.options.style.head = [];
         }
-        let cells = tableLayout.makeTableLayout(array);
+        const cells = tableLayout.makeTableLayout(array);
         cells.forEach(function (row) {
             row.forEach(function (cell) {
                 cell.mergeTableOptions(this.options, cells);
@@ -31,10 +31,10 @@ class Table extends Array {
                 cell.init(this.options);
             }, this);
         }, this);
-        let result = [];
+        const result = [];
         for (let rowIndex = 0; rowIndex < cells.length; rowIndex++) {
-            let row = cells[rowIndex];
-            let heightOfRow = this.options.rowHeights[rowIndex];
+            const row = cells[rowIndex];
+            const heightOfRow = this.options.rowHeights[rowIndex];
             if (rowIndex === 0 ||
                 !this.options.style.compact ||
                 (rowIndex == 1 && headersPresent)) {
@@ -50,16 +50,16 @@ class Table extends Array {
         return result.join('\n');
     }
     get width() {
-        let str = this.toString().split('\n');
+        const str = this.toString().split('\n');
         return str[0].length;
     }
 }
 function doDraw(row, lineNum, result) {
-    let line = [];
-    row.forEach(function (cell) {
+    const line = [];
+    row.forEach((cell) => {
         line.push(cell.draw(lineNum));
     });
-    let str = line.join('');
+    const str = line.join('');
     if (str.length) {
         result.push(str);
     }

package/lib/cli_table/src/utils.js

@@ -1,14 +1,13 @@
 "use strict";
-const objectAssign = require('object-assign');
 const stringWidth = require('string-width');
 function codeRegex(capture) {
     return capture ? /\u001b\[((?:\d*;){0,5}\d*)m/g : /\u001b\[(?:\d*;){0,5}\d*m/g;
 }
 function strlen(str) {
-    let code = codeRegex();
-    let stripped = ('' + str).replace(code, '');
-    let split = stripped.split('\n');
-    return split.reduce(function (memo, s) {
+    const code = codeRegex();
+    const stripped = ('' + str).replace(code, '');
+    const split = stripped.split('\n');
+    return split.reduce((memo, s) => {
         return stringWidth(s) > memo ? stringWidth(s) : memo;
     }, 0);
 }
@@ -16,17 +15,17 @@ function repeat(str, times) {
     return Array(times + 1).join(str);
 }
 function pad(str, len, pad, dir) {
-    let length = strlen(str);
+    const length = strlen(str);
     if (len + 1 >= length) {
-        let padlen = len - length;
+        const padlen = len - length;
         switch (dir) {
             case 'right': {
                 str = repeat(pad, padlen) + str;
                 break;
             }
             case 'center': {
-                let right = Math.ceil(padlen / 2);
-                let left = padlen - right;
+                const right = Math.ceil(padlen / 2);
+                const left = padlen - right;
                 str = repeat(pad, left) + str + repeat(pad, right);
                 break;
             }
@@ -38,7 +37,7 @@ function pad(str, len, pad, dir) {
     }
     return str;
 }
-let codeCache = {};
+const codeCache = {};
 function addToCodeCache(name, on, off) {
     on = '\u001b[' + on + 'm';
     off = '\u001b[' + off + 'm';
@@ -52,7 +51,7 @@ addToCodeCache('underline', 4, 24);
 addToCodeCache('inverse', 7, 27);
 addToCodeCache('strikethrough', 9, 29);
 function updateState(state, controlChars) {
-    let controlCode = controlChars[1] ? parseInt(controlChars[1].split(';')[0]) : 0;
+    const controlCode = controlChars[1] ? parseInt(controlChars[1].split(';')[0]) : 0;
     if ((controlCode >= 30 && controlCode <= 39) || (controlCode >= 90 && controlCode <= 97)) {
         state.lastForegroundAdded = controlChars[0];
         return;
@@ -62,22 +61,22 @@ function updateState(state, controlChars) {
         return;
     }
     if (controlCode === 0) {
-        for (let i in state) {
+        for (const i in state) {
             if (Object.prototype.hasOwnProperty.call(state, i)) {
                 delete state[i];
             }
         }
         return;
     }
-    let info = codeCache[controlChars[0]];
+    const info = codeCache[controlChars[0]];
     if (info) {
         state[info.set] = info.to;
     }
 }
 function readState(line) {
-    let code = codeRegex(true);
+    const code = codeRegex(true);
     let controlChars = code.exec(line);
-    let state = {};
+    const state = {};
     while (controlChars !== null) {
         updateState(state, controlChars);
         controlChars = code.exec(line);
@@ -85,11 +84,11 @@ function readState(line) {
     return state;
 }
 function unwindState(state, ret) {
-    let lastBackgroundAdded = state.lastBackgroundAdded;
-    let lastForegroundAdded = state.lastForegroundAdded;
+    const lastBackgroundAdded = state.lastBackgroundAdded;
+    const lastForegroundAdded = state.lastForegroundAdded;
     delete state.lastBackgroundAdded;
     delete state.lastForegroundAdded;
-    Object.keys(state).forEach(function (key) {
+    Object.keys(state).forEach((key) => {
         if (state[key]) {
             ret += codeCache[key].off;
         }
@@ -103,11 +102,11 @@ function unwindState(state, ret) {
     return ret;
 }
 function rewindState(state, ret) {
-    let lastBackgroundAdded = state.lastBackgroundAdded;
-    let lastForegroundAdded = state.lastForegroundAdded;
+    const lastBackgroundAdded = state.lastBackgroundAdded;
+    const lastForegroundAdded = state.lastForegroundAdded;
     delete state.lastBackgroundAdded;
     delete state.lastForegroundAdded;
-    Object.keys(state).forEach(function (key) {
+    Object.keys(state).forEach((key) => {
         if (state[key]) {
             ret = codeCache[key].on + ret;
         }
@@ -130,13 +129,13 @@ function truncateWidth(str, desiredLength) {
     return str;
 }
 function truncateWidthWithAnsi(str, desiredLength) {
-    let code = codeRegex(true);
-    let split = str.split(codeRegex());
+    const code = codeRegex(true);
+    const split = str.split(codeRegex());
     let splitIndex = 0;
     let retLen = 0;
     let ret = '';
     let myArray;
-    let state = {};
+    const state = {};
     while (retLen < desiredLength) {
         myArray = code.exec(str);
         let toAdd = split[splitIndex];
@@ -158,12 +157,12 @@ function truncateWidthWithAnsi(str, desiredLength) {
 }
 function truncate(str, desiredLength, truncateChar) {
     truncateChar = truncateChar || '…';
-    let lengthOfStr = strlen(str);
+    const lengthOfStr = strlen(str);
     if (lengthOfStr <= desiredLength) {
         return str;
     }
     desiredLength -= strlen(truncateChar);
-    let ret = truncateWidthWithAnsi(str, desiredLength);
+    const ret = truncateWidthWithAnsi(str, desiredLength);
     return ret + truncateChar;
 }
 function defaultOptions() {
@@ -203,19 +202,19 @@ function defaultOptions() {
 function mergeOptions(options, defaults) {
     options = options || {};
     defaults = defaults || defaultOptions();
-    let ret = objectAssign({}, defaults, options);
-    ret.chars = objectAssign({}, defaults.chars, options.chars);
-    ret.style = objectAssign({}, defaults.style, options.style);
+    const ret = Object.assign({}, defaults, options);
+    ret.chars = Object.assign({}, defaults.chars, options.chars);
+    ret.style = Object.assign({}, defaults.style, options.style);
     return ret;
 }
 function wordWrap(maxLength, input) {
-    let lines = [];
-    let split = input.split(/(\s+)/g);
+    const lines = [];
+    const split = input.split(/(\s+)/g);
     let line = [];
     let lineLength = 0;
     let whitespace;
     for (let i = 0; i < split.length; i += 2) {
-        let word = split[i];
+        const word = split[i];
         let newLength = lineLength + strlen(word);
         if (lineLength > 0 && whitespace) {
             newLength += whitespace.length;
@@ -239,7 +238,7 @@ function wordWrap(maxLength, input) {
     return lines;
 }
 function multiLineWordWrap(maxLength, input) {
-    let output = [];
+    const output = [];
     input = input.split('\n');
     for (let i = 0; i < input.length; i++) {
         output.push.apply(output, wordWrap(maxLength, input[i]));
@@ -248,11 +247,11 @@ function multiLineWordWrap(maxLength, input) {
 }
 function colorizeLines(input) {
     let state = {};
-    let output = [];
+    const output = [];
     for (let i = 0; i < input.length; i++) {
-        let line = rewindState(state, input[i]);
+        const line = rewindState(state, input[i]);
         state = readState(line);
-        let temp = objectAssign({}, state);
+        const temp = Object.assign({}, state);
         output.push(unwindState(temp, line));
     }
     return output;