text: /**
   * ZipStream
   *
   * @ignore
   * @license [MIT]{@link https://github.com/archiverjs/node-zip-stream/blob/master/LICENSE}
   * @copyright (c) 2014 Chris Talkington, contributors.
   */
  var inherits = require('util').inherits;
  
  var ZipArchiveOutputStream = require('compress-commons').ZipArchiveOutputStream;
  var ZipArchiveEntry = require('compress-commons').ZipArchiveEntry;
  
  var util = require('archiver-utils');
  
  /**
   * @constructor
   * @extends external:ZipArchiveOutputStream
   * @param {Object} [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.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}
   * to control compression.
   */
  var ZipStream = module.exports = function(options) {
    if (!(this instanceof ZipStream)) {
      return new ZipStream(options);
    }
  
    options = this.options = options || {};
    options.zlib = options.zlib || {};
  
    ZipArchiveOutputStream.call(this, options);
  
    if (typeof options.level === 'number' && options.level >= 0) {
      options.zlib.level = options.level;
      delete options.level;
    }
  
    if (typeof options.zlib.level === 'number' && options.zlib.level === 0) {
      options.store = true;
    }
  
    if (options.comment && options.comment.length > 0) {
      this.setComment(options.comment);
    }
  };
  
  inherits(ZipStream, ZipArchiveOutputStream);
  
  /**
   * Normalizes entry data with fallbacks for key properties.
   *
   * @private
   * @param  {Object} data
   * @return {Object}
   */
  ZipStream.prototype._normalizeFileData = function(data) {
    data = util.defaults(data, {
      type: 'file',
      name: null,
      linkname: null,
      date: null,
      mode: null,
      store: this.options.store,
      comment: ''
    });
  
    var isDir = data.type === 'directory';
    var isSymlink = data.type === 'symlink';
  
    if (data.name) {
      data.name = util.sanitizePath(data.name);
  
      if (!isSymlink && data.name.slice(-1) === '/') {
        isDir = true;
        data.type = 'directory';
      } else if (isDir) {
        data.name += '/';
      }
    }
  
    if (isDir || isSymlink) {
      data.store = true;
    }
  
    data.date = util.dateify(data.date);
  
    return data;
  };
  
  /**
   * Appends an entry given an input source (text string, buffer, or stream).
   *
   * @param  {(Buffer|Stream|String)} source The input source.
   * @param  {Object} data
   * @param  {String} data.name Sets the entry name including internal path.
   * @param  {String} [data.comment] Sets the entry comment.
   * @param  {(String|Date)} [data.date=NOW()] Sets the entry date.
   * @param  {Number} [data.mode=D:0755/F:0644] Sets the entry permissions.
   * @param  {Boolean} [data.store=options.store] Sets the compression method to STORE.
   * @param  {String} [data.type=file] Sets the entry type. Defaults to `directory`
   * if name ends with trailing slash.
   * @param  {Function} callback
   * @return this
   */
  ZipStream.prototype.entry = function(source, data, callback) {
    if (typeof callback !== 'function') {
      callback = this._emitErrorCallback.bind(this);
    }
  
    data = this._normalizeFileData(data);
  
    if (data.type !== 'file' && data.type !== 'directory' && data.type !== 'symlink') {
      callback(new Error(data.type + ' entries not currently supported'));
      return;
    }
  
    if (typeof data.name !== 'string' || data.name.length === 0) {
      callback(new Error('entry name must be a non-empty string value'));
      return;
    }
  
    if (data.type === 'symlink' && typeof data.linkname !== 'string') {
      callback(new Error('entry linkname must be a non-empty string value when type equals symlink'));
      return;
    }
  
    var entry = new ZipArchiveEntry(data.name);
    entry.setTime(data.date, this.options.forceLocalTime);
  
    if (data.store) {
      entry.setMethod(0);
    }
  
    if (data.comment.length > 0) {
      entry.setComment(data.comment);
    }
  
    if (data.type === 'symlink' && typeof data.mode !== 'number') {
      data.mode = 40960; // 0120000
    }
  
    if (typeof data.mode === 'number') {
      if (data.type === 'symlink') {
        data.mode |= 40960;
      }
  
      entry.setUnixMode(data.mode);
    }
  
    if (data.type === 'symlink' && typeof data.linkname === 'string') {
      source = new Buffer(data.linkname);
    }
  
    return ZipArchiveOutputStream.prototype.entry.call(this, entry, source, callback);
  };
  
  /**
   * Finalizes the instance and prevents further appending to the archive
   * structure (queue will continue til drained).
   *
   * @return void
   */
  ZipStream.prototype.finalize = function() {
    this.finish();
  };
  
  /**
   * Returns the current number of bytes written to this stream.
   * @function ZipStream#getBytesWritten
   * @returns {Number}
   */
  
  /**
   * Compress Commons ZipArchiveOutputStream
   * @external ZipArchiveOutputStream
   * @see {@link https://github.com/archiverjs/node-compress-commons}
   */
  