@allthings/sdk 6.6.0 → 7.0.0

package/dist/cli.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 'use strict';
 
-require('@aws-sdk/client-ssm');
 var querystring = require('query-string');
 var fetch = require('cross-fetch');
 var Bottleneck = require('bottleneck');
@@ -13,7 +12,16 @@ var require$$4 = require('https');
 var require$$5 = require('url');
 var require$$6 = require('fs');
 
-const version = "6.6.0";
+function createTokenStore(initialToken) {
+    const token = new Map(Object.entries(initialToken || {}));
+    return {
+        get: (key) => token.get(key),
+        reset: () => token.clear(),
+        set: (update) => Object.entries(update).forEach(([key, value]) => token.set(key, value)),
+    };
+}
+
+const version = "7.0.0";
 
 const REST_API_URL = 'https://api.allthings.me';
 const OAUTH_URL = 'https://accounts.allthings.me';
@@ -35,35 +43,6 @@ const DEFAULT_API_WRAPPER_OPTIONS = {
     username: process.env.ALLTHINGS_OAUTH_USERNAME,
 };
 const USER_AGENT = `Allthings Node SDK REST Client/${version}`;
-const DEFAULT_AWS_CONFIGURATION = {
-    region: 'eu-central-2',
-};
-
-(undefined && undefined.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-({
-    clientConfig: DEFAULT_AWS_CONFIGURATION,
-    onlyDefault: false,
-    prefix: process.env.SSM_PARAM_PATH,
-});
-
-function createTokenStore(initialToken) {
-    const token = new Map(Object.entries(initialToken || {}));
-    return {
-        get: (key) => token.get(key),
-        reset: () => token.clear(),
-        set: (update) => Object.entries(update).forEach(([key, value]) => token.set(key, value)),
-    };
-}
 
 const RESPONSE_TYPE$1 = 'code';
 const GRANT_TYPE$3 = 'authorization_code';
@@ -875,322 +854,338 @@ function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
-var Stream$2 = require$$0$1.Stream;
-var util$2 = require$$1;
-
-var delayed_stream = DelayedStream$1;
-function DelayedStream$1() {
-  this.source = null;
-  this.dataSize = 0;
-  this.maxDataSize = 1024 * 1024;
-  this.pauseStream = true;
-
-  this._maxDataSizeExceeded = false;
-  this._released = false;
-  this._bufferedEvents = [];
-}
-util$2.inherits(DelayedStream$1, Stream$2);
-
-DelayedStream$1.create = function(source, options) {
-  var delayedStream = new this();
+var delayed_stream;
+var hasRequiredDelayed_stream;
+
+function requireDelayed_stream () {
+	if (hasRequiredDelayed_stream) return delayed_stream;
+	hasRequiredDelayed_stream = 1;
+	var Stream = require$$0$1.Stream;
+	var util = require$$1;
+
+	delayed_stream = DelayedStream;
+	function DelayedStream() {
+	  this.source = null;
+	  this.dataSize = 0;
+	  this.maxDataSize = 1024 * 1024;
+	  this.pauseStream = true;
+
+	  this._maxDataSizeExceeded = false;
+	  this._released = false;
+	  this._bufferedEvents = [];
+	}
+	util.inherits(DelayedStream, Stream);
 
-  options = options || {};
-  for (var option in options) {
-    delayedStream[option] = options[option];
-  }
+	DelayedStream.create = function(source, options) {
+	  var delayedStream = new this();
 
-  delayedStream.source = source;
+	  options = options || {};
+	  for (var option in options) {
+	    delayedStream[option] = options[option];
+	  }
 
-  var realEmit = source.emit;
-  source.emit = function() {
-    delayedStream._handleEmit(arguments);
-    return realEmit.apply(source, arguments);
-  };
+	  delayedStream.source = source;
 
-  source.on('error', function() {});
-  if (delayedStream.pauseStream) {
-    source.pause();
-  }
+	  var realEmit = source.emit;
+	  source.emit = function() {
+	    delayedStream._handleEmit(arguments);
+	    return realEmit.apply(source, arguments);
+	  };
 
-  return delayedStream;
-};
+	  source.on('error', function() {});
+	  if (delayedStream.pauseStream) {
+	    source.pause();
+	  }
 
-Object.defineProperty(DelayedStream$1.prototype, 'readable', {
-  configurable: true,
-  enumerable: true,
-  get: function() {
-    return this.source.readable;
-  }
-});
+	  return delayedStream;
+	};
 
-DelayedStream$1.prototype.setEncoding = function() {
-  return this.source.setEncoding.apply(this.source, arguments);
-};
+	Object.defineProperty(DelayedStream.prototype, 'readable', {
+	  configurable: true,
+	  enumerable: true,
+	  get: function() {
+	    return this.source.readable;
+	  }
+	});
 
-DelayedStream$1.prototype.resume = function() {
-  if (!this._released) {
-    this.release();
-  }
+	DelayedStream.prototype.setEncoding = function() {
+	  return this.source.setEncoding.apply(this.source, arguments);
+	};
 
-  this.source.resume();
-};
+	DelayedStream.prototype.resume = function() {
+	  if (!this._released) {
+	    this.release();
+	  }
 
-DelayedStream$1.prototype.pause = function() {
-  this.source.pause();
-};
+	  this.source.resume();
+	};
 
-DelayedStream$1.prototype.release = function() {
-  this._released = true;
+	DelayedStream.prototype.pause = function() {
+	  this.source.pause();
+	};
 
-  this._bufferedEvents.forEach(function(args) {
-    this.emit.apply(this, args);
-  }.bind(this));
-  this._bufferedEvents = [];
-};
+	DelayedStream.prototype.release = function() {
+	  this._released = true;
 
-DelayedStream$1.prototype.pipe = function() {
-  var r = Stream$2.prototype.pipe.apply(this, arguments);
-  this.resume();
-  return r;
-};
+	  this._bufferedEvents.forEach(function(args) {
+	    this.emit.apply(this, args);
+	  }.bind(this));
+	  this._bufferedEvents = [];
+	};
 
-DelayedStream$1.prototype._handleEmit = function(args) {
-  if (this._released) {
-    this.emit.apply(this, args);
-    return;
-  }
+	DelayedStream.prototype.pipe = function() {
+	  var r = Stream.prototype.pipe.apply(this, arguments);
+	  this.resume();
+	  return r;
+	};
 
-  if (args[0] === 'data') {
-    this.dataSize += args[1].length;
-    this._checkIfMaxDataSizeExceeded();
-  }
+	DelayedStream.prototype._handleEmit = function(args) {
+	  if (this._released) {
+	    this.emit.apply(this, args);
+	    return;
+	  }
 
-  this._bufferedEvents.push(args);
-};
+	  if (args[0] === 'data') {
+	    this.dataSize += args[1].length;
+	    this._checkIfMaxDataSizeExceeded();
+	  }
 
-DelayedStream$1.prototype._checkIfMaxDataSizeExceeded = function() {
-  if (this._maxDataSizeExceeded) {
-    return;
-  }
+	  this._bufferedEvents.push(args);
+	};
 
-  if (this.dataSize <= this.maxDataSize) {
-    return;
-  }
+	DelayedStream.prototype._checkIfMaxDataSizeExceeded = function() {
+	  if (this._maxDataSizeExceeded) {
+	    return;
+	  }
 
-  this._maxDataSizeExceeded = true;
-  var message =
-    'DelayedStream#maxDataSize of ' + this.maxDataSize + ' bytes exceeded.';
-  this.emit('error', new Error(message));
-};
+	  if (this.dataSize <= this.maxDataSize) {
+	    return;
+	  }
 
-var util$1 = require$$1;
-var Stream$1 = require$$0$1.Stream;
-var DelayedStream = delayed_stream;
-
-var combined_stream = CombinedStream$1;
-function CombinedStream$1() {
-  this.writable = false;
-  this.readable = true;
-  this.dataSize = 0;
-  this.maxDataSize = 2 * 1024 * 1024;
-  this.pauseStreams = true;
-
-  this._released = false;
-  this._streams = [];
-  this._currentStream = null;
-  this._insideLoop = false;
-  this._pendingNext = false;
+	  this._maxDataSizeExceeded = true;
+	  var message =
+	    'DelayedStream#maxDataSize of ' + this.maxDataSize + ' bytes exceeded.';
+	  this.emit('error', new Error(message));
+	};
+	return delayed_stream;
 }
-util$1.inherits(CombinedStream$1, Stream$1);
-
-CombinedStream$1.create = function(options) {
-  var combinedStream = new this();
-
-  options = options || {};
-  for (var option in options) {
-    combinedStream[option] = options[option];
-  }
 
-  return combinedStream;
-};
+var combined_stream;
+var hasRequiredCombined_stream;
+
+function requireCombined_stream () {
+	if (hasRequiredCombined_stream) return combined_stream;
+	hasRequiredCombined_stream = 1;
+	var util = require$$1;
+	var Stream = require$$0$1.Stream;
+	var DelayedStream = requireDelayed_stream();
+
+	combined_stream = CombinedStream;
+	function CombinedStream() {
+	  this.writable = false;
+	  this.readable = true;
+	  this.dataSize = 0;
+	  this.maxDataSize = 2 * 1024 * 1024;
+	  this.pauseStreams = true;
+
+	  this._released = false;
+	  this._streams = [];
+	  this._currentStream = null;
+	  this._insideLoop = false;
+	  this._pendingNext = false;
+	}
+	util.inherits(CombinedStream, Stream);
 
-CombinedStream$1.isStreamLike = function(stream) {
-  return (typeof stream !== 'function')
-    && (typeof stream !== 'string')
-    && (typeof stream !== 'boolean')
-    && (typeof stream !== 'number')
-    && (!Buffer.isBuffer(stream));
-};
+	CombinedStream.create = function(options) {
+	  var combinedStream = new this();
 
-CombinedStream$1.prototype.append = function(stream) {
-  var isStreamLike = CombinedStream$1.isStreamLike(stream);
-
-  if (isStreamLike) {
-    if (!(stream instanceof DelayedStream)) {
-      var newStream = DelayedStream.create(stream, {
-        maxDataSize: Infinity,
-        pauseStream: this.pauseStreams,
-      });
-      stream.on('data', this._checkDataSize.bind(this));
-      stream = newStream;
-    }
+	  options = options || {};
+	  for (var option in options) {
+	    combinedStream[option] = options[option];
+	  }
 
-    this._handleErrors(stream);
+	  return combinedStream;
+	};
+
+	CombinedStream.isStreamLike = function(stream) {
+	  return (typeof stream !== 'function')
+	    && (typeof stream !== 'string')
+	    && (typeof stream !== 'boolean')
+	    && (typeof stream !== 'number')
+	    && (!Buffer.isBuffer(stream));
+	};
+
+	CombinedStream.prototype.append = function(stream) {
+	  var isStreamLike = CombinedStream.isStreamLike(stream);
+
+	  if (isStreamLike) {
+	    if (!(stream instanceof DelayedStream)) {
+	      var newStream = DelayedStream.create(stream, {
+	        maxDataSize: Infinity,
+	        pauseStream: this.pauseStreams,
+	      });
+	      stream.on('data', this._checkDataSize.bind(this));
+	      stream = newStream;
+	    }
 
-    if (this.pauseStreams) {
-      stream.pause();
-    }
-  }
+	    this._handleErrors(stream);
 
-  this._streams.push(stream);
-  return this;
-};
+	    if (this.pauseStreams) {
+	      stream.pause();
+	    }
+	  }
 
-CombinedStream$1.prototype.pipe = function(dest, options) {
-  Stream$1.prototype.pipe.call(this, dest, options);
-  this.resume();
-  return dest;
-};
+	  this._streams.push(stream);
+	  return this;
+	};
 
-CombinedStream$1.prototype._getNext = function() {
-  this._currentStream = null;
-
-  if (this._insideLoop) {
-    this._pendingNext = true;
-    return; // defer call
-  }
-
-  this._insideLoop = true;
-  try {
-    do {
-      this._pendingNext = false;
-      this._realGetNext();
-    } while (this._pendingNext);
-  } finally {
-    this._insideLoop = false;
-  }
-};
+	CombinedStream.prototype.pipe = function(dest, options) {
+	  Stream.prototype.pipe.call(this, dest, options);
+	  this.resume();
+	  return dest;
+	};
 
-CombinedStream$1.prototype._realGetNext = function() {
-  var stream = this._streams.shift();
+	CombinedStream.prototype._getNext = function() {
+	  this._currentStream = null;
 
+	  if (this._insideLoop) {
+	    this._pendingNext = true;
+	    return; // defer call
+	  }
 
-  if (typeof stream == 'undefined') {
-    this.end();
-    return;
-  }
+	  this._insideLoop = true;
+	  try {
+	    do {
+	      this._pendingNext = false;
+	      this._realGetNext();
+	    } while (this._pendingNext);
+	  } finally {
+	    this._insideLoop = false;
+	  }
+	};
 
-  if (typeof stream !== 'function') {
-    this._pipeNext(stream);
-    return;
-  }
-
-  var getStream = stream;
-  getStream(function(stream) {
-    var isStreamLike = CombinedStream$1.isStreamLike(stream);
-    if (isStreamLike) {
-      stream.on('data', this._checkDataSize.bind(this));
-      this._handleErrors(stream);
-    }
+	CombinedStream.prototype._realGetNext = function() {
+	  var stream = this._streams.shift();
 
-    this._pipeNext(stream);
-  }.bind(this));
-};
 
-CombinedStream$1.prototype._pipeNext = function(stream) {
-  this._currentStream = stream;
+	  if (typeof stream == 'undefined') {
+	    this.end();
+	    return;
+	  }
 
-  var isStreamLike = CombinedStream$1.isStreamLike(stream);
-  if (isStreamLike) {
-    stream.on('end', this._getNext.bind(this));
-    stream.pipe(this, {end: false});
-    return;
-  }
+	  if (typeof stream !== 'function') {
+	    this._pipeNext(stream);
+	    return;
+	  }
 
-  var value = stream;
-  this.write(value);
-  this._getNext();
-};
+	  var getStream = stream;
+	  getStream(function(stream) {
+	    var isStreamLike = CombinedStream.isStreamLike(stream);
+	    if (isStreamLike) {
+	      stream.on('data', this._checkDataSize.bind(this));
+	      this._handleErrors(stream);
+	    }
 
-CombinedStream$1.prototype._handleErrors = function(stream) {
-  var self = this;
-  stream.on('error', function(err) {
-    self._emitError(err);
-  });
-};
+	    this._pipeNext(stream);
+	  }.bind(this));
+	};
 
-CombinedStream$1.prototype.write = function(data) {
-  this.emit('data', data);
-};
+	CombinedStream.prototype._pipeNext = function(stream) {
+	  this._currentStream = stream;
 
-CombinedStream$1.prototype.pause = function() {
-  if (!this.pauseStreams) {
-    return;
-  }
+	  var isStreamLike = CombinedStream.isStreamLike(stream);
+	  if (isStreamLike) {
+	    stream.on('end', this._getNext.bind(this));
+	    stream.pipe(this, {end: false});
+	    return;
+	  }
 
-  if(this.pauseStreams && this._currentStream && typeof(this._currentStream.pause) == 'function') this._currentStream.pause();
-  this.emit('pause');
-};
+	  var value = stream;
+	  this.write(value);
+	  this._getNext();
+	};
 
-CombinedStream$1.prototype.resume = function() {
-  if (!this._released) {
-    this._released = true;
-    this.writable = true;
-    this._getNext();
-  }
+	CombinedStream.prototype._handleErrors = function(stream) {
+	  var self = this;
+	  stream.on('error', function(err) {
+	    self._emitError(err);
+	  });
+	};
 
-  if(this.pauseStreams && this._currentStream && typeof(this._currentStream.resume) == 'function') this._currentStream.resume();
-  this.emit('resume');
-};
+	CombinedStream.prototype.write = function(data) {
+	  this.emit('data', data);
+	};
 
-CombinedStream$1.prototype.end = function() {
-  this._reset();
-  this.emit('end');
-};
+	CombinedStream.prototype.pause = function() {
+	  if (!this.pauseStreams) {
+	    return;
+	  }
 
-CombinedStream$1.prototype.destroy = function() {
-  this._reset();
-  this.emit('close');
-};
+	  if(this.pauseStreams && this._currentStream && typeof(this._currentStream.pause) == 'function') this._currentStream.pause();
+	  this.emit('pause');
+	};
 
-CombinedStream$1.prototype._reset = function() {
-  this.writable = false;
-  this._streams = [];
-  this._currentStream = null;
-};
+	CombinedStream.prototype.resume = function() {
+	  if (!this._released) {
+	    this._released = true;
+	    this.writable = true;
+	    this._getNext();
+	  }
 
-CombinedStream$1.prototype._checkDataSize = function() {
-  this._updateDataSize();
-  if (this.dataSize <= this.maxDataSize) {
-    return;
-  }
+	  if(this.pauseStreams && this._currentStream && typeof(this._currentStream.resume) == 'function') this._currentStream.resume();
+	  this.emit('resume');
+	};
+
+	CombinedStream.prototype.end = function() {
+	  this._reset();
+	  this.emit('end');
+	};
+
+	CombinedStream.prototype.destroy = function() {
+	  this._reset();
+	  this.emit('close');
+	};
+
+	CombinedStream.prototype._reset = function() {
+	  this.writable = false;
+	  this._streams = [];
+	  this._currentStream = null;
+	};
+
+	CombinedStream.prototype._checkDataSize = function() {
+	  this._updateDataSize();
+	  if (this.dataSize <= this.maxDataSize) {
+	    return;
+	  }
 
-  var message =
-    'DelayedStream#maxDataSize of ' + this.maxDataSize + ' bytes exceeded.';
-  this._emitError(new Error(message));
-};
+	  var message =
+	    'DelayedStream#maxDataSize of ' + this.maxDataSize + ' bytes exceeded.';
+	  this._emitError(new Error(message));
+	};
 
-CombinedStream$1.prototype._updateDataSize = function() {
-  this.dataSize = 0;
+	CombinedStream.prototype._updateDataSize = function() {
+	  this.dataSize = 0;
 
-  var self = this;
-  this._streams.forEach(function(stream) {
-    if (!stream.dataSize) {
-      return;
-    }
+	  var self = this;
+	  this._streams.forEach(function(stream) {
+	    if (!stream.dataSize) {
+	      return;
+	    }
 
-    self.dataSize += stream.dataSize;
-  });
+	    self.dataSize += stream.dataSize;
+	  });
 
-  if (this._currentStream && this._currentStream.dataSize) {
-    this.dataSize += this._currentStream.dataSize;
-  }
-};
+	  if (this._currentStream && this._currentStream.dataSize) {
+	    this.dataSize += this._currentStream.dataSize;
+	  }
+	};
 
-CombinedStream$1.prototype._emitError = function(err) {
-  this._reset();
-  this.emit('error', err);
-};
+	CombinedStream.prototype._emitError = function(err) {
+	  this._reset();
+	  this.emit('error', err);
+	};
+	return combined_stream;
+}
 
 var mimeTypes = {};
 
@@ -11904,11 +11899,19 @@ var require$$0 = {
  * MIT Licensed
  */
 
-/**
- * Module exports.
- */
+var mimeDb;
+var hasRequiredMimeDb;
 
-var mimeDb = require$$0;
+function requireMimeDb () {
+	if (hasRequiredMimeDb) return mimeDb;
+	hasRequiredMimeDb = 1;
+	/**
+	 * Module exports.
+	 */
+
+	mimeDb = require$$0;
+	return mimeDb;
+}
 
 /*!
  * mime-types
@@ -11917,1088 +11920,1189 @@ var mimeDb = require$$0;
  * MIT Licensed
  */
 
-(function (exports) {
+var hasRequiredMimeTypes;
+
+function requireMimeTypes () {
+	if (hasRequiredMimeTypes) return mimeTypes;
+	hasRequiredMimeTypes = 1;
+	(function (exports) {
+
+		/**
+		 * Module dependencies.
+		 * @private
+		 */
+
+		var db = requireMimeDb();
+		var extname = require$$1$1.extname;
+
+		/**
+		 * Module variables.
+		 * @private
+		 */
+
+		var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
+		var TEXT_TYPE_REGEXP = /^text\//i;
+
+		/**
+		 * Module exports.
+		 * @public
+		 */
+
+		exports.charset = charset;
+		exports.charsets = { lookup: charset };
+		exports.contentType = contentType;
+		exports.extension = extension;
+		exports.extensions = Object.create(null);
+		exports.lookup = lookup;
+		exports.types = Object.create(null);
+
+		// Populate the extensions/types maps
+		populateMaps(exports.extensions, exports.types);
+
+		/**
+		 * Get the default charset for a MIME type.
+		 *
+		 * @param {string} type
+		 * @return {boolean|string}
+		 */
+
+		function charset (type) {
+		  if (!type || typeof type !== 'string') {
+		    return false
+		  }
+
+		  // TODO: use media-typer
+		  var match = EXTRACT_TYPE_REGEXP.exec(type);
+		  var mime = match && db[match[1].toLowerCase()];
+
+		  if (mime && mime.charset) {
+		    return mime.charset
+		  }
+
+		  // default text/* to utf-8
+		  if (match && TEXT_TYPE_REGEXP.test(match[1])) {
+		    return 'UTF-8'
+		  }
+
+		  return false
+		}
+
+		/**
+		 * Create a full Content-Type header given a MIME type or extension.
+		 *
+		 * @param {string} str
+		 * @return {boolean|string}
+		 */
+
+		function contentType (str) {
+		  // TODO: should this even be in this module?
+		  if (!str || typeof str !== 'string') {
+		    return false
+		  }
+
+		  var mime = str.indexOf('/') === -1
+		    ? exports.lookup(str)
+		    : str;
+
+		  if (!mime) {
+		    return false
+		  }
+
+		  // TODO: use content-type or other module
+		  if (mime.indexOf('charset') === -1) {
+		    var charset = exports.charset(mime);
+		    if (charset) mime += '; charset=' + charset.toLowerCase();
+		  }
+
+		  return mime
+		}
+
+		/**
+		 * Get the default extension for a MIME type.
+		 *
+		 * @param {string} type
+		 * @return {boolean|string}
+		 */
+
+		function extension (type) {
+		  if (!type || typeof type !== 'string') {
+		    return false
+		  }
+
+		  // TODO: use media-typer
+		  var match = EXTRACT_TYPE_REGEXP.exec(type);
+
+		  // get extensions
+		  var exts = match && exports.extensions[match[1].toLowerCase()];
+
+		  if (!exts || !exts.length) {
+		    return false
+		  }
+
+		  return exts[0]
+		}
+
+		/**
+		 * Lookup the MIME type for a file path/extension.
+		 *
+		 * @param {string} path
+		 * @return {boolean|string}
+		 */
+
+		function lookup (path) {
+		  if (!path || typeof path !== 'string') {
+		    return false
+		  }
+
+		  // get the extension ("ext" or ".ext" or full path)
+		  var extension = extname('x.' + path)
+		    .toLowerCase()
+		    .substr(1);
+
+		  if (!extension) {
+		    return false
+		  }
+
+		  return exports.types[extension] || false
+		}
+
+		/**
+		 * Populate the extensions and types maps.
+		 * @private
+		 */
+
+		function populateMaps (extensions, types) {
+		  // source preference (least -> most)
+		  var preference = ['nginx', 'apache', undefined, 'iana'];
+
+		  Object.keys(db).forEach(function forEachMimeType (type) {
+		    var mime = db[type];
+		    var exts = mime.extensions;
+
+		    if (!exts || !exts.length) {
+		      return
+		    }
+
+		    // mime -> extensions
+		    extensions[type] = exts;
+
+		    // extension -> mime
+		    for (var i = 0; i < exts.length; i++) {
+		      var extension = exts[i];
+
+		      if (types[extension]) {
+		        var from = preference.indexOf(db[types[extension]].source);
+		        var to = preference.indexOf(mime.source);
+
+		        if (types[extension] !== 'application/octet-stream' &&
+		          (from > to || (from === to && types[extension].substr(0, 12) === 'application/'))) {
+		          // skip the remapping
+		          continue
+		        }
+		      }
+
+		      // set the extension -> mime
+		      types[extension] = type;
+		    }
+		  });
+		} 
+	} (mimeTypes));
+	return mimeTypes;
+}
 
-	/**
-	 * Module dependencies.
-	 * @private
-	 */
+var defer_1;
+var hasRequiredDefer;
 
-	var db = mimeDb;
-	var extname = require$$1$1.extname;
+function requireDefer () {
+	if (hasRequiredDefer) return defer_1;
+	hasRequiredDefer = 1;
+	defer_1 = defer;
 
 	/**
-	 * Module variables.
-	 * @private
+	 * Runs provided function on next iteration of the event loop
+	 *
+	 * @param {function} fn - function to run
 	 */
+	function defer(fn)
+	{
+	  var nextTick = typeof setImmediate == 'function'
+	    ? setImmediate
+	    : (
+	      typeof process == 'object' && typeof process.nextTick == 'function'
+	      ? process.nextTick
+	      : null
+	    );
+
+	  if (nextTick)
+	  {
+	    nextTick(fn);
+	  }
+	  else
+	  {
+	    setTimeout(fn, 0);
+	  }
+	}
+	return defer_1;
+}
 
-	var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
-	var TEXT_TYPE_REGEXP = /^text\//i;
-
-	/**
-	 * Module exports.
-	 * @public
-	 */
+var async_1;
+var hasRequiredAsync;
 
-	exports.charset = charset;
-	exports.charsets = { lookup: charset };
-	exports.contentType = contentType;
-	exports.extension = extension;
-	exports.extensions = Object.create(null);
-	exports.lookup = lookup;
-	exports.types = Object.create(null);
+function requireAsync () {
+	if (hasRequiredAsync) return async_1;
+	hasRequiredAsync = 1;
+	var defer = requireDefer();
 
-	// Populate the extensions/types maps
-	populateMaps(exports.extensions, exports.types);
+	// API
+	async_1 = async;
 
 	/**
-	 * Get the default charset for a MIME type.
+	 * Runs provided callback asynchronously
+	 * even if callback itself is not
 	 *
-	 * @param {string} type
-	 * @return {boolean|string}
+	 * @param   {function} callback - callback to invoke
+	 * @returns {function} - augmented callback
 	 */
+	function async(callback)
+	{
+	  var isAsync = false;
+
+	  // check if async happened
+	  defer(function() { isAsync = true; });
+
+	  return function async_callback(err, result)
+	  {
+	    if (isAsync)
+	    {
+	      callback(err, result);
+	    }
+	    else
+	    {
+	      defer(function nextTick_callback()
+	      {
+	        callback(err, result);
+	      });
+	    }
+	  };
+	}
+	return async_1;
+}
 
-	function charset (type) {
-	  if (!type || typeof type !== 'string') {
-	    return false
-	  }
-
-	  // TODO: use media-typer
-	  var match = EXTRACT_TYPE_REGEXP.exec(type);
-	  var mime = match && db[match[1].toLowerCase()];
+var abort_1;
+var hasRequiredAbort;
 
-	  if (mime && mime.charset) {
-	    return mime.charset
-	  }
+function requireAbort () {
+	if (hasRequiredAbort) return abort_1;
+	hasRequiredAbort = 1;
+	// API
+	abort_1 = abort;
 
-	  // default text/* to utf-8
-	  if (match && TEXT_TYPE_REGEXP.test(match[1])) {
-	    return 'UTF-8'
-	  }
+	/**
+	 * Aborts leftover active jobs
+	 *
+	 * @param {object} state - current state object
+	 */
+	function abort(state)
+	{
+	  Object.keys(state.jobs).forEach(clean.bind(state));
 
-	  return false
+	  // reset leftover jobs
+	  state.jobs = {};
 	}
 
 	/**
-	 * Create a full Content-Type header given a MIME type or extension.
+	 * Cleans up leftover job by invoking abort function for the provided job id
 	 *
-	 * @param {string} str
-	 * @return {boolean|string}
+	 * @this  state
+	 * @param {string|number} key - job id to abort
 	 */
-
-	function contentType (str) {
-	  // TODO: should this even be in this module?
-	  if (!str || typeof str !== 'string') {
-	    return false
+	function clean(key)
+	{
+	  if (typeof this.jobs[key] == 'function')
+	  {
+	    this.jobs[key]();
 	  }
+	}
+	return abort_1;
+}
 
-	  var mime = str.indexOf('/') === -1
-	    ? exports.lookup(str)
-	    : str;
+var iterate_1;
+var hasRequiredIterate;
 
-	  if (!mime) {
-	    return false
-	  }
+function requireIterate () {
+	if (hasRequiredIterate) return iterate_1;
+	hasRequiredIterate = 1;
+	var async = requireAsync()
+	  , abort = requireAbort()
+	  ;
 
-	  // TODO: use content-type or other module
-	  if (mime.indexOf('charset') === -1) {
-	    var charset = exports.charset(mime);
-	    if (charset) mime += '; charset=' + charset.toLowerCase();
-	  }
-
-	  return mime
-	}
+	// API
+	iterate_1 = iterate;
 
 	/**
-	 * Get the default extension for a MIME type.
+	 * Iterates over each job object
 	 *
-	 * @param {string} type
-	 * @return {boolean|string}
+	 * @param {array|object} list - array or object (named list) to iterate over
+	 * @param {function} iterator - iterator to run
+	 * @param {object} state - current job status
+	 * @param {function} callback - invoked when all elements processed
 	 */
+	function iterate(list, iterator, state, callback)
+	{
+	  // store current index
+	  var key = state['keyedList'] ? state['keyedList'][state.index] : state.index;
+
+	  state.jobs[key] = runJob(iterator, key, list[key], function(error, output)
+	  {
+	    // don't repeat yourself
+	    // skip secondary callbacks
+	    if (!(key in state.jobs))
+	    {
+	      return;
+	    }
 
-	function extension (type) {
-	  if (!type || typeof type !== 'string') {
-	    return false
-	  }
-
-	  // TODO: use media-typer
-	  var match = EXTRACT_TYPE_REGEXP.exec(type);
-
-	  // get extensions
-	  var exts = match && exports.extensions[match[1].toLowerCase()];
+	    // clean up jobs
+	    delete state.jobs[key];
 
-	  if (!exts || !exts.length) {
-	    return false
-	  }
+	    if (error)
+	    {
+	      // don't process rest of the results
+	      // stop still active jobs
+	      // and reset the list
+	      abort(state);
+	    }
+	    else
+	    {
+	      state.results[key] = output;
+	    }
 
-	  return exts[0]
+	    // return salvaged results
+	    callback(error, state.results);
+	  });
 	}
 
 	/**
-	 * Lookup the MIME type for a file path/extension.
+	 * Runs iterator over provided job element
 	 *
-	 * @param {string} path
-	 * @return {boolean|string}
+	 * @param   {function} iterator - iterator to invoke
+	 * @param   {string|number} key - key/index of the element in the list of jobs
+	 * @param   {mixed} item - job description
+	 * @param   {function} callback - invoked after iterator is done with the job
+	 * @returns {function|mixed} - job abort function or something else
 	 */
-
-	function lookup (path) {
-	  if (!path || typeof path !== 'string') {
-	    return false
+	function runJob(iterator, key, item, callback)
+	{
+	  var aborter;
+
+	  // allow shortcut if iterator expects only two arguments
+	  if (iterator.length == 2)
+	  {
+	    aborter = iterator(item, async(callback));
 	  }
-
-	  // get the extension ("ext" or ".ext" or full path)
-	  var extension = extname('x.' + path)
-	    .toLowerCase()
-	    .substr(1);
-
-	  if (!extension) {
-	    return false
+	  // otherwise go with full three arguments
+	  else
+	  {
+	    aborter = iterator(item, key, async(callback));
 	  }
 
-	  return exports.types[extension] || false
+	  return aborter;
 	}
+	return iterate_1;
+}
 
-	/**
-	 * Populate the extensions and types maps.
-	 * @private
-	 */
-
-	function populateMaps (extensions, types) {
-	  // source preference (least -> most)
-	  var preference = ['nginx', 'apache', undefined, 'iana'];
+var state_1;
+var hasRequiredState;
 
-	  Object.keys(db).forEach(function forEachMimeType (type) {
-	    var mime = db[type];
-	    var exts = mime.extensions;
+function requireState () {
+	if (hasRequiredState) return state_1;
+	hasRequiredState = 1;
+	// API
+	state_1 = state;
 
-	    if (!exts || !exts.length) {
-	      return
+	/**
+	 * Creates initial state object
+	 * for iteration over list
+	 *
+	 * @param   {array|object} list - list to iterate over
+	 * @param   {function|null} sortMethod - function to use for keys sort,
+	 *                                     or `null` to keep them as is
+	 * @returns {object} - initial state object
+	 */
+	function state(list, sortMethod)
+	{
+	  var isNamedList = !Array.isArray(list)
+	    , initState =
+	    {
+	      index    : 0,
+	      keyedList: isNamedList || sortMethod ? Object.keys(list) : null,
+	      jobs     : {},
+	      results  : isNamedList ? {} : [],
+	      size     : isNamedList ? Object.keys(list).length : list.length
 	    }
+	    ;
+
+	  if (sortMethod)
+	  {
+	    // sort array keys based on it's values
+	    // sort object's keys just on own merit
+	    initState.keyedList.sort(isNamedList ? sortMethod : function(a, b)
+	    {
+	      return sortMethod(list[a], list[b]);
+	    });
+	  }
 
-	    // mime -> extensions
-	    extensions[type] = exts;
-
-	    // extension -> mime
-	    for (var i = 0; i < exts.length; i++) {
-	      var extension = exts[i];
-
-	      if (types[extension]) {
-	        var from = preference.indexOf(db[types[extension]].source);
-	        var to = preference.indexOf(mime.source);
+	  return initState;
+	}
+	return state_1;
+}
 
-	        if (types[extension] !== 'application/octet-stream' &&
-	          (from > to || (from === to && types[extension].substr(0, 12) === 'application/'))) {
-	          // skip the remapping
-	          continue
-	        }
-	      }
+var terminator_1;
+var hasRequiredTerminator;
 
-	      // set the extension -> mime
-	      types[extension] = type;
-	    }
-	  });
-	} 
-} (mimeTypes));
+function requireTerminator () {
+	if (hasRequiredTerminator) return terminator_1;
+	hasRequiredTerminator = 1;
+	var abort = requireAbort()
+	  , async = requireAsync()
+	  ;
 
-var defer_1 = defer$1;
+	// API
+	terminator_1 = terminator;
 
-/**
- * Runs provided function on next iteration of the event loop
- *
- * @param {function} fn - function to run
- */
-function defer$1(fn)
-{
-  var nextTick = typeof setImmediate == 'function'
-    ? setImmediate
-    : (
-      typeof process == 'object' && typeof process.nextTick == 'function'
-      ? process.nextTick
-      : null
-    );
-
-  if (nextTick)
-  {
-    nextTick(fn);
-  }
-  else
-  {
-    setTimeout(fn, 0);
-  }
-}
+	/**
+	 * Terminates jobs in the attached state context
+	 *
+	 * @this  AsyncKitState#
+	 * @param {function} callback - final callback to invoke after termination
+	 */
+	function terminator(callback)
+	{
+	  if (!Object.keys(this.jobs).length)
+	  {
+	    return;
+	  }
 
-var defer = defer_1;
+	  // fast forward iteration index
+	  this.index = this.size;
 
-// API
-var async_1 = async$2;
+	  // abort jobs
+	  abort(this);
 
-/**
- * Runs provided callback asynchronously
- * even if callback itself is not
- *
- * @param   {function} callback - callback to invoke
- * @returns {function} - augmented callback
- */
-function async$2(callback)
-{
-  var isAsync = false;
-
-  // check if async happened
-  defer(function() { isAsync = true; });
-
-  return function async_callback(err, result)
-  {
-    if (isAsync)
-    {
-      callback(err, result);
-    }
-    else
-    {
-      defer(function nextTick_callback()
-      {
-        callback(err, result);
-      });
-    }
-  };
+	  // send back results we have so far
+	  async(callback)(null, this.results);
+	}
+	return terminator_1;
 }
 
-// API
-var abort_1 = abort$2;
+var parallel_1;
+var hasRequiredParallel;
 
-/**
- * Aborts leftover active jobs
- *
- * @param {object} state - current state object
- */
-function abort$2(state)
-{
-  Object.keys(state.jobs).forEach(clean.bind(state));
+function requireParallel () {
+	if (hasRequiredParallel) return parallel_1;
+	hasRequiredParallel = 1;
+	var iterate    = requireIterate()
+	  , initState  = requireState()
+	  , terminator = requireTerminator()
+	  ;
 
-  // reset leftover jobs
-  state.jobs = {};
-}
+	// Public API
+	parallel_1 = parallel;
 
-/**
- * Cleans up leftover job by invoking abort function for the provided job id
- *
- * @this  state
- * @param {string|number} key - job id to abort
- */
-function clean(key)
-{
-  if (typeof this.jobs[key] == 'function')
-  {
-    this.jobs[key]();
-  }
-}
+	/**
+	 * Runs iterator over provided array elements in parallel
+	 *
+	 * @param   {array|object} list - array or object (named list) to iterate over
+	 * @param   {function} iterator - iterator to run
+	 * @param   {function} callback - invoked when all elements processed
+	 * @returns {function} - jobs terminator
+	 */
+	function parallel(list, iterator, callback)
+	{
+	  var state = initState(list);
+
+	  while (state.index < (state['keyedList'] || list).length)
+	  {
+	    iterate(list, iterator, state, function(error, result)
+	    {
+	      if (error)
+	      {
+	        callback(error, result);
+	        return;
+	      }
 
-var async$1 = async_1
-  , abort$1 = abort_1
-  ;
+	      // looks like it's the last one
+	      if (Object.keys(state.jobs).length === 0)
+	      {
+	        callback(null, state.results);
+	        return;
+	      }
+	    });
 
-// API
-var iterate_1 = iterate$2;
+	    state.index++;
+	  }
 
-/**
- * Iterates over each job object
- *
- * @param {array|object} list - array or object (named list) to iterate over
- * @param {function} iterator - iterator to run
- * @param {object} state - current job status
- * @param {function} callback - invoked when all elements processed
- */
-function iterate$2(list, iterator, state, callback)
-{
-  // store current index
-  var key = state['keyedList'] ? state['keyedList'][state.index] : state.index;
-
-  state.jobs[key] = runJob(iterator, key, list[key], function(error, output)
-  {
-    // don't repeat yourself
-    // skip secondary callbacks
-    if (!(key in state.jobs))
-    {
-      return;
-    }
+	  return terminator.bind(state, callback);
+	}
+	return parallel_1;
+}
 
-    // clean up jobs
-    delete state.jobs[key];
+var serialOrdered = {exports: {}};
 
-    if (error)
-    {
-      // don't process rest of the results
-      // stop still active jobs
-      // and reset the list
-      abort$1(state);
-    }
-    else
-    {
-      state.results[key] = output;
-    }
+var hasRequiredSerialOrdered;
 
-    // return salvaged results
-    callback(error, state.results);
-  });
-}
+function requireSerialOrdered () {
+	if (hasRequiredSerialOrdered) return serialOrdered.exports;
+	hasRequiredSerialOrdered = 1;
+	var iterate    = requireIterate()
+	  , initState  = requireState()
+	  , terminator = requireTerminator()
+	  ;
 
-/**
- * Runs iterator over provided job element
- *
- * @param   {function} iterator - iterator to invoke
- * @param   {string|number} key - key/index of the element in the list of jobs
- * @param   {mixed} item - job description
- * @param   {function} callback - invoked after iterator is done with the job
- * @returns {function|mixed} - job abort function or something else
- */
-function runJob(iterator, key, item, callback)
-{
-  var aborter;
-
-  // allow shortcut if iterator expects only two arguments
-  if (iterator.length == 2)
-  {
-    aborter = iterator(item, async$1(callback));
-  }
-  // otherwise go with full three arguments
-  else
-  {
-    aborter = iterator(item, key, async$1(callback));
-  }
-
-  return aborter;
-}
+	// Public API
+	serialOrdered.exports = serialOrdered$1;
+	// sorting helpers
+	serialOrdered.exports.ascending  = ascending;
+	serialOrdered.exports.descending = descending;
 
-// API
-var state_1 = state;
-
-/**
- * Creates initial state object
- * for iteration over list
- *
- * @param   {array|object} list - list to iterate over
- * @param   {function|null} sortMethod - function to use for keys sort,
- *                                     or `null` to keep them as is
- * @returns {object} - initial state object
- */
-function state(list, sortMethod)
-{
-  var isNamedList = !Array.isArray(list)
-    , initState =
-    {
-      index    : 0,
-      keyedList: isNamedList || sortMethod ? Object.keys(list) : null,
-      jobs     : {},
-      results  : isNamedList ? {} : [],
-      size     : isNamedList ? Object.keys(list).length : list.length
-    }
-    ;
-
-  if (sortMethod)
-  {
-    // sort array keys based on it's values
-    // sort object's keys just on own merit
-    initState.keyedList.sort(isNamedList ? sortMethod : function(a, b)
-    {
-      return sortMethod(list[a], list[b]);
-    });
-  }
+	/**
+	 * Runs iterator over provided sorted array elements in series
+	 *
+	 * @param   {array|object} list - array or object (named list) to iterate over
+	 * @param   {function} iterator - iterator to run
+	 * @param   {function} sortMethod - custom sort function
+	 * @param   {function} callback - invoked when all elements processed
+	 * @returns {function} - jobs terminator
+	 */
+	function serialOrdered$1(list, iterator, sortMethod, callback)
+	{
+	  var state = initState(list, sortMethod);
+
+	  iterate(list, iterator, state, function iteratorHandler(error, result)
+	  {
+	    if (error)
+	    {
+	      callback(error, result);
+	      return;
+	    }
 
-  return initState;
-}
+	    state.index++;
 
-var abort = abort_1
-  , async = async_1
-  ;
+	    // are we there yet?
+	    if (state.index < (state['keyedList'] || list).length)
+	    {
+	      iterate(list, iterator, state, iteratorHandler);
+	      return;
+	    }
 
-// API
-var terminator_1 = terminator$2;
+	    // done here
+	    callback(null, state.results);
+	  });
 
-/**
- * Terminates jobs in the attached state context
- *
- * @this  AsyncKitState#
- * @param {function} callback - final callback to invoke after termination
- */
-function terminator$2(callback)
-{
-  if (!Object.keys(this.jobs).length)
-  {
-    return;
-  }
+	  return terminator.bind(state, callback);
+	}
 
-  // fast forward iteration index
-  this.index = this.size;
+	/*
+	 * -- Sort methods
+	 */
 
-  // abort jobs
-  abort(this);
+	/**
+	 * sort helper to sort array elements in ascending order
+	 *
+	 * @param   {mixed} a - an item to compare
+	 * @param   {mixed} b - an item to compare
+	 * @returns {number} - comparison result
+	 */
+	function ascending(a, b)
+	{
+	  return a < b ? -1 : a > b ? 1 : 0;
+	}
 
-  // send back results we have so far
-  async(callback)(null, this.results);
+	/**
+	 * sort helper to sort array elements in descending order
+	 *
+	 * @param   {mixed} a - an item to compare
+	 * @param   {mixed} b - an item to compare
+	 * @returns {number} - comparison result
+	 */
+	function descending(a, b)
+	{
+	  return -1 * ascending(a, b);
+	}
+	return serialOrdered.exports;
 }
 
-var iterate$1    = iterate_1
-  , initState$1  = state_1
-  , terminator$1 = terminator_1
-  ;
-
-// Public API
-var parallel_1 = parallel;
-
-/**
- * Runs iterator over provided array elements in parallel
- *
- * @param   {array|object} list - array or object (named list) to iterate over
- * @param   {function} iterator - iterator to run
- * @param   {function} callback - invoked when all elements processed
- * @returns {function} - jobs terminator
- */
-function parallel(list, iterator, callback)
-{
-  var state = initState$1(list);
-
-  while (state.index < (state['keyedList'] || list).length)
-  {
-    iterate$1(list, iterator, state, function(error, result)
-    {
-      if (error)
-      {
-        callback(error, result);
-        return;
-      }
+var serial_1;
+var hasRequiredSerial;
 
-      // looks like it's the last one
-      if (Object.keys(state.jobs).length === 0)
-      {
-        callback(null, state.results);
-        return;
-      }
-    });
+function requireSerial () {
+	if (hasRequiredSerial) return serial_1;
+	hasRequiredSerial = 1;
+	var serialOrdered = requireSerialOrdered();
 
-    state.index++;
-  }
+	// Public API
+	serial_1 = serial;
 
-  return terminator$1.bind(state, callback);
+	/**
+	 * Runs iterator over provided array elements in series
+	 *
+	 * @param   {array|object} list - array or object (named list) to iterate over
+	 * @param   {function} iterator - iterator to run
+	 * @param   {function} callback - invoked when all elements processed
+	 * @returns {function} - jobs terminator
+	 */
+	function serial(list, iterator, callback)
+	{
+	  return serialOrdered(list, iterator, null, callback);
+	}
+	return serial_1;
 }
 
-var serialOrdered$2 = {exports: {}};
-
-var iterate    = iterate_1
-  , initState  = state_1
-  , terminator = terminator_1
-  ;
-
-// Public API
-serialOrdered$2.exports = serialOrdered$1;
-// sorting helpers
-serialOrdered$2.exports.ascending  = ascending;
-serialOrdered$2.exports.descending = descending;
-
-/**
- * Runs iterator over provided sorted array elements in series
- *
- * @param   {array|object} list - array or object (named list) to iterate over
- * @param   {function} iterator - iterator to run
- * @param   {function} sortMethod - custom sort function
- * @param   {function} callback - invoked when all elements processed
- * @returns {function} - jobs terminator
- */
-function serialOrdered$1(list, iterator, sortMethod, callback)
-{
-  var state = initState(list, sortMethod);
-
-  iterate(list, iterator, state, function iteratorHandler(error, result)
-  {
-    if (error)
-    {
-      callback(error, result);
-      return;
-    }
+var asynckit;
+var hasRequiredAsynckit;
+
+function requireAsynckit () {
+	if (hasRequiredAsynckit) return asynckit;
+	hasRequiredAsynckit = 1;
+	asynckit =
+	{
+	  parallel      : requireParallel(),
+	  serial        : requireSerial(),
+	  serialOrdered : requireSerialOrdered()
+	};
+	return asynckit;
+}
 
-    state.index++;
+var populate;
+var hasRequiredPopulate;
 
-    // are we there yet?
-    if (state.index < (state['keyedList'] || list).length)
-    {
-      iterate(list, iterator, state, iteratorHandler);
-      return;
-    }
+function requirePopulate () {
+	if (hasRequiredPopulate) return populate;
+	hasRequiredPopulate = 1;
+	// populates missing values
+	populate = function(dst, src) {
 
-    // done here
-    callback(null, state.results);
-  });
+	  Object.keys(src).forEach(function(prop)
+	  {
+	    dst[prop] = dst[prop] || src[prop];
+	  });
 
-  return terminator.bind(state, callback);
+	  return dst;
+	};
+	return populate;
 }
 
-/*
- * -- Sort methods
- */
+var form_data;
+var hasRequiredForm_data;
+
+function requireForm_data () {
+	if (hasRequiredForm_data) return form_data;
+	hasRequiredForm_data = 1;
+	var CombinedStream = requireCombined_stream();
+	var util = require$$1;
+	var path = require$$1$1;
+	var http = require$$3;
+	var https = require$$4;
+	var parseUrl = require$$5.parse;
+	var fs = require$$6;
+	var Stream = require$$0$1.Stream;
+	var mime = requireMimeTypes();
+	var asynckit = requireAsynckit();
+	var populate = requirePopulate();
+
+	// Public API
+	form_data = FormData;
+
+	// make it a Stream
+	util.inherits(FormData, CombinedStream);
 
-/**
- * sort helper to sort array elements in ascending order
- *
- * @param   {mixed} a - an item to compare
- * @param   {mixed} b - an item to compare
- * @returns {number} - comparison result
- */
-function ascending(a, b)
-{
-  return a < b ? -1 : a > b ? 1 : 0;
-}
+	/**
+	 * 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);
+	  }
 
-/**
- * sort helper to sort array elements in descending order
- *
- * @param   {mixed} a - an item to compare
- * @param   {mixed} b - an item to compare
- * @returns {number} - comparison result
- */
-function descending(a, b)
-{
-  return -1 * ascending(a, b);
-}
+	  this._overheadLength = 0;
+	  this._valueLength = 0;
+	  this._valuesToMeasure = [];
 
-var serialOrderedExports = serialOrdered$2.exports;
+	  CombinedStream.call(this);
 
-var serialOrdered = serialOrderedExports;
+	  options = options || {};
+	  for (var option in options) {
+	    this[option] = options[option];
+	  }
+	}
 
-// Public API
-var serial_1 = serial;
+	FormData.LINE_BREAK = '\r\n';
+	FormData.DEFAULT_CONTENT_TYPE = 'application/octet-stream';
 
-/**
- * Runs iterator over provided array elements in series
- *
- * @param   {array|object} list - array or object (named list) to iterate over
- * @param   {function} iterator - iterator to run
- * @param   {function} callback - invoked when all elements processed
- * @returns {function} - jobs terminator
- */
-function serial(list, iterator, callback)
-{
-  return serialOrdered(list, iterator, null, callback);
-}
+	FormData.prototype.append = function(field, value, options) {
 
-var asynckit$1 =
-{
-  parallel      : parallel_1,
-  serial        : serial_1,
-  serialOrdered : serialOrderedExports
-};
+	  options = options || {};
 
-// populates missing values
-var populate$1 = function(dst, src) {
+	  // allow filename as single option
+	  if (typeof options == 'string') {
+	    options = {filename: options};
+	  }
 
-  Object.keys(src).forEach(function(prop)
-  {
-    dst[prop] = dst[prop] || src[prop];
-  });
+	  var append = CombinedStream.prototype.append.bind(this);
 
-  return dst;
-};
+	  // all that streamy business can't handle numbers
+	  if (typeof value == 'number') {
+	    value = '' + value;
+	  }
 
-var CombinedStream = combined_stream;
-var util = require$$1;
-var path = require$$1$1;
-var http = require$$3;
-var https = require$$4;
-var parseUrl = require$$5.parse;
-var fs = require$$6;
-var Stream = require$$0$1.Stream;
-var mime = mimeTypes;
-var asynckit = asynckit$1;
-var populate = populate$1;
-
-// Public API
-var form_data = 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);
-  }
+	  // https://github.com/felixge/node-form-data/issues/38
+	  if (Array.isArray(value)) {
+	    // Please convert your array into string
+	    // the way web server expects it
+	    this._error(new Error('Arrays are not supported.'));
+	    return;
+	  }
 
-  this._overheadLength = 0;
-  this._valueLength = 0;
-  this._valuesToMeasure = [];
+	  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);
+	  }
 
-  CombinedStream.call(this);
+	  this._valueLength += valueLength;
 
-  options = options || {};
-  for (var option in options) {
-    this[option] = options[option];
-  }
-}
+	  // @check why add CRLF? does this account for custom/multiple CRLFs?
+	  this._overheadLength +=
+	    Buffer.byteLength(header) +
+	    FormData.LINE_BREAK.length;
 
-FormData.LINE_BREAK = '\r\n';
-FormData.DEFAULT_CONTENT_TYPE = 'application/octet-stream';
+	  // empty or either doesn't have path or not an http response or not a stream
+	  if (!value || ( !value.path && !(value.readable && value.hasOwnProperty('httpVersion')) && !(value instanceof Stream))) {
+	    return;
+	  }
 
-FormData.prototype.append = function(field, value, options) {
+	  // no need to bother with the length
+	  if (!options.knownLength) {
+	    this._valuesToMeasure.push(value);
+	  }
+	};
 
-  options = options || {};
+	FormData.prototype._lengthRetriever = function(value, callback) {
 
-  // allow filename as single option
-  if (typeof options == 'string') {
-    options = {filename: options};
-  }
+	  if (value.hasOwnProperty('fd')) {
 
-  var append = CombinedStream.prototype.append.bind(this);
+	    // 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) {
 
-  // all that streamy business can't handle numbers
-  if (typeof value == 'number') {
-    value = '' + value;
-  }
+	      // when end specified
+	      // no need to calculate range
+	      // inclusive, starts with 0
+	      callback(null, value.end + 1 - (value.start ? value.start : 0));
 
-  // 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;
-  }
+	    // not that fast snoopy
+	    } else {
+	      // still need to fetch file size from fs
+	      fs.stat(value.path, function(err, stat) {
 
-  var header = this._multiPartHeader(field, value, options);
-  var footer = this._multiPartFooter();
+	        var fileSize;
 
-  append(header);
-  append(value);
-  append(footer);
+	        if (err) {
+	          callback(err);
+	          return;
+	        }
 
-  // pass along options.knownLength
-  this._trackLength(header, value, options);
-};
+	        // update final size based on the range options
+	        fileSize = stat.size - (value.start ? value.start : 0);
+	        callback(null, fileSize);
+	      });
+	    }
 
-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 or not a stream
-  if (!value || ( !value.path && !(value.readable && value.hasOwnProperty('httpVersion')) && !(value instanceof Stream))) {
-    return;
-  }
+	  // 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;
+	  }
 
-  // no need to bother with the length
-  if (!options.knownLength) {
-    this._valuesToMeasure.push(value);
-  }
-};
+	  var contentDisposition = this._getContentDisposition(value, options);
+	  var contentType = this._getContentType(value, options);
 
-FormData.prototype._lengthRetriever = function(value, callback) {
+	  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 || [])
+	  };
 
-  if (value.hasOwnProperty('fd')) {
+	  // allow custom headers.
+	  if (typeof options.header == 'object') {
+	    populate(headers, options.header);
+	  }
 
-    // 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) {
+	  var header;
+	  for (var prop in headers) {
+	    if (!headers.hasOwnProperty(prop)) continue;
+	    header = headers[prop];
 
-      // when end specified
-      // no need to calculate range
-      // inclusive, starts with 0
-      callback(null, value.end + 1 - (value.start ? value.start : 0));
+	    // skip nullish headers.
+	    if (header == null) {
+	      continue;
+	    }
 
-    // not that fast snoopy
-    } else {
-      // still need to fetch file size from fs
-      fs.stat(value.path, function(err, stat) {
+	    // convert all headers to arrays.
+	    if (!Array.isArray(header)) {
+	      header = [header];
+	    }
 
-        var fileSize;
+	    // add non-empty headers.
+	    if (header.length) {
+	      contents += prop + ': ' + header.join('; ') + FormData.LINE_BREAK;
+	    }
+	  }
 
-        if (err) {
-          callback(err);
-          return;
-        }
+	  return '--' + this.getBoundary() + FormData.LINE_BREAK + contents + FormData.LINE_BREAK;
+	};
+
+	FormData.prototype._getContentDisposition = function(value, options) {
+
+	  var filename
+	    , contentDisposition
+	    ;
+
+	  if (typeof options.filepath === 'string') {
+	    // custom filepath for relative paths
+	    filename = path.normalize(options.filepath).replace(/\\/g, '/');
+	  } else if (options.filename || value.name || value.path) {
+	    // custom filename take precedence
+	    // formidable and the browser add a name property
+	    // fs- and request- streams have path property
+	    filename = path.basename(options.filename || value.name || value.path);
+	  } else if (value.readable && value.hasOwnProperty('httpVersion')) {
+	    // or try http response
+	    filename = path.basename(value.client._httpMessage.path || '');
+	  }
 
-        // update final size based on the range options
-        fileSize = stat.size - (value.start ? value.start : 0);
-        callback(null, fileSize);
-      });
-    }
+	  if (filename) {
+	    contentDisposition = 'filename="' + filename + '"';
+	  }
 
-  // or http response
-  } else if (value.hasOwnProperty('httpVersion')) {
-    callback(null, +value.headers['content-length']);
+	  return contentDisposition;
+	};
 
-  // 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();
+	FormData.prototype._getContentType = function(value, options) {
 
-  // something else
-  } else {
-    callback('Unknown stream');
-  }
-};
+	  // use custom content-type above all
+	  var contentType = options.contentType;
 
-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;
-    }
+	  // or try `name` from formidable, browser
+	  if (!contentType && value.name) {
+	    contentType = mime.lookup(value.name);
+	  }
 
-    // convert all headers to arrays.
-    if (!Array.isArray(header)) {
-      header = [header];
-    }
+	  // or try `path` from fs-, request- streams
+	  if (!contentType && value.path) {
+	    contentType = mime.lookup(value.path);
+	  }
 
-    // add non-empty headers.
-    if (header.length) {
-      contents += prop + ': ' + header.join('; ') + FormData.LINE_BREAK;
-    }
-  }
+	  // or if it's http-reponse
+	  if (!contentType && value.readable && value.hasOwnProperty('httpVersion')) {
+	    contentType = value.headers['content-type'];
+	  }
 
-  return '--' + this.getBoundary() + FormData.LINE_BREAK + contents + FormData.LINE_BREAK;
-};
+	  // or guess it from the filepath or filename
+	  if (!contentType && (options.filepath || options.filename)) {
+	    contentType = mime.lookup(options.filepath || options.filename);
+	  }
 
-FormData.prototype._getContentDisposition = function(value, options) {
-
-  var filename
-    , contentDisposition
-    ;
-
-  if (typeof options.filepath === 'string') {
-    // custom filepath for relative paths
-    filename = path.normalize(options.filepath).replace(/\\/g, '/');
-  } else if (options.filename || value.name || value.path) {
-    // custom filename take precedence
-    // formidable and the browser add a name property
-    // fs- and request- streams have path property
-    filename = path.basename(options.filename || value.name || value.path);
-  } else if (value.readable && value.hasOwnProperty('httpVersion')) {
-    // or try http response
-    filename = path.basename(value.client._httpMessage.path || '');
-  }
-
-  if (filename) {
-    contentDisposition = 'filename="' + filename + '"';
-  }
-
-  return contentDisposition;
-};
+	  // fallback to the default content type if `value` is not simple value
+	  if (!contentType && typeof value == 'object') {
+	    contentType = FormData.DEFAULT_CONTENT_TYPE;
+	  }
 
-FormData.prototype._getContentType = function(value, options) {
+	  return contentType;
+	};
 
-  // use custom content-type above all
-  var contentType = options.contentType;
+	FormData.prototype._multiPartFooter = function() {
+	  return function(next) {
+	    var footer = FormData.LINE_BREAK;
 
-  // or try `name` from formidable, browser
-  if (!contentType && value.name) {
-    contentType = mime.lookup(value.name);
-  }
+	    var lastPart = (this._streams.length === 0);
+	    if (lastPart) {
+	      footer += this._lastBoundary();
+	    }
 
-  // or try `path` from fs-, request- streams
-  if (!contentType && value.path) {
-    contentType = mime.lookup(value.path);
-  }
+	    next(footer);
+	  }.bind(this);
+	};
 
-  // or if it's http-reponse
-  if (!contentType && value.readable && value.hasOwnProperty('httpVersion')) {
-    contentType = value.headers['content-type'];
-  }
+	FormData.prototype._lastBoundary = function() {
+	  return '--' + this.getBoundary() + '--' + FormData.LINE_BREAK;
+	};
 
-  // or guess it from the filepath or filename
-  if (!contentType && (options.filepath || options.filename)) {
-    contentType = mime.lookup(options.filepath || options.filename);
-  }
+	FormData.prototype.getHeaders = function(userHeaders) {
+	  var header;
+	  var formHeaders = {
+	    'content-type': 'multipart/form-data; boundary=' + this.getBoundary()
+	  };
 
-  // fallback to the default content type if `value` is not simple value
-  if (!contentType && typeof value == 'object') {
-    contentType = FormData.DEFAULT_CONTENT_TYPE;
-  }
+	  for (header in userHeaders) {
+	    if (userHeaders.hasOwnProperty(header)) {
+	      formHeaders[header.toLowerCase()] = userHeaders[header];
+	    }
+	  }
 
-  return contentType;
-};
+	  return formHeaders;
+	};
 
