xprogress 0.17.3 → 0.19.1

package/dist/index.js

@@ -1,1038 +0,0 @@
-"use strict";
-
-var _util = require("util");
-
-var _lodash = require("lodash");
-
-var _fs = require("fs");
-
-var _tty = _interopRequireDefault(require("tty"));
-
-var _events = _interopRequireDefault(require("events"));
-
-var _xbytes = _interopRequireDefault(require("xbytes"));
-
-var _stringd = _interopRequireDefault(require("stringd"));
-
-var _prettyMs = _interopRequireDefault(require("pretty-ms"));
-
-var _padRatio = _interopRequireDefault(require("pad-ratio"));
-
-var _stringdColors = _interopRequireDefault(require("stringd-colors"));
-
-var _speedometer = _interopRequireDefault(require("speedometer"));
-
-var _progressStream = _interopRequireDefault(require("progress-stream"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
-
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
-function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-var globOpts = {
-  bar: {
-    blank: '-',
-    filler: '#',
-    header: '',
-    colorize: !0,
-    separator: '',
-    pulsateSkip: 15,
-    pulsateLength: 15
-  },
-  label: 'Loading',
-  clean: !1,
-  // eslint-disable-next-line no-use-before-define
-  length: 40,
-  flipper: ['|', '/', '-', '\\'],
-  pulsate: !1,
-  template: '',
-  variables: _objectSpread(_objectSpread({
-    tag: function tag(_ref) {
-      var _tag = _ref.tag;
-      return _tag && typeof _tag !== 'function' ? "".concat(_tag, "\n") : '';
-    }
-  }, _stringdColors["default"].raw), {}, {
-    'color:bar:empty': ':{color:close}',
-    'color:bar:header': ':{color(green)}',
-    'color:bar:filled': ':{bgcolor(green)}:{color(black)}',
-    'color:bar:separator': ''
-  }),
-  forceFirst: !1
-};
-
-var defaultOptions = _objectSpread(_objectSpread({}, globOpts), {}, {
-  template: ':{tag}[:{bar}] :{flipper} :{label} :3{percentage}% [:{completed}/:{total}]'
-});
-
-var streamOpts = _objectSpread(_objectSpread({}, globOpts), {}, {
-  pulsate: false,
-  progress: {
-    time: 100,
-    pulsate: false,
-    infinite: !1,
-    pulsateSkip: 15,
-    pulsateLength: 15
-  },
-  template: [':{label}', ' |:{slot:bar}| [:3{slot:percentage}%] (:{slot:eta}) [:{speed}] [:{slot:size}/:{slot:size:total}]', ' [:{bar}] [:3{percentage}%] (:{eta}) [:{size}/:{size:total}]'],
-  variables: _objectSpread(_objectSpread({}, globOpts.variables), {}, {
-    eta: null,
-    size: null,
-    speed: null,
-    progress: null,
-    'eta:raw': null,
-    'slot:bar': null,
-    'slot:blank': null,
-    'slot:eta': null,
-    'slot:eta:raw': null,
-    'slot:filler': null,
-    'slot:header': null,
-    'slot:size': null,
-    'slot:total': null,
-    'slot:runtime': null,
-    'slot:runtime:raw': null,
-    'slot:percentage': null,
-    'slot:size:total': null
-  }),
-  stageOpts: {}
-});
-/**
- * Get a persistent tty output stream
- * @returns {tty.WriteStream} The writable stream instance similar to `process.stdout`
- */
-
-
-function getPersistentStdout() {
-  var self = getPersistentStdout;
-  self.stdout = self.stdout && self.stdout.isTTY ? self.stdout : process.stdout.isTTY ? process.stdout : process.stderr.isTTY ? process.stderr : new _tty["default"].WriteStream((0, _fs.openSync)('/dev/tty', 'w'));
-  return self.stdout;
-}
-/**
- * Get a current flipper
- * @param {Number} count Value that determines the flipper
- * @param {String|String[]} flippers String or (Array of strigs) of flippers
- */
-
-
-var flipper = function getFlipper() {
-  function subflipper(count, flippers) {
-    var manageInt = function manageInt(max, val) {
-      return val > max ? manageInt(max, val - max) : val;
-    };
-
-    return flippers[manageInt(flippers.length, count) - 1];
-  }
-
-  return subflipper.count = 0, subflipper;
-}();
-/**
- * Parse a bar, returning a styled bar with a given percentage filled
- * @param {_defaultOptions} opts The options for the bar being parsed
- * @param {Number} fillable Maximum fillable slots
- * @param {Number} percentage Percentage filled
- * @param {Boolean} headers Whether or not to add headers to the bar
- */
-
-
-function parseBar(opts, fillable, percentage) {
-  var headers = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : !opts.pulsate;
-  fillable = Math.round(fillable);
-  var filled = Math.round(Math.min(100, percentage) / 100 * fillable);
-  var empty = fillable - filled; // eslint-disable-next-line prefer-const
-
-  var _opts$bar = opts.bar,
-      filler = _opts$bar.filler,
-      blank = _opts$bar.blank,
-      header = _opts$bar.header;
-
-  var _map = [filled, empty].map(Math.floor);
-
-  var _map2 = _slicedToArray(_map, 2);
-
-  filled = _map2[0];
-  empty = _map2[1];
-
-  var _map3 = [filler, blank].map(function (content) {
-    return Array.isArray(content) || typeof content === 'string' ? content : '';
-  });
-
-  var _map4 = _slicedToArray(_map3, 2);
-
-  filler = _map4[0];
-  blank = _map4[1];
-  return (0, _stringd["default"])([":{color:bar:filled}".concat(filler.repeat(filled)), ":{color:bar:header}".concat(headers ? header : ''), ":{color:bar:empty}".concat(blank.repeat(empty)), ''].join(':{color:close}:{bgcolor:close}'), opts.variables);
-}
-
-var xprettyMs = function (_) {
-  return function (sec) {
-    return Number.isFinite(sec) ? _(sec) : "\u221E";
-  };
-}(_prettyMs["default"]);
-/**
- * Create a pulsate bar
- * @param {ProgressBar} bar The bar to be pulsated
- * @param {Array} slots Pulsate slots to be used
- * @param {number} skip Valuation for by how much to skip the bar
- * @param {string} sep The separator to be used on the bar
- */
-
-
-function pulsateBar(bar, slots, skip) {
-  var sep = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';
-  if (slots[0].level + slots[1].level >= 100) slots[0].level = 100 - slots[1].level;
-  var total = bar.length() - sep.length * 2;
-  var stack = [].concat(_toConsumableArray(slots), [{
-    level: 100 - (slots[0].level + slots[1].level),
-    value: 0
-  }]).map(function (_ref2) {
-    var level = _ref2.level,
-        value = _ref2.value;
-    return {
-      fillable: Math.round(level / 100 * total),
-      percentage: value
-    };
-  });
-  if (slots[0].level + slots[1].level === 100) slots[0].level = 0;else slots[0].level += skip;
-  stack[stack.length - 1].fillable += total - Math.min(total, stack.reduce(function (max, _ref3) {
-    var fillable = _ref3.fillable;
-    return max + fillable;
-  }, 0));
-  return stack.map(function (_ref4) {
-    var fillable = _ref4.fillable,
-        percentage = _ref4.percentage;
-    return parseBar(bar.opts, fillable, percentage, false);
-  });
-}
-
-var ProgressGen = /*#__PURE__*/function (_EventEmitter) {
-  _inherits(ProgressGen, _EventEmitter);
-
-  var _super = _createSuper(ProgressGen);
-
-  function ProgressGen() {
-    _classCallCheck(this, ProgressGen);
-
-    return _super.apply(this, arguments);
-  }
-
-  return ProgressGen;
-}(_events["default"]);
-
-var ProgressBar = /*#__PURE__*/function () {
-  /**
-   * Build a progress bar
-   * @param {Number} total Max attainable value by the progressBar
-   * @param {((size) => Number|Number[])|Number|Number[]} arr Allocation of slots by value
-   * @param {_defaultOptions} opts Attachable options
-   */
-  function ProgressBar(total) {
-    var arr = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [total];
-    var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-
-    _classCallCheck(this, ProgressBar);
-
-    if (!(total && typeof total === 'number')) throw Error('<ProgressBar> must have a max integer value');
-    if (typeof arr === 'function') arr = arr(total);
-
-    if (_typeof(arr) === 'object' && !Array.isArray(arr)) {
-      var _ref5 = [[total], arr];
-      arr = _ref5[0];
-      opts = _ref5[1];
-    }
-
-    this.opts = _objectSpread(_objectSpread(_objectSpread({}, defaultOptions), opts), {}, {
-      bar: _objectSpread(_objectSpread({}, defaultOptions.bar), opts.bar),
-      variables: _objectSpread(_objectSpread({}, defaultOptions.variables), opts.variables)
-    });
-    this.cores = {
-      total: total,
-      label: this.opts.label,
-      append: [],
-      length: this.opts.length,
-      stdout: getPersistentStdout(),
-      pulsateSlots: [[0, 0], [this.opts.bar.pulsateLength, 100]].map(function (_ref6) {
-        var _ref7 = _slicedToArray(_ref6, 2),
-            level = _ref7[0],
-            value = _ref7[1];
-
-        return {
-          level: level,
-          value: value
-        };
-      })
-    };
-    var self = this;
-    this.slots = (0, _padRatio["default"])(arr, total, false).map(function (max) {
-      return Object.defineProperties({
-        max: max,
-        done: 0
-      }, {
-        level: {
-          get: function get() {
-            return this.max / self.total() * 100;
-          },
-          configurable: true,
-          enumerable: true
-        },
-        percentage: {
-          get: function get() {
-            return this.done / this.max * 100;
-          },
-          configurable: true,
-          enumerable: true
-        }
-      });
-    });
-    delete this.opts.blot;
-    delete this.opts.label;
-    delete this.opts.append;
-    delete this.opts.length;
-  }
-  /**
-   * Label the progressbar while returning itself
-   * @param {String} label The string label
-   */
-
-
-  _createClass(ProgressBar, [{
-    key: "label",
-    value: function label(_label) {
-      return _label ? (this.cores.label = _label, this) : this.cores.label;
-    }
-    /**
-     * Return or set the max length of the progressbar
-     * @param {number} [value] The value to set the progressBar length to
-     */
-
-  }, {
-    key: "length",
-    value: function length(value) {
-      var len = getPersistentStdout().columns;
-      var core = this.cores.length;
-
-      if (value && ['function', 'number'].includes(_typeof(value))) {
-        this.cores.length = value;
-        return this;
-      }
-
-      var ret;
-      if (typeof core === 'function') ret = core(len);
-      if (!ret && typeof core === 'number') ret = core < 0 ? len + core : Math.min(core, 100) / 100 * len;
-      if (typeof ret !== 'number') throw new Error('length of the bar must be a valid number');
-      return Math.floor(ret);
-    }
-    /**
-     * Return or update the total level of the progressbar
-     * @param {number} [value] The number to be added to the total level
-     * @param {{}} [template] Template variable values to be included into core options
-     */
-
-  }, {
-    key: "total",
-    value: function total(value, template) {
-      var _this = this;
-
-      if (value && Number.isFinite(value)) {
-        if (value < this.average().completed) throw new Error("<value> must not be lower than already completed value");
-        this.slots.map(function (v, r) {
-          return v.max = (r = v.max, v.max * value / _this.total()), v.done = v.done * v.max / r;
-        });
-        this.cores.total = Math.floor(value) ? value : 0;
-        Object.assign(this.opts.template, template);
-        return this;
-      }
-
-      return this.cores.total;
-    }
-    /**
-     * Update the progressbar slots with certain percentages
-     * - This will top up the current slots with the inputed values as opposed to `this.progress(levels)`
-     * - The progressbar would be automatically drawn if [template] is provided
-     * @param {Number|Number[]} levels Level(s) to update the slots with
-     * @param {{}} [template] Template variable values to use on the drawn progress bar
-     */
-
-  }, {
-    key: "tick",
-    value: function tick(levels, template) {
-      levels = typeof levels === 'number' ? Array(this.slots.length).fill(levels) : Array.isArray(levels) ? levels : Array(this.slots.length).fill(0);
-      var res;
-      return this.percentage(this.slots.map(function (slot, index) {
-        return res = slot.percentage + Math.floor(levels[index]), res > 100 ? 100 : res;
-      }), template);
-    }
-    /**
-     * Update the progressbar slots with certain values
-     * - This will top up the current slots with the inputed values as opposed to `this.progress(levels)`
-     * - The progressbar would be automatically drawn if [template] is provided
-     * @param {Number|Number[]} levels Level(s) to update the slots with
-     * @param {{}} [template] Template variable values to use on the drawn progress bar
-     */
-
-  }, {
-    key: "tickValue",
-    value: function tickValue(levels, template) {
-      levels = typeof levels === 'number' ? Array(this.slots.length).fill(levels) : Array.isArray(levels) ? levels : Array(this.slots.length).fill(0);
-      return this.value(this.slots.map(function (slot, index) {
-        return slot.done + Math.floor(levels[index]);
-      }), template);
-    }
-    /**
-     * Update the progressbar to a percentage
-     * - The progressbar would be automatically drawn if [template] is provided
-     * @param {number|number[]} index The index at which to replace percentage or an array of slot percentages
-     * @param {number} [value] if (index::number) the percentage for the specified index
-     * @param {{}} [template] Template variable values to use on the drawn progress bar
-     * @example
-     *  > this.percentage(50, {}) // Update the entire bar to 50%
-     *  > this.percentage(1, 20, {}) // Set the percentage of the first slot to 20%
-     *  > this.percentage([40,20,70], {}) // Set the percentage of the slots according to array specification
-     */
-
-  }, {
-    key: "percentage",
-    value: function percentage(index, value, template) {
-      if (this.isEnded) throw Error('This bar has been ended and is now immutable');
-      var _ref8 = [function (input, msg) {
-        if (!(Array.isArray(input) ? input : [input]).every(function (v) {
-          return typeof v === 'number';
-        })) throw new Error(msg);else return input;
-      }, function (slots, val, i) {
-        slots[i].done = parseType(val <= 0 || Math.floor(val) > 100 || val > 100 ? Math.floor(val) : val, "Percentage [".concat(val, "] must be in the range [0 < X < 100]")) / 100 * slots[i].max || slots[i].done;
-      }],
-          parseType = _ref8[0],
-          inferParse = _ref8[1];
-      var bars = [this].concat(_toConsumableArray(this.cores.append.reduce(function (a, v) {
-        return v.inherit && a.push(v.bar), a;
-      }, [])));
-      if (arguments.length > 1 && value && _typeof(value) !== 'object') parseType([index, value <= 0 || Math.floor(value) > 100 || value > 100 ? Math.floor(value) : value], "<index> and <value> must be of type `number`, <number> must be in the range [0 < X < 100]"), bars.map(function (_ref9) {
-        var slots = _ref9.slots;
-        return slots[index].done = value / slots[index].max * 100 || slots[index].value;
-      });else template = value, bars.map(function (_ref10) {
-        var slots = _ref10.slots;
-        return Array.isArray(index) ? index.map(function (val, i) {
-          return inferParse(slots, val, i);
-        }) : slots.map(function (_slot, i) {
-          return inferParse(slots, index, i);
-        });
-      });
-      return !template ? this : this.draw(template);
-    }
-  }, {
-    key: "value",
-    value: function value(index, _value, template) {
-      function inferParse(slots, val, i) {
-        if (val >= 0) {
-          if (val <= slots[i].max) slots[i].done = val;else throw new Error("Slot index [".concat(i, "] is being updated with more than it can hold [").concat(val, " > ").concat(slots[i].max, "]"));
-        } else throw new Error("Slot index [".concat(i, "] is being updated with [").concat(val, "] which is less than 0"));
-      }
-
-      var bars = [this].concat(_toConsumableArray(this.cores.append.reduce(function (a, v) {
-        return v.inherit && a.push(v.bar), a;
-      }, [])));
-      if (arguments.length > 1 && _value && _typeof(_value) !== 'object') bars.map(function (_ref11) {
-        var slots = _ref11.slots;
-        return slots[index].done = _value || slots[index].done;
-      });else template = _value, bars.map(function (_ref12) {
-        var slots = _ref12.slots;
-        return Array.isArray(index) ? index.map(function (val, i) {
-          return inferParse(slots, val, i);
-        }) : slots.map(function (_slot, i) {
-          return inferParse(slots, index, i);
-        });
-      });
-      return !template ? this : this.draw(template);
-    }
-    /**
-     * Get an average round up of values in percentage and current progress compatred to the total
-     * @param {Number} [fixedPoint] The fixed point at which to approximate average values to
-     * @returns {{completed:number, remaining:number, percentage:number}}
-     */
-
-  }, {
-    key: "average",
-    value: function average(fixedPoint) {
-      var completed = this.slots.reduce(function (a, b) {
-        return a + b.done;
-      }, 0);
-      var percentage = completed / this.total() * 100;
-      var remaining = this.total() - completed;
-
-      var _map5 = [percentage, completed, remaining].map(function (value) {
-        return fixedPoint ? parseFloat(value.toFixed(fixedPoint)) : value;
-      });
-
-      var _map6 = _slicedToArray(_map5, 3);
-
-      percentage = _map6[0];
-      completed = _map6[1];
-      remaining = _map6[2];
-      return {
-        completed: completed,
-        remaining: remaining,
-        percentage: percentage
-      };
-    }
-    /**
-     * Draw the progressbar, apply template options to the template
-     * @param {String|Object} [template] The template to use on the drawn progress bar or an array of predrawn progressbar from `this.constructBar` like `this.oldBar`
-     */
-
-  }, {
-    key: "draw",
-    value: function draw(template) {
-      var result = Array.isArray(template) ? template : [].concat(_toConsumableArray(this.constructBar(template).split('\n')), _toConsumableArray(this.cores.append.map(function (block) {
-        return block.bar.constructBar(block.inherit ? template : null);
-      })));
-      this.oldBar = result;
-      this.print("bar".concat(result.length ? "+".concat(result.length - 1) : ''), result.join('\n'));
-      this.hasBarredOnce = !0;
-      return this;
-    }
-  }, {
-    key: "constructBar",
-    value: function constructBar(template) {
-      var _this2 = this;
-
-      var forcedFirst = [parseBar(this.opts, this.length() - this.opts.bar.header.length, this.average().percentage, this.opts.bar.header)];
-      var bars = !this.opts.pulsate ? !this.opts.forceFirst ? function () {
-        var total = Math.max(0, _this2.length() + [[_this2.opts.bar.header, 0], [_this2.opts.bar.separator, -1]].reduce(function (a, _ref13) {
-          var _ref14 = _slicedToArray(_ref13, 2),
-              v = _ref14[0],
-              e = _ref14[1];
-
-          return a - (v.length ? v.length * _this2.slots.length + e : 0);
-        }, 0));
-
-        var slotting = _this2.slots.map(function (_ref15) {
-          var level = _ref15.level,
-              percentage = _ref15.percentage;
-          return {
-            portion: Math.floor(level / 100 * total),
-            percentage: percentage
-          };
-        });
-
-        var slack = total - slotting.reduce(function (max, _ref16) {
-          var portion = _ref16.portion;
-          return max + portion;
-        }, 0);
-        slotting.slice(-1).pop().portion += slack;
-        var result = slotting.map(function (_ref17) {
-          var portion = _ref17.portion,
-              percentage = _ref17.percentage;
-          return parseBar(_this2.opts, portion, percentage);
-        });
-        return result;
-      }() : forcedFirst : pulsateBar(this, this.cores.pulsateSlots, this.opts.bar.pulsateSkip, this.opts.bar.separator);
-      var templateString = Array.isArray(this.opts.template) ? this.opts.template.join('\n') : this.opts.template;
-      var average = this.average();
-      return this.parseString(templateString, _objectSpread(_objectSpread({
-        bar: bars.join(":{color:bar:separator}".concat(this.opts.bar.separator, ":{color:close}:{bgcolor:close}")),
-        'bar:complete': forcedFirst.join(''),
-        label: this.label(),
-        total: this.total(),
-        flipper: flipper(flipper.count += 1, this.opts.flipper)
-      }, average), {}, {
-        percentage: average.percentage.toFixed(0)
-      }, template));
-    }
-  }, {
-    key: "parseString",
-    value: function parseString(str, template) {
-      var variables = _objectSpread({}, template = _objectSpread(_objectSpread({}, this.opts.variables), template));
-
-      Object.entries(this.opts.variables).forEach(function (_ref18) {
-        var _ref19 = _slicedToArray(_ref18, 2),
-            spec = _ref19[0],
-            content = _ref19[1];
-
-        return typeof content === 'function' && content !== template[spec] && (template[spec] = content(template));
-      });
-      return (0, _stringd["default"])((0, _stringd["default"])(str, template), variables);
-    }
-    /**
-     * Print a message after a bar `draw` interrupt
-     * @param {'bar'|'end'} type Type of bar print or the first part of the printer
-     * @param {any[]} content The contents to be formatted
-     */
-
-  }, {
-    key: "print",
-    value: function print(type) {
-      var self = this;
-      type = (0, _util.format)(type);
-      if (!self.cores.stdout.isTTY) throw Error("Can't draw or print progressBar interrupts with piped output");
-
-      var cleanWrite = function cleanWrite(arr, dontClean) {
-        var addons = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-        var ending = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-
-        if (!dontClean) {
-          self.cores.stdout.moveCursor(0, -addons);
-          self.cores.stdout.cursorTo(0);
-          self.cores.stdout.clearScreenDown();
-        }
-
-        self.cores.stdout.write("".concat(dontClean && ending && addons ? '\n' : '').concat(self.parseString(_util.format.apply(void 0, _toConsumableArray(arr))).replace(self.opts.bar.colorize ? '' : /\x1b\[\d+m/g, '')));
-      };
-
-      var addonPack;
-      var addons = this.hasBarredOnce && !this.justLogged ? this.oldBar.length - 1 : 0;
-
-      for (var _len = arguments.length, content = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-        content[_key - 1] = arguments[_key];
-      }
-
-      this.justLogged = type === 'bar' && content.length === 1 ? !!cleanWrite(content, this.justLogged, addons) : (addonPack = type.match(/^bar\+(\d+)/)) !== null ? !!cleanWrite(content, this.justLogged, this.hasBarredOnce ? addonPack[1] : addons) : type === 'end' ? !!cleanWrite(content, !this.opts.clean, addons, true) : !cleanWrite([type.startsWith(':') && "".concat(type.slice(1)) || type].concat(content, ['\n']), this.justLogged, addons);
-      if (this.justLogged && this.hasBarredOnce) this.draw(this.oldBar);
-      return this;
-    }
-    /**
-     * End the bar irrespective of progress, optionally with a message.
-     * @param {any[]} [message] The message to be printed to `stdout` right before ending the bar
-     */
-
-  }, {
-    key: "end",
-    value: function end() {
-      if (!this.isEnded) {
-        for (var _len2 = arguments.length, message = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-          message[_key2] = arguments[_key2];
-        }
-
-        if (message.length) this.print.apply(this, ['end'].concat(message));
-        this.isEnded = !0;
-      }
-
-      return this;
-    }
-    /**
-     * Drain all slots in the progressbar to 0
-     */
-
-  }, {
-    key: "drain",
-    value: function drain(slotID) {
-      if (slotID) this.slots[slotID].done = 0;else this.slots.map(function (slot) {
-        return slot.done = 0, slot;
-      });
-      return this;
-    }
-    /**
-     * Drop the chain, return void
-     */
-    // eslint-disable-next-line class-methods-use-this
-
-  }, {
-    key: "drop",
-    value: function drop() {}
-    /**
-     * Append the specified bar after `this`
-     * @param {ProgressBar} bar The bar to be appended
-     * @param {Boolean} inherit Whether or not to inherit bar templates from `this`
-     */
-
-  }, {
-    key: "append",
-    value: function append(bar) {
-      var inherit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : !1;
-      if (!ProgressBar.isBar(bar) && !bar.opts.template) throw Error('The Parameter <bar> is not a progressbar or a hanger');
-      this.cores.append.push({
-        bar: bar,
-        inherit: inherit
-      });
-      bar.cores.isKid = !0;
-      return this;
-    }
-    /**
-     * Check if the bar or a slot is complete
-     * @param {Number} [slot] The slot to be checked for completion
-     */
-
-  }, {
-    key: "isComplete",
-    value: function isComplete(slot) {
-      if (slot && !this.slots[slot]) throw Error("Value in <slot>:".concat(slot, " has no slot reference"));
-      return slot ? this.slots[slot].max === this.slots[slot].done : this.average().remaining === 0;
-    }
-    /**
-     * Find out the progressbar is appended to another
-     */
-
-  }, {
-    key: "slotStreamify",
-
-    /**
-     * Prepare a raw generator for use
-     * @param {(slots:Number, total?:Number) => String} actor The performing function
-     * @returns {Generator} New ProgressBar Generator
-     * @yields The through instance or a cache model of the ProgressBar
-     */
-    value: function* slotStreamify(actor, args) {
-      for (var level = -1; (level += 1) <= (this.opts.progress.infinite ? Infinity : this.slots.length);) {
-        args = yield !level ? this : ((0, _lodash.merge)(this.opts, args[1]), actor(Math.floor(level - 1), args[0], this.opts.progress.infinite));
-      }
-    }
-  }, {
-    key: "isChild",
-    get: function get() {
-      return !!this.cores.isKid;
-    }
-    /**
-     * Check if the progressbar is active.
-     * - Activity is determined when the progressbar is not complete
-     */
-
-  }, {
-    key: "isActive",
-    get: function get() {
-      return !this.isComplete();
-    }
-    /**
-     * Check if the bar is fresh.
-     * - Equivalent of `this.isActive && !this.average().value`
-     */
-
-  }, {
-    key: "isFresh",
-    get: function get() {
-      return this.isActive && !this.average().completed;
-    }
-    /**
-     * Check if the provided progressbar is an instance of `this`
-     * @param {ProgressBar} bar The progressbar to be checked
-     */
-
-  }], [{
-    key: "isBar",
-    value: function isBar(bar) {
-      return bar instanceof ProgressBar;
-    }
-    /**
-     * Check if the provided progressbar is an stream instance of `this`
-     * @param {ProgressBar} bar The progressbar to be checked
-     */
-
-  }, {
-    key: "isBarStream",
-    value: function isBarStream(barStream) {
-      return !!barStream && ProgressBar.isBar(barStream.bar) && barStream instanceof _events["default"] && [barStream.read, barStream.write].every(function (slot) {
-        return typeof slot === 'function';
-      });
-    }
-    /**
-     * Check if the provided object is a stream progressbar generator
-     * @param {any} bar The progressbar to be checked
-     */
-
-  }, {
-    key: "isBarGen",
-    value: function isBarGen(barStream) {
-      return !!barStream && ProgressBar.isBar(barStream.bar) && barStream instanceof _events["default"] && typeof barStream.next === 'function';
-    }
-    /**
-     * Check if the provided object is related to any instances created by this script
-     * @param {any} bar The progressbar to be checked
-     */
-
-  }, {
-    key: "isBarRelated",
-    value: function isBarRelated(barStream) {
-      return ProgressBar.isBar(barStream) || ProgressBar.isBarStream(barStream) || ProgressBar.isBarGen(barStream);
-    }
-    /**
-     * Calculate slot levels by number of slots
-     * @param {number} len Each slot length, inferrable if ratio doesn't make 100 or pop-able if over 100
-     */
-
-  }, {
-    key: "slotsByCount",
-    value: function slotsByCount(len) {
-      return function (size) {
-        return (0, _padRatio["default"])(Array(len).fill(size / len), size, false);
-      };
-    }
-    /**
-     * Calculate slot levels by size
-     * @param {number} size Maximum possible total size
-     * @param {number[]} percentages Each slot length, inferrable if ratio doesn't make 100 or pop-able if over 100
-     */
-
-  }, {
-    key: "slotsByPercentage",
-    value: function slotsByPercentage(percentages) {
-      return function (size) {
-        return (0, _padRatio["default"])(percentages.map(function (_size) {
-          return _size / 100 * size;
-        }), size);
-      };
-    }
-    /**
-     * Create a streamified bar for use with generators
-     * @param {Number} total Total attainable value of bytes in <N>
-     * @param {Number|Number[]} slots Number of slots in <%>
-     * @param {_streamOpts} [opts] Options for the bar
-     * @param {(bar:ProgressBar,slotLevel:Number,template:{}) => void} [actor] The actor for every yield
-     */
-
-  }, {
-    key: "stream",
-    value: function stream(total, slots, opts, actor) {
-      // if (typeof slots === 'function') [slots, opts, actor] = [, {}, slots];
-      if (typeof opts === 'function') {
-        var _ref20 = [{}, opts];
-        opts = _ref20[0];
-        actor = _ref20[1];
-      }
-
-      if (_typeof(slots) === 'object' & !Array.isArray(slots)) {
-        var _ref21 = [, slots];
-        slots = _ref21[0];
-        opts = _ref21[1];
-      }
-
-      opts = _objectSpread(_objectSpread(_objectSpread({}, total === Infinity ? {
-        pulsate: !0,
-        template: ':{tag}[:{bar}] [:{flipper}] :{label} (:{slot:runtime}) :{slot:size}'
-      } : {}), opts), slots === Infinity ? (slots = total, {
-        progress: {
-          infinite: !0
-        }
-      }) : {});
-      var progressBar = new ProgressBar(total, slots, opts);
-      return ProgressBar.streamify(progressBar, actor, opts);
-    }
-    /**
-     * Streamify a bar for use with generators
-     * @param {ProgressBar} bar The bar to be used
-     * @param {(bar:ProgressBar, slotLevel:Number, template:() => {completed:number, remaining:number, percentage:number}) => void} [actor] The actor for every yield
-     * @param {_streamOpts} [opts] Options for the bar
-     * @returns {{next(size: Number, opts: _streamOpts):NodeJS.WritableStream, bar:ProgressBar}} Returned function from `ProgressBar.streamify`
-     */
-
-  }, {
-    key: "streamify",
-    value: function streamify(bar, actor, opts) {
-      if (_typeof(actor) === 'object') {
-        var _ref22 = [, actor];
-        actor = _ref22[0];
-        opts = _ref22[1];
-      }
-
-      bar.opts = (0, _lodash.merge)({}, bar.opts, streamOpts, opts);
-      bar.opts.template = opts.template || streamOpts.template;
-      var _ref23 = [[[0, 0], [bar.opts.progress.pulsateLength || bar.opts.bar.pulsateLength, 100]].map(function (_ref24) {
-        var _ref25 = _slicedToArray(_ref24, 2),
-            level = _ref25[0],
-            value = _ref25[1];
-
-        return {
-          level: level,
-          value: value
-        };
-      }), bar.opts.progress.pulsateSkip || bar.opts.bar.pulsateSkip],
-          pulsateSlots = _ref23[0],
-          pulsateSkips = _ref23[1];
-
-      var _defaultUnit;
-
-      var progressGen = new ProgressGen();
-
-      var buildBytesWith = function buildBytesWith(bytes) {
-        var byteOpts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-        return function (props, data) {
-          return _xbytes["default"].createRelativeSizer(data && (data.args[0] || data.matched.unit) || _defaultUnit, {
-            iec: data && 'iec' in data.matched ? data.matched.iec === 'true' : byteOpts.iec || !1,
-            bits: data && 'bits' in data.matched ? data.matched.bits === 'true' : byteOpts.bits || !1,
-            fixed: data && 'fixed' in data.matched ? parseInt(data.matched.fixed, 10) : byteOpts.fixed || 2,
-            "short": data && 'short' in data.matched ? data.matched["short"] === 'true' : byteOpts["short"] || !0,
-            space: data && 'space' in data.matched ? data.matched.space === 'true' : byteOpts.space || !0,
-            sticky: data && 'sticky' in data.matched ? data.matched.sticky === 'true' : byteOpts.sticky || !1
-          })(typeof bytes === 'function' ? bytes(props) : bytes);
-        };
-      };
-
-      var buildSpeedWith = function buildSpeedWith(speed) {
-        return function (_, data) {
-          return "".concat(buildBytesWith(speed, {
-            iec: !1,
-            bits: !0,
-            fixed: 2,
-            "short": !0,
-            space: !1,
-            sticky: !1
-          })(_, data)).concat(data && data.matched.metric || 'ps');
-        };
-      };
-
-      var totalSpeed = (0, _speedometer["default"])(5000);
-      var streamGenerator = bar.slotStreamify(function (slotIndex, total, infinite) {
-        var max = !infinite ? Math.round(bar.slots[slotIndex].level / 100 * bar.total()) : Infinity;
-        total = typeof total === 'function' ? total(bar) : total || max;
-        if (!infinite && total > max) throw Error("<size> slot must not be greater than maximum possible size for the slot [".concat(max, "], consider using infinite slots"));
-        var through = (0, _progressStream["default"])(_objectSpread({
-          length: total
-        }, bar.opts.progress)).on('progress', function (progress) {
-          var speed = totalSpeed(progress.delta);
-
-          if (bar.isEnded) {
-            through.emit('error', Error('The <bar> being used has been ended'));
-            return;
-          }
-
-          (actor || function (_bar, args, template) {
-            return _bar.value.apply(_bar, _toConsumableArray(args)).draw(template);
-          })(bar, bar.opts.progress.infinite ? [progress.delta + bar.average().completed] : [slotIndex, progress.transferred], {
-            eta: function eta() {
-              return xprettyMs(1000 * bar.average().remaining / speed);
-            },
-            size: buildBytesWith(function () {
-              return bar.average().completed;
-            }),
-            speed: buildSpeedWith(speed),
-            'speed:raw': speed,
-            'slot:speed': buildSpeedWith(progress.speed),
-            'slot:speed:raw': progress.speed,
-            progress: progress,
-            'eta:raw': function etaRaw() {
-              return Math.round(bar.average().remaining / speed);
-            },
-            'slot:bar': function slotBar() {
-              return bar.opts.progress.pulsate ? pulsateBar(bar, pulsateSlots, pulsateSkips, bar.opts.bar.separator).join('') : function () {
-                var header = bar.opts.bar['slot:header'] || bar.opts.bar.header;
-                var filler = bar.opts.bar['slot:filler'] || bar.opts.bar.filler;
-                var blank = bar.opts.bar['slot:blank'] || bar.opts.bar.blank;
-                return parseBar((0, _lodash.merge)({}, bar.opts, {
-                  bar: {
-                    header: header,
-                    filler: filler,
-                    blank: blank
-                  }
-                }), bar.length() - (header || '').length, progress.percentage);
-              }();
-            },
-            'slot:eta': xprettyMs(1000 * progress.eta),
-            'slot:eta:raw': progress.eta,
-            'slot:size': buildBytesWith(progress.transferred),
-            'slot:size:raw': progress.transferred,
-            'size:total': buildBytesWith(function () {
-              return bar.total();
-            }),
-            'slot:runtime': xprettyMs(1000 * progress.runtime),
-            'slot:runtime:raw': progress.runtime,
-            'slot:percentage': progress.percentage.toFixed(0),
-            'slot:size:total': buildBytesWith(progress.length),
-            'slot:size:total:raw': progress.length
-          });
-          [through, progressGen].map(function (emitter) {
-            return emitter.emit('tick', {
-              progress: progress,
-              bar: bar
-            });
-          });
-        }).on('end', function () {
-          return bar.isComplete() ? progressGen.emit('complete', bar) : null, progressGen.emit('end', bar);
-        }).once('error', function (error) {
-          return bar.end(":{color(red)}[Bar Error]:{color:close} An Error occurred\n".concat(error));
-        }); // through.emit = (tr => (...args) => (bar.print('tr>', args[0]), tr.call(through, ...args)))(through.emit)
-
-        return through.bar = bar, through;
-      });
-      return Object.assign(progressGen, {
-        /**
-         * Get the next PassThrough instance
-         * @param {number} [size] Size for the next chunk (Omittable)
-         * @param {_streamOpts} [options] Bar options
-         * @returns {NodeJS.WritableStream} Returned function from `ProgressBar.streamify`
-         */
-        next: function next(size, options) {
-          return streamGenerator.next(_toConsumableArray(typeof size === 'number' ? [size, options] : [, size])).value;
-        },
-
-        /**
-         * End the bar irrespective of progress, optionally with a message.
-         * @param {any[]} [message] The message to be printed to `stdout` right before ending the bar
-         * @returns {ProgressBar} The ProgressBar
-         */
-        end: function end() {
-          return bar.end.apply(bar, arguments);
-        },
-
-        /**
-         * Print a message after a bar `draw` interrupt
-         * @param {any[]} message The message to printed
-         * @returns {ProgressBar} The ProgressBar
-         */
-        print: function print() {
-          return bar.print.apply(bar, arguments);
-        },
-
-        /**
-         * Set the default unit
-         * @param {xbytes.AllUnitStacks} unit Preferred unit representation
-         * @returns {ProgressBar} The ProgressBar
-         */
-        defaultUnit: function defaultUnit(unit) {
-          if (!_xbytes["default"].isUnit(unit)) throw new Error("Invalid ByteString unit: ".concat(unit));
-          _defaultUnit = unit;
-          return this;
-        },
-
-        /**
-         * The ProgressBar Instance
-         * @type {ProgressBar} The ProgresBar
-         */
-        bar: streamGenerator.next().value
-      });
-    }
-  }]);
-
-  return ProgressBar;
-}();
-
-module.exports = ProgressBar;