archiver-node 8.0.3 → 8.0.5

package/cjs/Archiver.js

@@ -1,183 +1,181 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var Archiver_exports = {};
-__export(Archiver_exports, {
-  default: () => Archiver
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(Archiver_exports);
-var import_fs = require("fs");
-var import_is_stream = require("is-stream");
-var import_readdir_glob = __toESM(require("readdir-glob"), 1);
-var import_lazystream = require("./lazystream.js");
-var import_async = require("async");
-var import_path = require("path");
-var import_error = require("./error.js");
-var import_readable_stream = require("readable-stream");
-var import_utils = require("./utils.js");
-const readdirGlob = import_readdir_glob.default || import_readdir_glob.readdirGlob;
-const { ReaddirGlob } = readdirGlob;
-const win32 = process.platform === "win32";
-class Archiver extends import_readable_stream.Transform {
-  _supportsDirectory = false;
-  _supportsSymlink = false;
-  /**
-   * @constructor
-   * @param {String} format The archive format to use.
-   * @param {(CoreOptions|TransformOptions)} options See also {@link ZipOptions} and {@link TarOptions}.
+exports["default"] = void 0;
+var _fs = require("fs");
+var _isStream = require("is-stream");
+var _readdirGlob = _interopRequireDefault(require("readdir-glob"));
+var _lazystream = require("./lazystream.js");
+var _async = require("async");
+var _path = require("path");
+var _error = require("./error.js");
+var _readableStream = require("readable-stream");
+var _utils = require("./utils.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
+function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
+function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
+function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var ReaddirGlob = _readdirGlob["default"].ReaddirGlob;
+var win32 = process.platform === "win32";
+var Archiver = exports["default"] = /*#__PURE__*/function (_Transform) {
+  /**
+   * @constructor
+   * @param {String} format The archive format to use.
+   * @param {(CoreOptions|TransformOptions)} options See also {@link ZipOptions} and {@link TarOptions}.
    */
-  constructor(options) {
-    options = {
+  function Archiver(options) {
+    var _this;
+    _classCallCheck(this, Archiver);
+    options = _objectSpread({
       highWaterMark: 1024 * 1024,
-      statConcurrency: 4,
-      ...options
-    };
-    super(options);
-    this.options = options;
-    this._format = false;
-    this._module = false;
-    this._pending = 0;
-    this._pointer = 0;
-    this._entriesCount = 0;
-    this._entriesProcessedCount = 0;
-    this._fsEntriesTotalBytes = 0;
-    this._fsEntriesProcessedBytes = 0;
-    this._queue = (0, import_async.queue)(this._onQueueTask.bind(this), 1);
-    this._queue.drain(this._onQueueDrain.bind(this));
-    this._statQueue = (0, import_async.queue)(
-      this._onStatQueueTask.bind(this),
-      options.statConcurrency
-    );
-    this._statQueue.drain(this._onQueueDrain.bind(this));
-    this._state = {
+      statConcurrency: 4
+    }, options);
+    _this = _callSuper(this, Archiver, [options]);
+    _defineProperty(_this, "_supportsDirectory", false);
+    _defineProperty(_this, "_supportsSymlink", false);
+    _this.options = options;
+    _this._format = false;
+    _this._module = false;
+    _this._pending = 0;
+    _this._pointer = 0;
+    _this._entriesCount = 0;
+    _this._entriesProcessedCount = 0;
+    _this._fsEntriesTotalBytes = 0;
+    _this._fsEntriesProcessedBytes = 0;
+    _this._queue = (0, _async.queue)(_this._onQueueTask.bind(_this), 1);
+    _this._queue.drain(_this._onQueueDrain.bind(_this));
+    _this._statQueue = (0, _async.queue)(_this._onStatQueueTask.bind(_this), options.statConcurrency);
+    _this._statQueue.drain(_this._onQueueDrain.bind(_this));
+    _this._state = {
       aborted: false,
       finalize: false,
       finalizing: false,
       finalized: false,
       modulePiped: false
     };
-    this._streams = [];
-  }
-  /**
-   * Internal logic for `abort`.
-   *
-   * @private
-   * @return void
-   */
-  _abort() {
-    this._state.aborted = true;
-    this._queue.kill();
-    this._statQueue.kill();
-    if (this._queue.idle()) {
-      this._shutdown();
-    }
+    _this._streams = [];
+    return _this;
   }
-  /**
-   * Internal helper for appending files.
-   *
-   * @private
-   * @param  {String} filepath The source filepath.
-   * @param  {EntryData} data The entry data.
-   * @return void
+
+  /**
+   * Internal logic for `abort`.
+   *
+   * @private
+   * @return void
    */
-  _append(filepath, data) {
-    data = data || {};
-    let task = {
-      source: null,
-      filepath
-    };
-    if (!data.name) {
-      data.name = filepath;
+  _inherits(Archiver, _Transform);
+  return _createClass(Archiver, [{
+    key: "_abort",
+    value: function _abort() {
+      this._state.aborted = true;
+      this._queue.kill();
+      this._statQueue.kill();
+      if (this._queue.idle()) {
+        this._shutdown();
+      }
     }
-    data.sourcePath = filepath;
-    task.data = data;
-    this._entriesCount++;
-    if (data.stats && data.stats instanceof import_fs.Stats) {
-      task = this._updateQueueTaskWithStats(task, data.stats);
-      if (task) {
-        if (data.stats.size) {
-          this._fsEntriesTotalBytes += data.stats.size;
+    /**
+     * Internal helper for appending files.
+     *
+     * @private
+     * @param  {String} filepath The source filepath.
+     * @param  {EntryData} data The entry data.
+     * @return void
+     */
+  }, {
+    key: "_append",
+    value: function _append(filepath, data) {
+      data = data || {};
+      var task = {
+        source: null,
+        filepath: filepath
+      };
+      if (!data.name) {
+        data.name = filepath;
+      }
+      data.sourcePath = filepath;
+      task.data = data;
+      this._entriesCount++;
+      if (data.stats && data.stats instanceof _fs.Stats) {
+        task = this._updateQueueTaskWithStats(task, data.stats);
+        if (task) {
+          if (data.stats.size) {
+            this._fsEntriesTotalBytes += data.stats.size;
+          }
+          this._queue.push(task);
         }
-        this._queue.push(task);
+      } else {
+        this._statQueue.push(task);
       }
-    } else {
-      this._statQueue.push(task);
-    }
-  }
-  /**
-   * Internal logic for `finalize`.
-   *
-   * @private
-   * @return void
-   */
-  _finalize() {
-    if (this._state.finalizing || this._state.finalized || this._state.aborted) {
-      return;
     }
-    this._state.finalizing = true;
-    this._moduleFinalize();
-    this._state.finalizing = false;
-    this._state.finalized = true;
-  }
-  /**
-   * Checks the various state variables to determine if we can `finalize`.
-   *
-   * @private
-   * @return {Boolean}
-   */
-  _maybeFinalize() {
-    if (this._state.finalizing || this._state.finalized || this._state.aborted) {
+    /**
+     * Internal logic for `finalize`.
+     *
+     * @private
+     * @return void
+     */
+  }, {
+    key: "_finalize",
+    value: function _finalize() {
+      if (this._state.finalizing || this._state.finalized || this._state.aborted) {
+        return;
+      }
+      this._state.finalizing = true;
+      this._moduleFinalize();
+      this._state.finalizing = false;
+      this._state.finalized = true;
+    }
+    /**
+     * Checks the various state variables to determine if we can `finalize`.
+     *
+     * @private
+     * @return {Boolean}
+     */
+  }, {
+    key: "_maybeFinalize",
+    value: function _maybeFinalize() {
+      if (this._state.finalizing || this._state.finalized || this._state.aborted) {
+        return false;
+      }
+      if (this._state.finalize && this._pending === 0 && this._queue.idle() && this._statQueue.idle()) {
+        this._finalize();
+        return true;
+      }
       return false;
     }
-    if (this._state.finalize && this._pending === 0 && this._queue.idle() && this._statQueue.idle()) {
-      this._finalize();
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Appends an entry to the module.
-   *
-   * @private
-   * @fires  Archiver#entry
-   * @param  {(Buffer|Stream)} source
-   * @param  {EntryData} data
-   * @param  {Function} callback
-   * @return void
-   */
-  _moduleAppend(source, data, callback) {
-    if (this._state.aborted) {
-      callback();
-      return;
-    }
-    this._module.append(
-      source,
-      data,
-      function(err) {
+    /**
+     * Appends an entry to the module.
+     *
+     * @private
+     * @fires  Archiver#entry
+     * @param  {(Buffer|Stream)} source
+     * @param  {EntryData} data
+     * @param  {Function} callback
+     * @return void
+     */
+  }, {
+    key: "_moduleAppend",
+    value: function _moduleAppend(source, data, callback) {
+      if (this._state.aborted) {
+        callback();
+        return;
+      }
+      this._module.append(source, data, function (err) {
         this._task = null;
         if (this._state.aborted) {
           this._shutdown();
@@ -188,11 +186,21 @@ class Archiver extends import_readable_stream.Transform {
           setImmediate(callback);
           return;
         }
+        /**
+         * Fires when the entry's input has been processed and appended to the archive.
+         *
+         * @event Archiver#entry
+         * @type {EntryData}
+         */
         this.emit("entry", data);
         this._entriesProcessedCount++;
         if (data.stats && data.stats.size) {
           this._fsEntriesProcessedBytes += data.stats.size;
         }
+        /**
+         * @event Archiver#progress
+         * @type {ProgressData}
+         */
         this.emit("progress", {
           entries: {
             total: this._entriesCount,
@@ -204,175 +212,197 @@ class Archiver extends import_readable_stream.Transform {
           }
         });
         setImmediate(callback);
-      }.bind(this)
-    );
-  }
-  /**
-   * Finalizes the module.
-   *
-   * @private
-   * @return void
-   */
-  _moduleFinalize() {
-    if (typeof this._module.finalize === "function") {
-      this._module.finalize();
-    } else if (typeof this._module.end === "function") {
-      this._module.end();
-    } else {
-      this.emit("error", new import_error.ArchiverError("NOENDMETHOD"));
-    }
-  }
-  /**
-   * Pipes the module to our internal stream with error bubbling.
-   *
-   * @private
-   * @return void
-   */
-  _modulePipe() {
-    this._module.on("error", this._onModuleError.bind(this));
-    this._module.pipe(this);
-    this._state.modulePiped = true;
-  }
-  /**
-   * Unpipes the module from our internal stream.
-   *
-   * @private
-   * @return void
-   */
-  _moduleUnpipe() {
-    this._module.unpipe(this);
-    this._state.modulePiped = false;
-  }
-  /**
-   * Normalizes entry data with fallbacks for key properties.
-   *
-   * @private
-   * @param  {Object} data
-   * @param  {fs.Stats} stats
-   * @return {Object}
-   */
-  _normalizeEntryData(data, stats) {
-    data = {
-      type: "file",
-      name: null,
-      date: null,
-      mode: null,
-      prefix: null,
-      sourcePath: null,
-      stats: false,
-      ...data
-    };
-    if (stats && data.stats === false) {
-      data.stats = stats;
-    }
-    let isDir = data.type === "directory";
-    if (data.name) {
-      if (typeof data.prefix === "string" && "" !== data.prefix) {
-        data.name = data.prefix + "/" + data.name;
-        data.prefix = null;
-      }
-      data.name = (0, import_utils.sanitizePath)(data.name);
-      if (data.type !== "symlink" && data.name.slice(-1) === "/") {
-        isDir = true;
-        data.type = "directory";
-      } else if (isDir) {
-        data.name += "/";
+      }.bind(this));
+    }
+    /**
+     * Finalizes the module.
+     *
+     * @private
+     * @return void
+     */
+  }, {
+    key: "_moduleFinalize",
+    value: function _moduleFinalize() {
+      if (typeof this._module.finalize === "function") {
+        this._module.finalize();
+      } else if (typeof this._module.end === "function") {
+        this._module.end();
+      } else {
+        this.emit("error", new _error.ArchiverError("NOENDMETHOD"));
       }
     }
-    if (typeof data.mode === "number") {
-      if (win32) {
-        data.mode &= 511;
-      } else {
-        data.mode &= 4095;
+    /**
+     * Pipes the module to our internal stream with error bubbling.
+     *
+     * @private
+     * @return void
+     */
+  }, {
+    key: "_modulePipe",
+    value: function _modulePipe() {
+      this._module.on("error", this._onModuleError.bind(this));
+      this._module.pipe(this);
+      this._state.modulePiped = true;
+    }
+    /**
+     * Unpipes the module from our internal stream.
+     *
+     * @private
+     * @return void
+     */
+  }, {
+    key: "_moduleUnpipe",
+    value: function _moduleUnpipe() {
+      this._module.unpipe(this);
+      this._state.modulePiped = false;
+    }
+    /**
+     * Normalizes entry data with fallbacks for key properties.
+     *
+     * @private
+     * @param  {Object} data
+     * @param  {fs.Stats} stats
+     * @return {Object}
+     */
+  }, {
+    key: "_normalizeEntryData",
+    value: function _normalizeEntryData(data, stats) {
+      data = _objectSpread({
+        type: "file",
+        name: null,
+        date: null,
+        mode: null,
+        prefix: null,
+        sourcePath: null,
+        stats: false
+      }, data);
+      if (stats && data.stats === false) {
+        data.stats = stats;
       }
-    } else if (data.stats && data.mode === null) {
-      if (win32) {
-        data.mode = data.stats.mode & 511;
-      } else {
-        data.mode = data.stats.mode & 4095;
+      var isDir = data.type === "directory";
+      if (data.name) {
+        if (typeof data.prefix === "string" && "" !== data.prefix) {
+          data.name = data.prefix + "/" + data.name;
+          data.prefix = null;
+        }
+        data.name = (0, _utils.sanitizePath)(data.name);
+        if (data.type !== "symlink" && data.name.slice(-1) === "/") {
+          isDir = true;
+          data.type = "directory";
+        } else if (isDir) {
+          data.name += "/";
+        }
       }
-      if (win32 && isDir) {
-        data.mode = 493;
+      // 511 === 0777; 493 === 0755; 438 === 0666; 420 === 0644
+      if (typeof data.mode === "number") {
+        if (win32) {
+          data.mode &= 511;
+        } else {
+          data.mode &= 4095;
+        }
+      } else if (data.stats && data.mode === null) {
+        if (win32) {
+          data.mode = data.stats.mode & 511;
+        } else {
+          data.mode = data.stats.mode & 4095;
+        }
+        // stat isn't reliable on windows; force 0755 for dir
+        if (win32 && isDir) {
+          data.mode = 493;
+        }
+      } else if (data.mode === null) {
+        data.mode = isDir ? 493 : 420;
       }
-    } else if (data.mode === null) {
-      data.mode = isDir ? 493 : 420;
-    }
-    if (data.stats && data.date === null) {
-      data.date = data.stats.mtime;
-    } else {
-      data.date = (0, import_utils.dateify)(data.date);
-    }
-    return data;
-  }
-  /**
-   * Error listener that re-emits error on to our internal stream.
-   *
-   * @private
-   * @param  {Error} err
-   * @return void
-   */
-  _onModuleError(err) {
-    this.emit("error", err);
-  }
-  /**
-   * Checks the various state variables after queue has drained to determine if
-   * we need to `finalize`.
-   *
-   * @private
-   * @return void
-   */
-  _onQueueDrain() {
-    if (this._state.finalizing || this._state.finalized || this._state.aborted) {
-      return;
-    }
-    if (this._state.finalize && this._pending === 0 && this._queue.idle() && this._statQueue.idle()) {
-      this._finalize();
-    }
-  }
-  /**
-   * Appends each queue task to the module.
-   *
-   * @private
-   * @param  {Object} task
-   * @param  {Function} callback
-   * @return void
-   */
-  _onQueueTask(task, callback) {
-    const fullCallback = () => {
-      if (task.data.callback) {
-        task.data.callback();
+      if (data.stats && data.date === null) {
+        data.date = data.stats.mtime;
+      } else {
+        data.date = (0, _utils.dateify)(data.date);
       }
-      callback();
-    };
-    if (this._state.finalizing || this._state.finalized || this._state.aborted) {
-      fullCallback();
-      return;
+      return data;
+    }
+    /**
+     * Error listener that re-emits error on to our internal stream.
+     *
+     * @private
+     * @param  {Error} err
+     * @return void
+     */
+  }, {
+    key: "_onModuleError",
+    value: function _onModuleError(err) {
+      /**
+       * @event Archiver#error
+       * @type {ErrorData}
+       */
+      this.emit("error", err);
     }
-    this._task = task;
-    this._moduleAppend(task.source, task.data, fullCallback);
-  }
-  /**
-   * Performs a file stat and reinjects the task back into the queue.
-   *
-   * @private
-   * @param  {Object} task
-   * @param  {Function} callback
-   * @return void
-   */
-  _onStatQueueTask(task, callback) {
-    if (this._state.finalizing || this._state.finalized || this._state.aborted) {
-      callback();
-      return;
+    /**
+     * Checks the various state variables after queue has drained to determine if
+     * we need to `finalize`.
+     *
+     * @private
+     * @return void
+     */
+  }, {
+    key: "_onQueueDrain",
+    value: function _onQueueDrain() {
+      if (this._state.finalizing || this._state.finalized || this._state.aborted) {
+        return;
+      }
+      if (this._state.finalize && this._pending === 0 && this._queue.idle() && this._statQueue.idle()) {
+        this._finalize();
+      }
     }
-    (0, import_fs.lstat)(
-      task.filepath,
-      function(err, stats) {
+    /**
+     * Appends each queue task to the module.
+     *
+     * @private
+     * @param  {Object} task
+     * @param  {Function} callback
+     * @return void
+     */
+  }, {
+    key: "_onQueueTask",
+    value: function _onQueueTask(task, callback) {
+      var fullCallback = function fullCallback() {
+        if (task.data.callback) {
+          task.data.callback();
+        }
+        callback();
+      };
+      if (this._state.finalizing || this._state.finalized || this._state.aborted) {
+        fullCallback();
+        return;
+      }
+      this._task = task;
+      this._moduleAppend(task.source, task.data, fullCallback);
+    }
+    /**
+     * Performs a file stat and reinjects the task back into the queue.
+     *
+     * @private
+     * @param  {Object} task
+     * @param  {Function} callback
+     * @return void
+     */
+  }, {
+    key: "_onStatQueueTask",
+    value: function _onStatQueueTask(task, callback) {
+      if (this._state.finalizing || this._state.finalized || this._state.aborted) {
+        callback();
+        return;
+      }
+      (0, _fs.lstat)(task.filepath, function (err, stats) {
         if (this._state.aborted) {
           setImmediate(callback);
           return;
         }
         if (err) {
           this._entriesCount--;
+          /**
+           * @event Archiver#warning
+           * @type {ErrorData}
+           */
           this.emit("warning", err);
           setImmediate(callback);
           return;
@@ -385,382 +415,441 @@ class Archiver extends import_readable_stream.Transform {
           this._queue.push(task);
         }
         setImmediate(callback);
-      }.bind(this)
-    );
-  }
-  /**
-   * Unpipes the module and ends our internal stream.
-   *
-   * @private
-   * @return void
-   */
-  _shutdown() {
-    this._moduleUnpipe();
-    this.end();
-  }
-  /**
-   * Tracks the bytes emitted by our internal stream.
-   *
-   * @private
-   * @param  {Buffer} chunk
-   * @param  {String} encoding
-   * @param  {Function} callback
-   * @return void
-   */
-  _transform(chunk, encoding, callback) {
-    if (chunk) {
-      this._pointer += chunk.length;
-    }
-    callback(null, chunk);
-  }
-  /**
-   * Updates and normalizes a queue task using stats data.
-   *
-   * @private
-   * @param  {Object} task
-   * @param  {Stats} stats
-   * @return {Object}
-   */
-  _updateQueueTaskWithStats(task, stats) {
-    if (stats.isFile()) {
-      task.data.type = "file";
-      task.data.sourceType = "stream";
-      task.source = new import_lazystream.Readable(function() {
-        return (0, import_fs.createReadStream)(task.filepath);
-      });
-    } else if (stats.isDirectory() && this._supportsDirectory) {
-      task.data.name = (0, import_utils.trailingSlashIt)(task.data.name);
-      task.data.type = "directory";
-      task.data.sourcePath = (0, import_utils.trailingSlashIt)(task.filepath);
-      task.data.sourceType = "buffer";
-      task.source = Buffer.concat([]);
-    } else if (stats.isSymbolicLink() && this._supportsSymlink) {
-      const linkPath = (0, import_fs.readlinkSync)(task.filepath);
-      const dirName = (0, import_path.dirname)(task.filepath);
-      task.data.type = "symlink";
-      task.data.linkname = (0, import_path.relative)(
-        dirName,
-        (0, import_path.resolve)(dirName, linkPath)
-      );
-      task.data.sourceType = "buffer";
-      task.source = Buffer.concat([]);
-    } else {
-      if (stats.isDirectory()) {
-        this.emit(
-          "warning",
-          new import_error.ArchiverError("DIRECTORYNOTSUPPORTED", task.data)
-        );
-      } else if (stats.isSymbolicLink()) {
-        this.emit(
-          "warning",
-          new import_error.ArchiverError("SYMLINKNOTSUPPORTED", task.data)
-        );
+      }.bind(this));
+    }
+    /**
+     * Unpipes the module and ends our internal stream.
+     *
+     * @private
+     * @return void
+     */
+  }, {
+    key: "_shutdown",
+    value: function _shutdown() {
+      this._moduleUnpipe();
+      this.end();
+    }
+    /**
+     * Tracks the bytes emitted by our internal stream.
+     *
+     * @private
+     * @param  {Buffer} chunk
+     * @param  {String} encoding
+     * @param  {Function} callback
+     * @return void
+     */
+  }, {
+    key: "_transform",
+    value: function _transform(chunk, encoding, callback) {
+      if (chunk) {
+        this._pointer += chunk.length;
+      }
+      callback(null, chunk);
+    }
+    /**
+     * Updates and normalizes a queue task using stats data.
+     *
+     * @private
+     * @param  {Object} task
+     * @param  {Stats} stats
+     * @return {Object}
+     */
+  }, {
+    key: "_updateQueueTaskWithStats",
+    value: function _updateQueueTaskWithStats(task, stats) {
+      if (stats.isFile()) {
+        task.data.type = "file";
+        task.data.sourceType = "stream";
+        task.source = new _lazystream.Readable(function () {
+          return (0, _fs.createReadStream)(task.filepath);
+        });
+      } else if (stats.isDirectory() && this._supportsDirectory) {
+        task.data.name = (0, _utils.trailingSlashIt)(task.data.name);
+        task.data.type = "directory";
+        task.data.sourcePath = (0, _utils.trailingSlashIt)(task.filepath);
+        task.data.sourceType = "buffer";
+        task.source = Buffer.concat([]);
+      } else if (stats.isSymbolicLink() && this._supportsSymlink) {
+        var linkPath = (0, _fs.readlinkSync)(task.filepath);
+        var dirName = (0, _path.dirname)(task.filepath);
+        task.data.type = "symlink";
+        task.data.linkname = (0, _path.relative)(dirName, (0, _path.resolve)(dirName, linkPath));
+        task.data.sourceType = "buffer";
+        task.source = Buffer.concat([]);
       } else {
-        this.emit("warning", new import_error.ArchiverError("ENTRYNOTSUPPORTED", task.data));
+        if (stats.isDirectory()) {
+          this.emit("warning", new _error.ArchiverError("DIRECTORYNOTSUPPORTED", task.data));
+        } else if (stats.isSymbolicLink()) {
+          this.emit("warning", new _error.ArchiverError("SYMLINKNOTSUPPORTED", task.data));
+        } else {
+          this.emit("warning", new _error.ArchiverError("ENTRYNOTSUPPORTED", task.data));
+        }
+        return null;
       }
-      return null;
-    }
-    task.data = this._normalizeEntryData(task.data, stats);
-    return task;
-  }
-  /**
-   * Aborts the archiving process, taking a best-effort approach, by:
-   *
-   * - removing any pending queue tasks
-   * - allowing any active queue workers to finish
-   * - detaching internal module pipes
-   * - ending both sides of the Transform stream
-   *
-   * It will NOT drain any remaining sources.
-   *
-   * @return {this}
-   */
-  abort() {
-    if (this._state.aborted || this._state.finalized) {
-      return this;
-    }
-    this._abort();
-    return this;
-  }
-  /**
-   * Appends an input source (text string, buffer, or stream) to the instance.
-   *
-   * When the instance has received, processed, and emitted the input, the `entry`
-   * event is fired.
-   *
-   * @fires  Archiver#entry
-   * @param  {(Buffer|Stream|String)} source The input source.
-   * @param  {EntryData} data See also {@link ZipEntryData} and {@link TarEntryData}.
-   * @return {this}
-   */
-  append(source, data) {
-    if (this._state.finalize || this._state.aborted) {
-      this.emit("error", new import_error.ArchiverError("QUEUECLOSED"));
-      return this;
-    }
-    data = this._normalizeEntryData(data);
-    if (typeof data.name !== "string" || data.name.length === 0) {
-      this.emit("error", new import_error.ArchiverError("ENTRYNAMEREQUIRED"));
-      return this;
-    }
-    if (data.type === "directory" && !this._supportsDirectory) {
-      this.emit(
-        "error",
-        new import_error.ArchiverError("DIRECTORYNOTSUPPORTED", { name: data.name })
-      );
-      return this;
-    }
-    source = (0, import_utils.normalizeInputSource)(source);
-    if (Buffer.isBuffer(source)) {
-      data.sourceType = "buffer";
-    } else if ((0, import_is_stream.isStream)(source)) {
-      data.sourceType = "stream";
-    } else {
-      this.emit(
-        "error",
-        new import_error.ArchiverError("INPUTSTEAMBUFFERREQUIRED", { name: data.name })
-      );
-      return this;
-    }
-    this._entriesCount++;
-    this._queue.push({
-      data,
-      source
-    });
-    return this;
-  }
-  /**
-   * Appends a directory and its files, recursively, given its dirpath.
-   *
-   * @param  {String} dirpath The source directory path.
-   * @param  {String} destpath The destination path within the archive.
-   * @param  {(EntryData|Function)} data See also [ZipEntryData]{@link ZipEntryData} and
-   * [TarEntryData]{@link TarEntryData}.
-   * @return {this}
-   */
-  directory(dirpath, destpath, data) {
-    if (this._state.finalize || this._state.aborted) {
-      this.emit("error", new import_error.ArchiverError("QUEUECLOSED"));
+      task.data = this._normalizeEntryData(task.data, stats);
+      return task;
+    }
+    /**
+     * Aborts the archiving process, taking a best-effort approach, by:
+     *
+     * - removing any pending queue tasks
+     * - allowing any active queue workers to finish
+     * - detaching internal module pipes
+     * - ending both sides of the Transform stream
+     *
+     * It will NOT drain any remaining sources.
+     *
+     * @return {this}
+     */
+  }, {
+    key: "abort",
+    value: function abort() {
+      if (this._state.aborted || this._state.finalized) {
+        return this;
+      }
+      this._abort();
       return this;
     }
-    if (typeof dirpath !== "string" || dirpath.length === 0) {
-      this.emit("error", new import_error.ArchiverError("DIRECTORYDIRPATHREQUIRED"));
+    /**
+     * Appends an input source (text string, buffer, or stream) to the instance.
+     *
+     * When the instance has received, processed, and emitted the input, the `entry`
+     * event is fired.
+     *
+     * @fires  Archiver#entry
+     * @param  {(Buffer|Stream|String)} source The input source.
+     * @param  {EntryData} data See also {@link ZipEntryData} and {@link TarEntryData}.
+     * @return {this}
+     */
+  }, {
+    key: "append",
+    value: function append(source, data) {
+      if (this._state.finalize || this._state.aborted) {
+        this.emit("error", new _error.ArchiverError("QUEUECLOSED"));
+        return this;
+      }
+      data = this._normalizeEntryData(data);
+      if (typeof data.name !== "string" || data.name.length === 0) {
+        this.emit("error", new _error.ArchiverError("ENTRYNAMEREQUIRED"));
+        return this;
+      }
+      if (data.type === "directory" && !this._supportsDirectory) {
+        this.emit("error", new _error.ArchiverError("DIRECTORYNOTSUPPORTED", {
+          name: data.name
+        }));
+        return this;
+      }
+      source = (0, _utils.normalizeInputSource)(source);
+      if (Buffer.isBuffer(source)) {
+        data.sourceType = "buffer";
+      } else if ((0, _isStream.isStream)(source)) {
+        data.sourceType = "stream";
+      } else {
+        this.emit("error", new _error.ArchiverError("INPUTSTEAMBUFFERREQUIRED", {
+          name: data.name
+        }));
+        return this;
+      }
+      this._entriesCount++;
+      this._queue.push({
+        data: data,
+        source: source
+      });
       return this;
     }
-    this._pending++;
-    if (destpath === false) {
-      destpath = "";
-    } else if (typeof destpath !== "string") {
-      destpath = dirpath;
-    }
-    var dataFunction = false;
-    if (typeof data === "function") {
-      dataFunction = data;
-      data = {};
-    } else if (typeof data !== "object") {
-      data = {};
-    }
-    var globOptions = {
-      stat: true,
-      dot: true
-    };
-    function onGlobEnd() {
-      this._pending--;
-      this._maybeFinalize();
-    }
-    function onGlobError(err) {
-      this.emit("error", err);
-    }
-    function onGlobMatch(match) {
-      globber.pause();
-      let ignoreMatch = false;
-      let entryData = Object.assign({}, data);
-      entryData.name = match.relative;
-      entryData.prefix = destpath;
-      entryData.stats = match.stat;
-      entryData.callback = globber.resume.bind(globber);
-      try {
-        if (dataFunction) {
-          entryData = dataFunction(entryData);
-          if (entryData === false) {
-            ignoreMatch = true;
-          } else if (typeof entryData !== "object") {
-            throw new import_error.ArchiverError("DIRECTORYFUNCTIONINVALIDDATA", {
-              dirpath
-            });
+    /**
+     * Appends a directory and its files, recursively, given its dirpath.
+     *
+     * @param  {String} dirpath The source directory path.
+     * @param  {String} destpath The destination path within the archive.
+     * @param  {(EntryData|Function)} data See also [ZipEntryData]{@link ZipEntryData} and
+     * [TarEntryData]{@link TarEntryData}.
+     * @return {this}
+     */
+  }, {
+    key: "directory",
+    value: function directory(dirpath, destpath, data) {
+      if (this._state.finalize || this._state.aborted) {
+        this.emit("error", new _error.ArchiverError("QUEUECLOSED"));
+        return this;
+      }
+      if (typeof dirpath !== "string" || dirpath.length === 0) {
+        this.emit("error", new _error.ArchiverError("DIRECTORYDIRPATHREQUIRED"));
+        return this;
+      }
+      this._pending++;
+      if (destpath === false) {
+        destpath = "";
+      } else if (typeof destpath !== "string") {
+        destpath = dirpath;
+      }
+      var dataFunction = false;
+      if (typeof data === "function") {
+        dataFunction = data;
+        data = {};
+      } else if (_typeof(data) !== "object") {
+        data = {};
+      }
+      var globOptions = {
+        stat: true,
+        dot: true
+      };
+      function onGlobEnd() {
+        this._pending--;
+        this._maybeFinalize();
+      }
+      function onGlobError(err) {
+        this.emit("error", err);
+      }
+      function onGlobMatch(match) {
+        globber.pause();
+        var ignoreMatch = false;
+        var entryData = Object.assign({}, data);
+        entryData.name = match.relative;
+        entryData.prefix = destpath;
+        entryData.stats = match.stat;
+        entryData.callback = globber.resume.bind(globber);
+        try {
+          if (dataFunction) {
+            entryData = dataFunction(entryData);
+            if (entryData === false) {
+              ignoreMatch = true;
+            } else if (_typeof(entryData) !== "object") {
+              throw new _error.ArchiverError("DIRECTORYFUNCTIONINVALIDDATA", {
+                dirpath: dirpath
+              });
+            }
           }
+        } catch (e) {
+          this.emit("error", e);
+          return;
         }
-      } catch (e) {
-        this.emit("error", e);
-        return;
-      }
-      if (ignoreMatch) {
-        globber.resume();
-        return;
+        if (ignoreMatch) {
+          globber.resume();
+          return;
+        }
+        this._append(match.absolute, entryData);
       }
-      this._append(match.absolute, entryData);
-    }
-    const globber = readdirGlob(dirpath, globOptions);
-    globber.on("error", onGlobError.bind(this));
-    globber.on("match", onGlobMatch.bind(this));
-    globber.on("end", onGlobEnd.bind(this));
-    return this;
-  }
-  /**
-   * Appends a file given its filepath using a
-   * [lazystream]{@link https://github.com/jpommerening/node-lazystream} wrapper to
-   * prevent issues with open file limits.
-   *
-   * When the instance has received, processed, and emitted the file, the `entry`
-   * event is fired.
-   *
-   * @param  {String} filepath The source filepath.
-   * @param  {EntryData} data See also [ZipEntryData]{@link ZipEntryData} and
-   * [TarEntryData]{@link TarEntryData}.
-   * @return {this}
-   */
-  file(filepath, data) {
-    if (this._state.finalize || this._state.aborted) {
-      this.emit("error", new import_error.ArchiverError("QUEUECLOSED"));
-      return this;
-    }
-    if (typeof filepath !== "string" || filepath.length === 0) {
-      this.emit("error", new import_error.ArchiverError("FILEFILEPATHREQUIRED"));
+      var globber = (0, _readdirGlob["default"])(dirpath, globOptions);
+      globber.on("error", onGlobError.bind(this));
+      globber.on("match", onGlobMatch.bind(this));
+      globber.on("end", onGlobEnd.bind(this));
       return this;
     }
-    this._append(filepath, data);
-    return this;
-  }
-  /**
-   * Appends multiple files that match a glob pattern.
-   *
-   * @param  {String} pattern The [glob pattern]{@link https://github.com/isaacs/minimatch} to match.
-   * @param  {Object} options See [node-readdir-glob]{@link https://github.com/yqnn/node-readdir-glob#options}.
-   * @param  {EntryData} data See also [ZipEntryData]{@link ZipEntryData} and
-   * [TarEntryData]{@link TarEntryData}.
-   * @return {this}
-   */
-  glob(pattern, options, data) {
-    this._pending++;
-    options = {
-      stat: true,
-      pattern,
-      ...options
-    };
-    function onGlobEnd() {
-      this._pending--;
-      this._maybeFinalize();
-    }
-    function onGlobError(err) {
-      this.emit("error", err);
-    }
-    function onGlobMatch(match) {
-      globber.pause();
-      const entryData = Object.assign({}, data);
-      entryData.callback = globber.resume.bind(globber);
-      entryData.stats = match.stat;
-      entryData.name = match.relative;
-      this._append(match.absolute, entryData);
-    }
-    const globber = new ReaddirGlob(options.cwd || ".", options);
-    globber.on("error", onGlobError.bind(this));
-    globber.on("match", onGlobMatch.bind(this));
-    globber.on("end", onGlobEnd.bind(this));
-    return this;
-  }
-  /**
-   * Finalizes the instance and prevents further appending to the archive
-   * structure (queue will continue til drained).
-   *
-   * The `end`, `close` or `finish` events on the destination stream may fire
-   * right after calling this method so you should set listeners beforehand to
-   * properly detect stream completion.
-   *
-   * @return {Promise}
-   */
-  finalize() {
-    if (this._state.aborted) {
-      var abortedError = new import_error.ArchiverError("ABORTED");
-      this.emit("error", abortedError);
-      return Promise.reject(abortedError);
-    }
-    if (this._state.finalize) {
-      var finalizingError = new import_error.ArchiverError("FINALIZING");
-      this.emit("error", finalizingError);
-      return Promise.reject(finalizingError);
-    }
-    this._state.finalize = true;
-    if (this._pending === 0 && this._queue.idle() && this._statQueue.idle()) {
-      this._finalize();
-    }
-    var self = this;
-    return new Promise(function(resolve, reject) {
-      var errored;
-      self._module.on("end", function() {
-        if (!errored) {
-          resolve();
-        }
-      });
-      self._module.on("error", function(err) {
-        errored = true;
-        reject(err);
-      });
-    });
-  }
-  /**
-   * Appends a symlink to the instance.
-   *
-   * This does NOT interact with filesystem and is used for programmatically creating symlinks.
-   *
-   * @param  {String} filepath The symlink path (within archive).
-   * @param  {String} target The target path (within archive).
-   * @param  {Number} mode Sets the entry permissions.
-   * @return {this}
-   */
-  symlink(filepath, target, mode) {
-    if (this._state.finalize || this._state.aborted) {
-      this.emit("error", new import_error.ArchiverError("QUEUECLOSED"));
+    /**
+     * Appends a file given its filepath using a
+     * [lazystream]{@link https://github.com/jpommerening/node-lazystream} wrapper to
+     * prevent issues with open file limits.
+     *
+     * When the instance has received, processed, and emitted the file, the `entry`
+     * event is fired.
+     *
+     * @param  {String} filepath The source filepath.
+     * @param  {EntryData} data See also [ZipEntryData]{@link ZipEntryData} and
+     * [TarEntryData]{@link TarEntryData}.
+     * @return {this}
+     */
+  }, {
+    key: "file",
+    value: function file(filepath, data) {
+      if (this._state.finalize || this._state.aborted) {
+        this.emit("error", new _error.ArchiverError("QUEUECLOSED"));
+        return this;
+      }
+      if (typeof filepath !== "string" || filepath.length === 0) {
+        this.emit("error", new _error.ArchiverError("FILEFILEPATHREQUIRED"));
+        return this;
+      }
+      this._append(filepath, data);
       return this;
     }
-    if (typeof filepath !== "string" || filepath.length === 0) {
-      this.emit("error", new import_error.ArchiverError("SYMLINKFILEPATHREQUIRED"));
+    /**
+     * Appends multiple files that match a glob pattern.
+     *
+     * @param  {String} pattern The [glob pattern]{@link https://github.com/isaacs/minimatch} to match.
+     * @param  {Object} options See [node-readdir-glob]{@link https://github.com/yqnn/node-readdir-glob#options}.
+     * @param  {EntryData} data See also [ZipEntryData]{@link ZipEntryData} and
+     * [TarEntryData]{@link TarEntryData}.
+     * @return {this}
+     */
+  }, {
+    key: "glob",
+    value: function glob(pattern, options, data) {
+      this._pending++;
+      options = _objectSpread({
+        stat: true,
+        pattern: pattern
+      }, options);
+      function onGlobEnd() {
+        this._pending--;
+        this._maybeFinalize();
+      }
+      function onGlobError(err) {
+        this.emit("error", err);
+      }
+      function onGlobMatch(match) {
+        globber.pause();
+        var entryData = Object.assign({}, data);
+        entryData.callback = globber.resume.bind(globber);
+        entryData.stats = match.stat;
+        entryData.name = match.relative;
+        this._append(match.absolute, entryData);
+      }
+      var globber = new ReaddirGlob(options.cwd || ".", options);
+      globber.on("error", onGlobError.bind(this));
+      globber.on("match", onGlobMatch.bind(this));
+      globber.on("end", onGlobEnd.bind(this));
       return this;
     }
-    if (typeof target !== "string" || target.length === 0) {
-      this.emit(
-        "error",
-        new import_error.ArchiverError("SYMLINKTARGETREQUIRED", { filepath })
-      );
-      return this;
+    /**
+     * Finalizes the instance and prevents further appending to the archive
+     * structure (queue will continue til drained).
+     *
+     * The `end`, `close` or `finish` events on the destination stream may fire
+     * right after calling this method so you should set listeners beforehand to
+     * properly detect stream completion.
+     *
+     * @return {Promise}
+     */
+  }, {
+    key: "finalize",
+    value: function finalize() {
+      if (this._state.aborted) {
+        var abortedError = new _error.ArchiverError("ABORTED");
+        this.emit("error", abortedError);
+        return Promise.reject(abortedError);
+      }
+      if (this._state.finalize) {
+        var finalizingError = new _error.ArchiverError("FINALIZING");
+        this.emit("error", finalizingError);
+        return Promise.reject(finalizingError);
+      }
+      this._state.finalize = true;
+      if (this._pending === 0 && this._queue.idle() && this._statQueue.idle()) {
+        this._finalize();
+      }
+      var self = this;
+      return new Promise(function (resolve, reject) {
+        var errored;
+        self._module.on("end", function () {
+          if (!errored) {
+            resolve();
+          }
+        });
+        self._module.on("error", function (err) {
+          errored = true;
+          reject(err);
+        });
+      });
     }
-    if (!this._supportsSymlink) {
-      this.emit(
-        "error",
-        new import_error.ArchiverError("SYMLINKNOTSUPPORTED", { filepath })
-      );
+    /**
+     * Appends a symlink to the instance.
+     *
+     * This does NOT interact with filesystem and is used for programmatically creating symlinks.
+     *
+     * @param  {String} filepath The symlink path (within archive).
+     * @param  {String} target The target path (within archive).
+     * @param  {Number} mode Sets the entry permissions.
+     * @return {this}
+     */
+  }, {
+    key: "symlink",
+    value: function symlink(filepath, target, mode) {
+      if (this._state.finalize || this._state.aborted) {
+        this.emit("error", new _error.ArchiverError("QUEUECLOSED"));
+        return this;
+      }
+      if (typeof filepath !== "string" || filepath.length === 0) {
+        this.emit("error", new _error.ArchiverError("SYMLINKFILEPATHREQUIRED"));
+        return this;
+      }
+      if (typeof target !== "string" || target.length === 0) {
+        this.emit("error", new _error.ArchiverError("SYMLINKTARGETREQUIRED", {
+          filepath: filepath
+        }));
+        return this;
+      }
+      if (!this._supportsSymlink) {
+        this.emit("error", new _error.ArchiverError("SYMLINKNOTSUPPORTED", {
+          filepath: filepath
+        }));
+        return this;
+      }
+      var data = {};
+      data.type = "symlink";
+      data.name = filepath.replace(/\\/g, "/");
+      data.linkname = target.replace(/\\/g, "/");
+      data.sourceType = "buffer";
+      if (typeof mode === "number") {
+        data.mode = mode;
+      }
+      this._entriesCount++;
+      this._queue.push({
+        data: data,
+        source: Buffer.concat([])
+      });
       return this;
     }
-    var data = {};
-    data.type = "symlink";
-    data.name = filepath.replace(/\\/g, "/");
-    data.linkname = target.replace(/\\/g, "/");
-    data.sourceType = "buffer";
-    if (typeof mode === "number") {
-      data.mode = mode;
-    }
-    this._entriesCount++;
-    this._queue.push({
-      data,
-      source: Buffer.concat([])
-    });
-    return this;
-  }
-  /**
-   * Returns the current length (in bytes) that has been emitted.
-   *
-   * @return {Number}
-   */
-  pointer() {
-    return this._pointer;
-  }
-}
+    /**
+     * Returns the current length (in bytes) that has been emitted.
+     *
+     * @return {Number}
+     */
+  }, {
+    key: "pointer",
+    value: function pointer() {
+      return this._pointer;
+    }
+  }]);
+}(_readableStream.Transform);
+/**
+ * @typedef {Object} CoreOptions
+ * @global
+ * @property {Number} [statConcurrency=4] Sets the number of workers used to
+ * process the internal fs stat queue.
+ */
+/**
+ * @typedef {Object} TransformOptions
+ * @property {Boolean} [allowHalfOpen=true] If set to false, then the stream
+ * will automatically end the readable side when the writable side ends and vice
+ * versa.
+ * @property {Boolean} [readableObjectMode=false] Sets objectMode for readable
+ * side of the stream. Has no effect if objectMode is true.
+ * @property {Boolean} [writableObjectMode=false] Sets objectMode for writable
+ * side of the stream. Has no effect if objectMode is true.
+ * @property {Boolean} [decodeStrings=true] Whether or not to decode strings
+ * into Buffers before passing them to _write(). `Writable`
+ * @property {String} [encoding=NULL] If specified, then buffers will be decoded
+ * to strings using the specified encoding. `Readable`
+ * @property {Number} [highWaterMark=16kb] The maximum number of bytes to store
+ * in the internal buffer before ceasing to read from the underlying resource.
+ * `Readable` `Writable`
+ * @property {Boolean} [objectMode=false] Whether this stream should behave as a
+ * stream of objects. Meaning that stream.read(n) returns a single value instead
+ * of a Buffer of size n. `Readable` `Writable`
+ */
+/**
+ * @typedef {Object} EntryData
+ * @property {String} name Sets the entry name including internal path.
+ * @property {(String|Date)} [date=NOW()] Sets the entry date.
+ * @property {Number} [mode=D:0755/F:0644] Sets the entry permissions.
+ * @property {String} [prefix] Sets a path prefix for the entry name. Useful
+ * when working with methods like `directory` or `glob`.
+ * @property {fs.Stats} [stats] Sets the fs stat data for this entry allowing
+ * for reduction of fs stat calls when stat data is already known.
+ */
+/**
+ * @typedef {Object} ErrorData
+ * @property {String} message The message of the error.
+ * @property {String} code The error code assigned to this error.
+ * @property {String} data Additional data provided for reporting or debugging (where available).
+ */
+/**
+ * @typedef {Object} ProgressData
+ * @property {Object} entries
+ * @property {Number} entries.total Number of entries that have been appended.
+ * @property {Number} entries.processed Number of entries that have been processed.
+ * @property {Object} fs
+ * @property {Number} fs.totalBytes Number of bytes that have been appended. Calculated asynchronously and might not be accurate: it growth while entries are added. (based on fs.Stats)
+ * @property {Number} fs.processedBytes Number of bytes that have been processed. (based on fs.Stats)
+ */