-FormData.prototype._multiPartFooter = function() {
-  return function(next) {
-    var footer = FormData.LINE_BREAK;
+	FormData.prototype.setBoundary = function(boundary) {
+	  this._boundary = boundary;
+	};
 
-    var lastPart = (this._streams.length === 0);
-    if (lastPart) {
-      footer += this._lastBoundary();
-    }
+	FormData.prototype.getBoundary = function() {
+	  if (!this._boundary) {
+	    this._generateBoundary();
+	  }
 
-    next(footer);
-  }.bind(this);
-};
+	  return this._boundary;
+	};
 
-FormData.prototype._lastBoundary = function() {
-  return '--' + this.getBoundary() + '--' + FormData.LINE_BREAK;
-};
+	FormData.prototype.getBuffer = function() {
+	  var dataBuffer = new Buffer.alloc( 0 );
+	  var boundary = this.getBoundary();
 
-FormData.prototype.getHeaders = function(userHeaders) {
-  var header;
-  var formHeaders = {
-    'content-type': 'multipart/form-data; 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') {
 
-  for (header in userHeaders) {
-    if (userHeaders.hasOwnProperty(header)) {
-      formHeaders[header.toLowerCase()] = userHeaders[header];
-    }
-  }
+	      // 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])]);
+	      }
 
-  return formHeaders;
-};
+	      // 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)] );
+	      }
+	    }
+	  }
 
