archiver-node 8.0.0 → 8.0.2

package/cjs/archivers/JsonArchive.js

@@ -0,0 +1,44 @@
+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 JsonArchive_exports = {};
+__export(JsonArchive_exports, {
+  default: () => JsonArchive
+});
+module.exports = __toCommonJS(JsonArchive_exports);
+var import_Archiver = __toESM(require("../Archiver.js"), 1);
+var import_json = __toESM(require("../plugins/json.js"), 1);
+class JsonArchive extends import_Archiver.default {
+  constructor(options) {
+    super(options);
+    this._format = "json";
+    this._module = new import_json.default(options);
+    this._supportsDirectory = true;
+    this._supportsSymlink = true;
+    this._modulePipe();
+  }
+}

package/cjs/archivers/TarArchive.js

@@ -0,0 +1,44 @@
+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 TarArchive_exports = {};
+__export(TarArchive_exports, {
+  default: () => TarArchive
+});
+module.exports = __toCommonJS(TarArchive_exports);
+var import_Archiver = __toESM(require("../Archiver.js"), 1);
+var import_tar = __toESM(require("../plugins/tar.js"), 1);
+class TarArchive extends import_Archiver.default {
+  constructor(options) {
+    super(options);
+    this._format = "tar";
+    this._module = new import_tar.default(options);
+    this._supportsDirectory = true;
+    this._supportsSymlink = true;
+    this._modulePipe();
+  }
+}

package/cjs/archivers/ZipArchive.js

@@ -0,0 +1,44 @@
+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 ZipArchive_exports = {};
+__export(ZipArchive_exports, {
+  default: () => ZipArchive
+});
+module.exports = __toCommonJS(ZipArchive_exports);
+var import_Archiver = __toESM(require("../Archiver.js"), 1);
+var import_zip = __toESM(require("../plugins/zip.js"), 1);
+class ZipArchive extends import_Archiver.default {
+  constructor(options) {
+    super(options);
+    this._format = "zip";
+    this._module = new import_zip.default(options);
+    this._supportsDirectory = true;
+    this._supportsSymlink = true;
+    this._modulePipe();
+  }
+}

package/cjs/error.js

@@ -0,0 +1,62 @@
+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 error_exports = {};
+__export(error_exports, {
+  ArchiverError: () => ArchiverError
+});
+module.exports = __toCommonJS(error_exports);
+var import_util = __toESM(require("util"), 1);
+const ERROR_CODES = {
+  ABORTED: "archive was aborted",
+  DIRECTORYDIRPATHREQUIRED: "diretory dirpath argument must be a non-empty string value",
+  DIRECTORYFUNCTIONINVALIDDATA: "invalid data returned by directory custom data function",
+  ENTRYNAMEREQUIRED: "entry name must be a non-empty string value",
+  FILEFILEPATHREQUIRED: "file filepath argument must be a non-empty string value",
+  FINALIZING: "archive already finalizing",
+  QUEUECLOSED: "queue closed",
+  NOENDMETHOD: "no suitable finalize/end method defined by module",
+  DIRECTORYNOTSUPPORTED: "support for directory entries not defined by module",
+  FORMATSET: "archive format already set",
+  INPUTSTEAMBUFFERREQUIRED: "input source must be valid Stream or Buffer instance",
+  MODULESET: "module already set",
+  SYMLINKNOTSUPPORTED: "support for symlink entries not defined by module",
+  SYMLINKFILEPATHREQUIRED: "symlink filepath argument must be a non-empty string value",
+  SYMLINKTARGETREQUIRED: "symlink target argument must be a non-empty string value",
+  ENTRYNOTSUPPORTED: "entry not supported"
+};
+function ArchiverError(code, data) {
+  Error.captureStackTrace(this, this.constructor);
+  this.message = ERROR_CODES[code] || code;
+  this.code = code;
+  this.data = data;
+}
+import_util.default.inherits(ArchiverError, Error);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArchiverError
+});

package/cjs/lazystream.js

@@ -0,0 +1,66 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lazystream_exports = {};
+__export(lazystream_exports, {
+  Readable: () => Readable,
+  Writable: () => Writable
+});
+module.exports = __toCommonJS(lazystream_exports);
+var import_stream = require("stream");
+function beforeFirstCall(instance, method, callback) {
+  instance[method] = function(...args) {
+    delete instance[method];
+    callback.apply(this, args);
+    return this[method].apply(this, args);
+  };
+}
+class Readable extends import_stream.PassThrough {
+  constructor(fn, options) {
+    super(options);
+    if (!(this instanceof Readable)) {
+      return new Readable(fn, options);
+    }
+    beforeFirstCall(this, "_read", function() {
+      const source = fn.call(this, options);
+      const emit = this.emit.bind(this, "error");
+      source.on("error", emit);
+      source.pipe(this);
+    });
+    this.emit("readable");
+  }
+}
+class Writable extends import_stream.PassThrough {
+  constructor(fn, options) {
+    super(options);
+    if (!(this instanceof Writable)) {
+      return new Writable(fn, options);
+    }
+    beforeFirstCall(this, "_write", function() {
+      const destination = fn.call(this, options);
+      const emit = this.emit.bind(this, "error");
+      destination.on("error", emit);
+      this.pipe(destination);
+    });
+    this.emit("writable");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Readable,
+  Writable
+});

