text: var CombinedStream = require('combined-stream');
  var util = require('util');
  var path = require('path');
  var http = require('http');
  var https = require('https');
  var parseUrl = require('url').parse;
  var fs = require('fs');
  var mime = require('mime-types');
  var asynckit = require('asynckit');
  var populate = require('./populate.js');
  
  // Public API
  module.exports = FormData;
  
  // make it a Stream
  util.inherits(FormData, CombinedStream);
  
  /**
   * Create readable "multipart/form-data" streams.
   * Can be used to submit forms
   * and file uploads to other web applications.
   *
   * @constructor
   * @param {Object} options - Properties to be added/overriden for FormData and CombinedStream
   */
  function FormData(options) {
    if (!(this instanceof FormData)) {
      return new FormData(options);
    }
  
    this._overheadLength = 0;
    this._valueLength = 0;
    this._valuesToMeasure = [];
  
    CombinedStream.call(this);
  
    options = options || {};
    for (var option in options) {
      this[option] = options[option];
    }
  }
  
  FormData.LINE_BREAK = '\r\n';
  FormData.DEFAULT_CONTENT_TYPE = 'application/octet-stream';
  
  FormData.prototype.append = function(field, value, options) {
  
    options = options || {};
    value = value || '';
  
    // allow filename as single option
    if (typeof options == 'string') {
      options = {filename: options};
    }
  
    var append = CombinedStream.prototype.append.bind(this);
  
    // all that streamy business can't handle numbers
    if (typeof value == 'number') {
      value = '' + value;
    }
  
    // https://github.com/felixge/node-form-data/issues/38
    if (util.isArray(value)) {
      // Please convert your array into string
      // the way web server expects it
      this._error(new Error('Arrays are not supported.'));
      return;
    }
  
    var header = this._multiPartHeader(field, value, options);
    var footer = this._multiPartFooter();
  
    append(header);
    append(value);
    append(footer);
  
    // pass along options.knownLength
    this._trackLength(header, value, options);
  };
  
  FormData.prototype._trackLength = function(header, value, options) {
    var valueLength = 0;
  
    // used w/ getLengthSync(), when length is known.
    // e.g. for streaming directly from a remote server,
    // w/ a known file a size, and not wanting to wait for
    // incoming file to finish to get its size.
    if (options.knownLength != null) {
      valueLength += +options.knownLength;
    } else if (Buffer.isBuffer(value)) {
      valueLength = value.length;
    } else if (typeof value === 'string') {
      valueLength = Buffer.byteLength(value);
    }
  
    this._valueLength += valueLength;
  
    // @check why add CRLF? does this account for custom/multiple CRLFs?
    this._overheadLength +=
      Buffer.byteLength(header) +
      FormData.LINE_BREAK.length;
  
    // empty or either doesn't have path or not an http response
    if (!value || ( !value.path && !(value.readable && value.hasOwnProperty('httpVersion')) )) {
      return;
    }
  
    // no need to bother with the length
    if (!options.knownLength) {
      this._valuesToMeasure.push(value);
    }
  };
  
  FormData.prototype._lengthRetriever = function(value, callback) {
  
    if (value.hasOwnProperty('fd')) {
  
      // take read range into a account
      // `end` = Infinity –> read file till the end
      //
      // TODO: Looks like there is bug in Node fs.createReadStream
      // it doesn't respect `end` options without `start` options
      // Fix it when node fixes it.
      // https://github.com/joyent/node/issues/7819
      if (value.end != undefined && value.end != Infinity && value.start != undefined) {
  
        // when end specified
        // no need to calculate range
        // inclusive, starts with 0
        callback(null, value.end + 1 - (value.start ? value.start : 0));
  
      // not that fast snoopy
      } else {
        // still need to fetch file size from fs
        fs.stat(value.path, function(err, stat) {
  
          var fileSize;
  
          if (err) {
            callback(err);
            return;
          }
  
          // update final size based on the range options
          fileSize = stat.size - (value.start ? value.start : 0);
          callback(null, fileSize);
        });
      }
  
    // or http response
    } else if (value.hasOwnProperty('httpVersion')) {
      callback(null, +value.headers['content-length']);
  
    // or request stream http://github.com/mikeal/request
    } else if (value.hasOwnProperty('httpModule')) {
      // wait till response come back
      value.on('response', function(response) {
        value.pause();
        callback(null, +response.headers['content-length']);
      });
      value.resume();
  
    // something else
    } else {
      callback('Unknown stream');
    }
  };
  
  FormData.prototype._multiPartHeader = function(field, value, options) {
    // custom header specified (as string)?
    // it becomes responsible for boundary
    // (e.g. to handle extra CRLFs on .NET servers)
    if (typeof options.header == 'string') {
      return options.header;
    }
  
    var contentDisposition = this._getContentDisposition(value, options);
    var contentType = this._getContentType(value, options);
  
    var contents = '';
    var headers  = {
      // add custom disposition as third element or keep it two elements if not
      'Content-Disposition': ['form-data', 'name="' + field + '"'].concat(contentDisposition || []),
      // if no content type. allow it to be empty array
      'Content-Type': [].concat(contentType || [])
    };
  
    // allow custom headers.
    if (typeof options.header == 'object') {
      populate(headers, options.header);
    }
  
    var header;
    for (var prop in headers) {
      if (!headers.hasOwnProperty(prop)) continue;
      header = headers[prop];
  
      // skip nullish headers.
      if (header == null) {
        continue;
      }
  
      // convert all headers to arrays.
      if (!Array.isArray(header)) {
        header = [header];
      }
  
      // add non-empty headers.
      if (header.length) {
        contents += prop + ': ' + header.join('; ') + FormData.LINE_BREAK;
      }
    }
  
    return '--' + this.getBoundary() + FormData.LINE_BREAK + contents + FormData.LINE_BREAK;
  };
  
  FormData.prototype._encodeHeaderParam = function(str, lang) {
    if (!lang || typeof lang !== 'string') {
      lang = '';
    }
  
    // taken from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent
    // @note see RFC 8187
    // @todo use postman-urlencoder instead of encodeURIComponent for consistency
    return 'UTF-8\'' + lang + '\'' + encodeURIComponent(str).
      // Note that although RFC3986 reserves "!", RFC8187 does not,
      // so we do not need to escape it
      replace(/['()*]/g, function(c) {
        return '%' + c.charCodeAt(0).toString(16);
      }).
      // The following are not required for percent-encoding per RFC8187,
      // so we can allow for a little better readability over the wire: |`^
      replace(/%(?:7C|60|5E)/g, unescape);
  };
  
  FormData.prototype._getContentDisposition = function(value, options) {
  
    var filename
      , contentDisposition = []
      , NON_ASCII_REGEX = /[^\t\x20-\x7e\x80-\xff]/
      ;
  
    if (typeof options.filepath === 'string') {
      // custom filepath for relative paths
      filename = path.normalize(options.filepath).replace(/\\/g, '/');
    } else if (typeof options.filename === 'string') {
      // custom filename take precedence
      filename = path.basename(options.filename);
    } else if (value && (value.name || value.path)) {
      // formidable and the browser add a name property
      // fs- and request- streams have path property
      filename = path.basename(value.name || value.path);
    } else if (value && value.readable && value.hasOwnProperty('httpVersion')) {
      // or try http response
      filename = path.basename(value.client._httpMessage.path || '');
    }
  
    // bail if no valid filename
    if (typeof filename !== 'string') {
      return;
    }
  
    contentDisposition.push('filename="' + filename + '"');
  
    // add "filename*" param if filename is not in ASCII
    if (NON_ASCII_REGEX.test(filename)) {
      contentDisposition.push('filename*="' + this._encodeHeaderParam(filename) + '"');
    }
  
    return contentDisposition;
  };
  
  FormData.prototype._getContentType = function(value, options) {
  
    // use custom content-type above all
    var contentType = options.contentType;
  
    // or try `name` from formidable, browser
    if (!contentType && value && value.name) {
      contentType = mime.lookup(value.name);
    }
  
    // or try `path` from fs-, request- streams
    if (!contentType && value && value.path) {
      contentType = mime.lookup(value.path);
    }
  
    // or if it's http-reponse
    if (!contentType && value && value.readable && value.hasOwnProperty('httpVersion')) {
      contentType = value.headers['content-type'];
    }
  
    // or guess it from the filepath or filename
    if (!contentType && (options.filepath || options.filename)) {
      contentType = mime.lookup(options.filepath || options.filename);
    }
  
    // fallback to the default content type if `value` is not simple value
    if (!contentType && typeof value == 'object') {
      contentType = FormData.DEFAULT_CONTENT_TYPE;
    }
  
    return contentType;
  };
  
  FormData.prototype._multiPartFooter = function() {
    return function(next) {
      var footer = FormData.LINE_BREAK;
  
      var lastPart = (this._streams.length === 0);
      if (lastPart) {
        footer += this._lastBoundary();
      }
  
      next(footer);
    }.bind(this);
  };
  
  FormData.prototype._lastBoundary = function() {
    return '--' + this.getBoundary() + '--' + FormData.LINE_BREAK;
  };
  
  FormData.prototype.getHeaders = function(userHeaders) {
    var header;
    var formHeaders = {
      'content-type': 'multipart/form-data; boundary=' + this.getBoundary()
    };
  
    for (header in userHeaders) {
      if (userHeaders.hasOwnProperty(header)) {
        formHeaders[header.toLowerCase()] = userHeaders[header];
      }
    }
  
    return formHeaders;
  };
  
  FormData.prototype.getBoundary = function() {
    if (!this._boundary) {
      this._generateBoundary();
    }
  
    return this._boundary;
  };
  
  FormData.prototype.getBuffer = function() {
    var dataBuffer = new Buffer.alloc( 0 );
    var boundary = this.getBoundary();
  
    // Create the form content. Add Line breaks to the end of data.
    for (var i = 0, len = this._streams.length; i < len; i++) {
      if (typeof this._streams[i] !== 'function') {
  
        // Add content to the buffer.
        if(Buffer.isBuffer(this._streams[i])) {
          dataBuffer = Buffer.concat( [dataBuffer, this._streams[i]]);
        }else {
          dataBuffer = Buffer.concat( [dataBuffer, Buffer.from(this._streams[i])]);
        }
  
        // Add break after content.
        if (typeof this._streams[i] !== 'string' || this._streams[i].substring( 2, boundary.length + 2 ) !== boundary) {
          dataBuffer = Buffer.concat( [dataBuffer, Buffer.from(FormData.LINE_BREAK)] );
        }
      }
    }
  
    // Add the footer and return the Buffer object.
    return Buffer.concat( [dataBuffer, Buffer.from(this._lastBoundary())] );
  };
  
  FormData.prototype._generateBoundary = function() {
    // This generates a 50 character boundary similar to those used by Firefox.
    // They are optimized for boyer-moore parsing.
    var boundary = '--------------------------';
    for (var i = 0; i < 24; i++) {
      boundary += Math.floor(Math.random() * 10).toString(16);
    }
  
    this._boundary = boundary;
  };
  
  // Note: getLengthSync DOESN'T calculate streams length
  // As workaround one can calculate file size manually
  // and add it as knownLength option
  FormData.prototype.getLengthSync = function() {
    var knownLength = this._overheadLength + this._valueLength;
  
    // Don't get confused, there are 3 "internal" streams for each keyval pair
    // so it basically checks if there is any value added to the form
    if (this._streams.length) {
      knownLength += this._lastBoundary().length;
    }
  
    // https://github.com/form-data/form-data/issues/40
    if (!this.hasKnownLength()) {
      // Some async length retrievers are present
      // therefore synchronous length calculation is false.
      // Please use getLength(callback) to get proper length
      this._error(new Error('Cannot calculate proper length in synchronous way.'));
    }
  
    return knownLength;
  };
  
  // Public API to check if length of added values is known
  // https://github.com/form-data/form-data/issues/196
  // https://github.com/form-data/form-data/issues/262
  FormData.prototype.hasKnownLength = function() {
    var hasKnownLength = true;
  
    if (this._valuesToMeasure.length) {
      hasKnownLength = false;
    }
  
    return hasKnownLength;
  };
  
  FormData.prototype.getLength = function(cb) {
    var knownLength = this._overheadLength + this._valueLength;
  
    if (this._streams.length) {
      knownLength += this._lastBoundary().length;
    }
  
    if (!this._valuesToMeasure.length) {
      process.nextTick(cb.bind(this, null, knownLength));
      return;
    }
  
    asynckit.parallel(this._valuesToMeasure, this._lengthRetriever, function(err, values) {
      if (err) {
        cb(err);
        return;
      }
  
      values.forEach(function(length) {
        knownLength += length;
      });
  
      cb(null, knownLength);
    });
  };
  
  FormData.prototype.submit = function(params, cb) {
    var request
      , options
      , defaults = {method: 'post'}
      ;
  
    // parse provided url if it's string
    // or treat it as options object
    if (typeof params == 'string') {
  
      params = parseUrl(params);
      options = populate({
        port: params.port,
        path: params.pathname,
        host: params.hostname,
        protocol: params.protocol
      }, defaults);
  
    // use custom params
    } else {
  
      options = populate(params, defaults);
      // if no port provided use default one
      if (!options.port) {
        options.port = options.protocol == 'https:' ? 443 : 80;
      }
    }
  
    // put that good code in getHeaders to some use
    options.headers = this.getHeaders(params.headers);
  
    // https if specified, fallback to http in any other case
    if (options.protocol == 'https:') {
      request = https.request(options);
    } else {
      request = http.request(options);
    }
  
    // get content length and fire away
    this.getLength(function(err, length) {
      if (err) {
        this._error(err);
        return;
      }
  
      // add content length
      request.setHeader('Content-Length', length);
  
      this.pipe(request);
      if (cb) {
        var onResponse;
  
        var callback = function (error, responce) {
          request.removeListener('error', callback);
          request.removeListener('response', onResponse);
  
          return cb.call(this, error, responce);
        };
  
        onResponse = callback.bind(this, null);
  
        request.on('error', callback);
        request.on('response', onResponse);
      }
    }.bind(this));
  
    return request;
  };
  
  FormData.prototype._error = function(err) {
    if (!this.error) {
      this.error = err;
      this.pause();
      this.emit('error', err);
    }
  };
  
  FormData.prototype.toString = function () {
    return '[object FormData]';
  };
  