-FormData.prototype.setBoundary = function(boundary) {
-  this._boundary = boundary;
-};
+	  // Add the footer and return the Buffer object.
+	  return Buffer.concat( [dataBuffer, Buffer.from(this._lastBoundary())] );
+	};
 
-FormData.prototype.getBoundary = function() {
-  if (!this._boundary) {
-    this._generateBoundary();
-  }
+	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);
+	  }
 
-  return this._boundary;
-};
+	  this._boundary = 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)] );
-      }
-    }
-  }
+	// 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;
 
-  // Add the footer and return the Buffer object.
-  return Buffer.concat( [dataBuffer, Buffer.from(this._lastBoundary())] );
-};
+	  // 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;
+	  }
 
-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);
-  }
+	  // 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.'));
+	  }
 
-  this._boundary = boundary;
-};
+	  return knownLength;
+	};
 
-// 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;
 
-// 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;
+	  }
 
-  if (this._valuesToMeasure.length) {
-    hasKnownLength = false;
-  }
+	  return hasKnownLength;
+	};
 
-  return hasKnownLength;
-};
+	FormData.prototype.getLength = function(cb) {
+	  var knownLength = this._overheadLength + this._valueLength;
 
-FormData.prototype.getLength = function(cb) {
-  var knownLength = this._overheadLength + this._valueLength;
+	  if (this._streams.length) {
+	    knownLength += this._lastBoundary().length;
+	  }
 
-  if (this._streams.length) {
-    knownLength += this._lastBoundary().length;
-  }
+	  if (!this._valuesToMeasure.length) {
+	    process.nextTick(cb.bind(this, null, knownLength));
+	    return;
+	  }
 
-  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;
+	    }
 
-  asynckit.parallel(this._valuesToMeasure, this._lengthRetriever, function(err, values) {
-    if (err) {
-      cb(err);
-      return;
-    }
+	    values.forEach(function(length) {
+	      knownLength += length;
+	    });
 
-    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;
+	    }
+	  }
 
-    cb(null, knownLength);
-  });
-};
+	  // put that good code in getHeaders to some use
+	  options.headers = this.getHeaders(params.headers);
 