package/cjs/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "archiver-node/cjs",
+  "type": "commonjs",
+  "private": true
+}

package/cjs/plugins/json.js

@@ -0,0 +1,110 @@
+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 json_exports = {};
+__export(json_exports, {
+  default: () => Json
+});
+module.exports = __toCommonJS(json_exports);
+var import_readable_stream = require("readable-stream");
+var import_buffer_crc32 = __toESM(require("buffer-crc32"), 1);
+var import_utils = require("../utils.js");
+/**
+ * JSON Format Plugin
+ *
+ * @module plugins/json
+ * @license [MIT]{@link https://github.com/archiverjs/node-archiver/blob/master/LICENSE}
+ * @copyright (c) 2012-2014 Chris Talkington, contributors.
+ */
+class Json extends import_readable_stream.Transform {
+  /**
+   * @constructor
+   * @param {(JsonOptions|TransformOptions)} options
+   */
+  constructor(options) {
+    super({ ...options });
+    this.files = [];
+  }
+  /**
+   * [_transform description]
+   *
+   * @private
+   * @param  {Buffer}   chunk
+   * @param  {String}   encoding
+   * @param  {Function} callback
+   * @return void
+   */
+  _transform(chunk, encoding, callback) {
+    callback(null, chunk);
+  }
+  /**
+   * [_writeStringified description]
+   *
+   * @private
+   * @return void
+   */
+  _writeStringified() {
+    var fileString = JSON.stringify(this.files);
+    this.write(fileString);
+  }
+  /**
+   * [append description]
+   *
+   * @param  {(Buffer|Stream)}   source
+   * @param  {EntryData}   data
+   * @param  {Function} callback
+   * @return void
+   */
+  append(source, data, callback) {
+    var self = this;
+    data.crc32 = 0;
+    function onend(err, sourceBuffer) {
+      if (err) {
+        callback(err);
+        return;
+      }
+      data.size = sourceBuffer.length || 0;
+      data.crc32 = import_buffer_crc32.default.unsigned(sourceBuffer);
+      self.files.push(data);
+      callback(null, data);
+    }
+    if (data.sourceType === "buffer") {
+      onend(null, source);
+    } else if (data.sourceType === "stream") {
+      (0, import_utils.collectStream)(source, onend);
+    }
+  }
+  /**
+   * [finalize description]
+   *
+   * @return void
+   */
+  finalize() {
+    this._writeStringified();
+    this.end();
+  }
+}

package/cjs/plugins/tar.js