-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 && err !== 'Unknown stream') {
-      this._error(err);
-      return;
-    }
+	  // https if specified, fallback to http in any other case
+	  if (options.protocol == 'https:') {
+	    request = https.request(options);
+	  } else {
+	    request = http.request(options);
+	  }
 
-    // add content length
-    if (length) {
-      request.setHeader('Content-Length', length);
-    }
+	  // get content length and fire away
+	  this.getLength(function(err, length) {
+	    if (err && err !== 'Unknown stream') {
+	      this._error(err);
+	      return;
+	    }
 
-    this.pipe(request);
-    if (cb) {
-      var onResponse;
+	    // add content length
+	    if (length) {
+	      request.setHeader('Content-Length', length);
+	    }
 
-      var callback = function (error, responce) {
-        request.removeListener('error', callback);
-        request.removeListener('response', onResponse);
+	    this.pipe(request);
+	    if (cb) {
+	      var onResponse;
 
-        return cb.call(this, error, responce);
-      };
+	      var callback = function (error, responce) {
+	        request.removeListener('error', callback);
+	        request.removeListener('response', onResponse);
 
-      onResponse = callback.bind(this, null);
+	        return cb.call(this, error, responce);
+	      };
 
-      request.on('error', callback);
-      request.on('response', onResponse);
-    }
-  }.bind(this));
+	      onResponse = callback.bind(this, null);
 
-  return request;
-};
+	      request.on('error', callback);
+	      request.on('response', onResponse);
+	    }
+	  }.bind(this));
 
-FormData.prototype._error = function(err) {
-  if (!this.error) {
-    this.error = err;
-    this.pause();
-    this.emit('error', err);
-  }
-};
+	  return request;
+	};
 
-FormData.prototype.toString = function () {
-  return '[object FormData]';
-};
+	FormData.prototype._error = function(err) {
+	  if (!this.error) {
+	    this.error = err;
+	    this.pause();
+	    this.emit('error', err);
+	  }
+	};
+
+	FormData.prototype.toString = function () {
+	  return '[object FormData]';
+	};
+	return form_data;
+}
 
-var FormDataModule = /*@__PURE__*/getDefaultExportFromCjs(form_data);
+var form_dataExports = requireForm_data();
+var FormDataModule = /*@__PURE__*/getDefaultExportFromCjs(form_dataExports);
 
 const GRANT_TYPE$1 = 'client_credentials';
 const castClientOptionsToRequestParams = (clientOptions) => {