@@ -0,0 +1,147 @@
+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 tar_exports = {};
+__export(tar_exports, {
+  default: () => Tar
+});
+module.exports = __toCommonJS(tar_exports);
+var import_zlib = __toESM(require("zlib"), 1);
+var import_tar_stream = __toESM(require("tar-stream"), 1);
+var import_utils = require("../utils.js");
+/**
+ * TAR Format Plugin
+ *
+ * @module plugins/tar
+ * @license [MIT]{@link https://github.com/archiverjs/node-archiver/blob/master/LICENSE}
+ * @copyright (c) 2012-2014 Chris Talkington, contributors.
+ */
+class Tar {
+  /**
+   * @constructor
+   * @param {TarOptions} options
+   */
+  constructor(options) {
+    options = this.options = {
+      gzip: false,
+      ...options
+    };
+    if (typeof options.gzipOptions !== "object") {
+      options.gzipOptions = {};
+    }
+    this.engine = import_tar_stream.default.pack(options);
+    this.compressor = false;
+    if (options.gzip) {
+      this.compressor = import_zlib.default.createGzip(options.gzipOptions);
+      this.compressor.on("error", this._onCompressorError.bind(this));
+    }
+  }
+  /**
+   * [_onCompressorError description]
+   *
+   * @private
+   * @param  {Error} err
+   * @return void
+   */
+  _onCompressorError(err) {
+    this.engine.emit("error", err);
+  }
+  /**
+   * [append description]
+   *
+   * @param  {(Buffer|Stream)} source
+   * @param  {TarEntryData} data
+   * @param  {Function} callback
+   * @return void
+   */
+  append(source, data, callback) {
+    var self = this;
+    data.mtime = data.date;
+    function append(err, sourceBuffer) {
+      if (err) {
+        callback(err);
+        return;
+      }
+      self.engine.entry(data, sourceBuffer, function(err2) {
+        callback(err2, data);
+      });
+    }
+    if (data.sourceType === "buffer") {
+      append(null, source);
+    } else if (data.sourceType === "stream" && data.stats) {
+      data.size = data.stats.size;
+      var entry = self.engine.entry(data, function(err) {
+        callback(err, data);
+      });
+      source.pipe(entry);
+    } else if (data.sourceType === "stream") {
+      (0, import_utils.collectStream)(source, append);
+    }
+  }
+  /**
+   * [finalize description]
+   *
+   * @return void
+   */
+  finalize() {
+    this.engine.finalize();
+  }
+  /**
+   * [on description]
+   *
+   * @return this.engine
+   */
+  on() {
+    return this.engine.on.apply(this.engine, arguments);
+  }
+  /**
+   * [pipe description]
+   *
+   * @param  {String} destination
+   * @param  {Object} options
+   * @return this.engine
+   */
+  pipe(destination, options) {
+    if (this.compressor) {
+      return this.engine.pipe.apply(this.engine, [this.compressor]).pipe(destination, options);
+    } else {
+      return this.engine.pipe.apply(this.engine, arguments);
+    }
+  }
+  /**
+   * [unpipe description]
+   *
+   * @return this.engine
+   */
+  unpipe() {
+    if (this.compressor) {
+      return this.compressor.unpipe.apply(this.compressor, arguments);
+    } else {
+      return this.engine.unpipe.apply(this.engine, arguments);
+    }
+  }
+}

package/cjs/plugins/zip.js

@@ -0,0 +1,103 @@
+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 zip_exports = {};
+__export(zip_exports, {
+  default: () => Zip
+});
+module.exports = __toCommonJS(zip_exports);
+var import_zip_stream = __toESM(require("zip-stream"), 1);
+/**
+ * ZIP Format Plugin
+ *
+ * @module plugins/zip
+ * @license [MIT]{@link https://github.com/archiverjs/node-archiver/blob/master/LICENSE}
+ * @copyright (c) 2012-2014 Chris Talkington, contributors.
+ */
+class Zip {
+  /**
+   * @constructor
+   * @param {ZipOptions} [options]
+   * @param {String} [options.comment] Sets the zip archive comment.
+   * @param {Boolean} [options.forceLocalTime=false] Forces the archive to contain local file times instead of UTC.
+   * @param {Boolean} [options.forceZip64=false] Forces the archive to contain ZIP64 headers.
+   * @param {Boolean} [options.namePrependSlash=false] Prepends a forward slash to archive file paths.
+   * @param {Boolean} [options.store=false] Sets the compression method to STORE.
+   * @param {Object} [options.zlib] Passed to [zlib]{@link https://nodejs.org/api/zlib.html#zlib_class_options}
+   */
+  constructor(options) {
+    options = this.options = {
+      comment: "",
+      forceUTC: false,
+      namePrependSlash: false,
+      store: false,
+      ...options
+    };
+    this.engine = new import_zip_stream.default(options);
+  }
+  /**
+   * @param  {(Buffer|Stream)} source
+   * @param  {ZipEntryData} data
+   * @param  {String} data.name Sets the entry name including internal path.
+   * @param  {(String|Date)} [data.date=NOW()] Sets the entry date.
+   * @param  {Number} [data.mode=D:0755/F:0644] Sets the entry permissions.
+   * @param  {String} [data.prefix] Sets a path prefix for the entry name. Useful
+   * when working with methods like `directory` or `glob`.
+   * @param  {fs.Stats} [data.stats] Sets the fs stat data for this entry allowing
+   * for reduction of fs stat calls when stat data is already known.
+   * @param  {Boolean} [data.store=ZipOptions.store] Sets the compression method to STORE.
+   * @param  {Function} callback
+   * @return void
+   */
+  append(source, data, callback) {
+    this.engine.entry(source, data, callback);
+  }
+  /**
+   * @return void
+   */
+  finalize() {
+    this.engine.finalize();
+  }
+  /**
+   * @return this.engine
+   */
+  on() {
+    return this.engine.on.apply(this.engine, arguments);
+  }
+  /**
+   * @return this.engine
+   */
+  pipe() {
+    return this.engine.pipe.apply(this.engine, arguments);
+  }
+  /**
+   * @return this.engine
+   */
+  unpipe() {
+    return this.engine.unpipe.apply(this.engine, arguments);
+  }
+}