prettier 0.15.1 → 0.16.0

data/node_modules/prettier/third-party.js

@@ -1,5 +1,7 @@
 'use strict';
 
+Object.defineProperty(exports, '__esModule', { value: true });
+
 function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
 
 var os = _interopDefault(require('os'));
@@ -31,199 +33,119 @@ function _createClass(Constructor, protoProps, staticProps) {
   return Constructor;
 }
 
-function _toArray(arr) {
-  return _arrayWithHoles(arr) || _iterableToArray(arr) || _nonIterableRest();
-}
-
-function _arrayWithHoles(arr) {
-  if (Array.isArray(arr)) return arr;
-}
-
-function _iterableToArray(iter) {
-  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
-}
-
-function _nonIterableRest() {
-  throw new TypeError("Invalid attempt to destructure non-iterable instance");
-}
-
-function _toPrimitive(input, hint) {
-  if (typeof input !== "object" || input === null) return input;
-  var prim = input[Symbol.toPrimitive];
-
-  if (prim !== undefined) {
-    var res = prim.call(input, hint || "default");
-    if (typeof res !== "object") return res;
-    throw new TypeError("@@toPrimitive must return a primitive value.");
-  }
-
-  return (hint === "string" ? String : Number)(input);
-}
-
-function _toPropertyKey(arg) {
-  var key = _toPrimitive(arg, "string");
-
-  return typeof key === "symbol" ? key : String(key);
-}
-
-function _addElementPlacement(element, placements, silent) {
-  var keys = placements[element.placement];
-
-  if (!silent && keys.indexOf(element.key) !== -1) {
-    throw new TypeError("Duplicated element (" + element.key + ")");
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
   }
 
-  keys.push(element.key);
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) _setPrototypeOf(subClass, superClass);
 }
 
-function _fromElementDescriptor(element) {
-  var obj = {
-    kind: element.kind,
-    key: element.key,
-    placement: element.placement,
-    descriptor: element.descriptor
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
   };
-  var desc = {
-    value: "Descriptor",
-    configurable: true
-  };
-  Object.defineProperty(obj, Symbol.toStringTag, desc);
-  if (element.kind === "field") obj.initializer = element.initializer;
-  return obj;
+  return _getPrototypeOf(o);
 }
 
-function _toElementDescriptors(elementObjects) {
-  if (elementObjects === undefined) return;
-  return _toArray(elementObjects).map(function (elementObject) {
-    var element = _toElementDescriptor(elementObject);
-
-    _disallowProperty(elementObject, "finisher", "An element descriptor");
-
-    _disallowProperty(elementObject, "extras", "An element descriptor");
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
 
-    return element;
-  });
+  return _setPrototypeOf(o, p);
 }
 
-function _toElementDescriptor(elementObject) {
-  var kind = String(elementObject.kind);
+function isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
 
-  if (kind !== "method" && kind !== "field") {
-    throw new TypeError('An element descriptor\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"');
-  }
-
-  var key = _toPropertyKey(elementObject.key);
-
-  var placement = String(elementObject.placement);
-
-  if (placement !== "static" && placement !== "prototype" && placement !== "own") {
-    throw new TypeError('An element descriptor\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"');
+  try {
+    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
   }
+}
 
-  var descriptor = elementObject.descriptor;
-
-  _disallowProperty(elementObject, "elements", "An element descriptor");
-
-  var element = {
-    kind: kind,
-    key: key,
-    placement: placement,
-    descriptor: Object.assign({}, descriptor)
-  };
-
-  if (kind !== "field") {
-    _disallowProperty(elementObject, "initializer", "A method descriptor");
+function _construct(Parent, args, Class) {
+  if (isNativeReflectConstruct()) {
+    _construct = Reflect.construct;
   } else {
-    _disallowProperty(descriptor, "get", "The property descriptor of a field descriptor");
-
-    _disallowProperty(descriptor, "set", "The property descriptor of a field descriptor");
-
-    _disallowProperty(descriptor, "value", "The property descriptor of a field descriptor");
-
-    element.initializer = elementObject.initializer;
+    _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Function.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) _setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
   }
 
-  return element;
+  return _construct.apply(null, arguments);
 }
 
-function _toElementFinisherExtras(elementObject) {
-  var element = _toElementDescriptor(elementObject);
-
-  var finisher = _optionalCallableProperty(elementObject, "finisher");
-
-  var extras = _toElementDescriptors(elementObject.extras);
-
-  return {
-    element: element,
-    finisher: finisher,
-    extras: extras
-  };
+function _isNativeFunction(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
 }
 
-function _fromClassDescriptor(elements) {
-  var obj = {
-    kind: "class",
-    elements: elements.map(_fromElementDescriptor)
-  };
-  var desc = {
-    value: "Descriptor",
-    configurable: true
-  };
-  Object.defineProperty(obj, Symbol.toStringTag, desc);
-  return obj;
-}
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : undefined;
 
-function _toClassDescriptor(obj) {
-  var kind = String(obj.kind);
+  _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (Class === null || !_isNativeFunction(Class)) return Class;
 
-  if (kind !== "class") {
-    throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"');
-  }
-
-  _disallowProperty(obj, "key", "A class descriptor");
-
-  _disallowProperty(obj, "placement", "A class descriptor");
-
-  _disallowProperty(obj, "descriptor", "A class descriptor");
-
-  _disallowProperty(obj, "initializer", "A class descriptor");
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
 
-  _disallowProperty(obj, "extras", "A class descriptor");
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
 
-  var finisher = _optionalCallableProperty(obj, "finisher");
+      _cache.set(Class, Wrapper);
+    }
 
-  var elements = _toElementDescriptors(obj.elements);
+    function Wrapper() {
+      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+    }
 
-  return {
-    elements: elements,
-    finisher: finisher
+    Wrapper.prototype = Object.create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _setPrototypeOf(Wrapper, Class);
   };
-}
 
-function _disallowProperty(obj, name, objectType) {
-  if (obj[name] !== undefined) {
-    throw new TypeError(objectType + " can't have a ." + name + " property.");
-  }
+  return _wrapNativeSuper(Class);
 }
 
-function _optionalCallableProperty(obj, name) {
-  var value = obj[name];
-
-  if (value !== undefined && typeof value !== "function") {
-    throw new TypeError("Expected '" + name + "' to be a function");
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
   }
 
-  return value;
-}
-
-function commonjsRequire () {
-	throw new Error('Dynamic requires are not currently supported by rollup-plugin-commonjs');
+  return self;
 }
 
+function _possibleConstructorReturn(self, call) {
+  if (call && (typeof call === "object" || typeof call === "function")) {
+    return call;
+  }
 
-
-function createCommonjsModule(fn, module) {
-	return module = { exports: {} }, fn(module, module.exports), module.exports;
+  return _assertThisInitialized(self);
 }
 
 var isArrayish = function isArrayish(obj) {
@@ -364,9 +286,9 @@ errorEx.line = function (str, def) {
 
 var errorEx_1 = errorEx;
 
-var jsonParseBetterErrors = parseJson$2;
+var jsonParseBetterErrors = parseJson;
 
-function parseJson$2(txt, reviver, context) {
+function parseJson(txt, reviver, context) {
   context = context || 20;
 
   try {
@@ -393,38 +315,34 @@ function parseJson$2(txt, reviver, context) {
   }
 }
 
-var parseJson = createCommonjsModule(function (module) {
-  'use strict';
-
-  var JSONError = errorEx_1('JSONError', {
-    fileName: errorEx_1.append('in %s')
-  });
+var JSONError = errorEx_1('JSONError', {
+  fileName: errorEx_1.append('in %s')
+});
 
-  module.exports = function (input, reviver, filename) {
-    if (typeof reviver === 'string') {
-      filename = reviver;
-      reviver = null;
-    }
+var parseJson$1 = function parseJson(input, reviver, filename) {
+  if (typeof reviver === 'string') {
+    filename = reviver;
+    reviver = null;
+  }
 
+  try {
     try {
-      try {
-        return JSON.parse(input, reviver);
-      } catch (err) {
-        jsonParseBetterErrors(input, reviver);
-        throw err;
-      }
+      return JSON.parse(input, reviver);
     } catch (err) {
-      err.message = err.message.replace(/\n/g, '');
-      var jsonErr = new JSONError(err);
-
-      if (filename) {
-        jsonErr.fileName = filename;
-      }
+      jsonParseBetterErrors(input, reviver);
+      throw err;
+    }
+  } catch (err) {
+    err.message = err.message.replace(/\n/g, '');
+    var jsonErr = new JSONError(err);
 
-      throw jsonErr;
+    if (filename) {
+      jsonErr.fileName = filename;
     }
-  };
-});
+
+    throw jsonErr;
+  }
+};
 
 function isNothing(subject) {
   return typeof subject === 'undefined' || subject === null;
@@ -485,8 +403,8 @@ var common = {
 };
 
 // YAML error class. http://stackoverflow.com/questions/8458984
-//
-function YAMLException$1(reason, mark) {
+
+function YAMLException(reason, mark) {
   // Super constructor
   Error.call(this);
   this.name = 'YAMLException';
@@ -504,10 +422,10 @@ function YAMLException$1(reason, mark) {
 } // Inherit from Error
 
 
-YAMLException$1.prototype = Object.create(Error.prototype);
-YAMLException$1.prototype.constructor = YAMLException$1;
+YAMLException.prototype = Object.create(Error.prototype);
+YAMLException.prototype.constructor = YAMLException;
 
-YAMLException$1.prototype.toString = function toString(compact) {
+YAMLException.prototype.toString = function toString(compact) {
   var result = this.name + ': ';
   result += this.reason || '(unknown reason)';
 
@@ -518,7 +436,7 @@ YAMLException$1.prototype.toString = function toString(compact) {
   return result;
 };
 
-var exception = YAMLException$1;
+var exception = YAMLException;
 
 function Mark(name, buffer, position, line, column) {
   this.name = name;
@@ -603,7 +521,7 @@ function compileStyleAliases(map) {
   return result;
 }
 
-function Type$1(tag, options) {
+function Type(tag, options) {
   options = options || {};
   Object.keys(options).forEach(function (name) {
     if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
@@ -633,7 +551,7 @@ function Type$1(tag, options) {
   }
 }
 
-var type = Type$1;
+var type = Type;
 
 /*eslint-disable max-len*/
 
@@ -651,7 +569,7 @@ function compileList(schema, name, result) {
     });
     result.push(currentType);
   });
-  return result.filter(function (type$$1, index) {
+  return result.filter(function (type, index) {
     return exclude.indexOf(index) === -1;
   });
 }
@@ -668,8 +586,8 @@ function compileMap()
       index,
       length;
 
-  function collectType(type$$1) {
-    result[type$$1.kind][type$$1.tag] = result['fallback'][type$$1.tag] = type$$1;
+  function collectType(type) {
+    result[type.kind][type.tag] = result['fallback'][type.tag] = type;
   }
 
   for (index = 0, length = arguments.length; index < length; index += 1) {
@@ -679,12 +597,12 @@ function compileMap()
   return result;
 }
 
-function Schema$1(definition) {
+function Schema(definition) {
   this.include = definition.include || [];
   this.implicit = definition.implicit || [];
   this.explicit = definition.explicit || [];
-  this.implicit.forEach(function (type$$1) {
-    if (type$$1.loadKind && type$$1.loadKind !== 'scalar') {
+  this.implicit.forEach(function (type) {
+    if (type.loadKind && type.loadKind !== 'scalar') {
       throw new exception('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.');
     }
   });
@@ -693,14 +611,14 @@ function Schema$1(definition) {
   this.compiledTypeMap = compileMap(this.compiledImplicit, this.compiledExplicit);
 }
 
-Schema$1.DEFAULT = null;
+Schema.DEFAULT = null;
 
-Schema$1.create = function createSchema() {
+Schema.create = function createSchema() {
   var schemas, types;
 
   switch (arguments.length) {
     case 1:
-      schemas = Schema$1.DEFAULT;
+      schemas = Schema.DEFAULT;
       types = arguments[0];
       break;
 
@@ -717,24 +635,24 @@ Schema$1.create = function createSchema() {
   types = common.toArray(types);
 
   if (!schemas.every(function (schema) {
-    return schema instanceof Schema$1;
+    return schema instanceof Schema;
   })) {
     throw new exception('Specified list of super schemas (or a single Schema object) contains a non-Schema object.');
   }
 
-  if (!types.every(function (type$$1) {
-    return type$$1 instanceof type;
+  if (!types.every(function (type$1) {
+    return type$1 instanceof type;
   })) {
     throw new exception('Specified list of YAML types (or a single Type object) contains a non-Type object.');
   }
 
-  return new Schema$1({
+  return new Schema({
     include: schemas,
     explicit: types
   });
 };
 
-var schema = Schema$1;
+var schema = Schema;
 
 var str = new type('tag:yaml.org,2002:str', {
   kind: 'scalar',
@@ -1242,6 +1160,18 @@ var merge = new type('tag:yaml.org,2002:merge', {
   resolve: resolveYamlMerge
 });
 
+function commonjsRequire () {
+	throw new Error('Dynamic requires are not currently supported by rollup-plugin-commonjs');
+}
+
+function createCommonjsModule(fn, module) {
+	return module = { exports: {} }, fn(module, module.exports), module.exports;
+}
+
+function getCjsExportFromNamespace (n) {
+	return n && n['default'] || n;
+}
+
 /*eslint-disable no-bitwise*/
 
 
@@ -1376,7 +1306,7 @@ var binary = new type('tag:yaml.org,2002:binary', {
   represent: representYamlBinary
 });
 
-var _hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+var _hasOwnProperty = Object.prototype.hasOwnProperty;
 var _toString = Object.prototype.toString;
 
 function resolveYamlOmap(data) {
@@ -1395,7 +1325,7 @@ function resolveYamlOmap(data) {
     if (_toString.call(pair) !== '[object Object]') return false;
 
     for (pairKey in pair) {
-      if (_hasOwnProperty$1.call(pair, pairKey)) {
+      if (_hasOwnProperty.call(pair, pairKey)) {
         if (!pairHasKey) pairHasKey = true;else return false;
       }
     }
@@ -1465,7 +1395,7 @@ var pairs = new type('tag:yaml.org,2002:pairs', {
   construct: constructYamlPairs
 });
 
-var _hasOwnProperty$2 = Object.prototype.hasOwnProperty;
+var _hasOwnProperty$1 = Object.prototype.hasOwnProperty;
 
 function resolveYamlSet(data) {
   if (data === null) return true;
@@ -1473,7 +1403,7 @@ function resolveYamlSet(data) {
       object = data;
 
   for (key in object) {
-    if (_hasOwnProperty$2.call(object, key)) {
+    if (_hasOwnProperty$1.call(object, key)) {
       if (object[key] !== null) return false;
     }
   }
@@ -1485,7 +1415,7 @@ function constructYamlSet(data) {
   return data !== null ? data : {};
 }
 
-var set$1 = new type('tag:yaml.org,2002:set', {
+var set = new type('tag:yaml.org,2002:set', {
   kind: 'mapping',
   resolve: resolveYamlSet,
   construct: constructYamlSet
@@ -1494,7 +1424,7 @@ var set$1 = new type('tag:yaml.org,2002:set', {
 var default_safe = new schema({
   include: [core],
   implicit: [timestamp, merge],
-  explicit: [binary, omap, pairs, set$1]
+  explicit: [binary, omap, pairs, set]
 });
 
 function resolveJavascriptUndefined() {
@@ -1668,7 +1598,7 @@ var default_full = schema.DEFAULT = new schema({
 /*eslint-disable max-len,no-use-before-define*/
 
 
-var _hasOwnProperty = Object.prototype.hasOwnProperty;
+var _hasOwnProperty$2 = Object.prototype.hasOwnProperty;
 var CONTEXT_FLOW_IN = 1;
 var CONTEXT_FLOW_OUT = 2;
 var CONTEXT_BLOCK_IN = 3;
@@ -1935,7 +1865,7 @@ var directiveHandlers = {
       throwError(state, 'ill-formed tag handle (first argument) of the TAG directive');
     }
 
-    if (_hasOwnProperty.call(state.tagMap, handle)) {
+    if (_hasOwnProperty$2.call(state.tagMap, handle)) {
       throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
     }
 
@@ -1981,7 +1911,7 @@ function mergeMappings(state, destination, source, overridableKeys) {
   for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
     key = sourceKeys[index];
 
-    if (!_hasOwnProperty.call(destination, key)) {
+    if (!_hasOwnProperty$2.call(destination, key)) {
       destination[key] = source[key];
       overridableKeys[key] = true;
     }
@@ -2029,7 +1959,7 @@ function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valu
       mergeMappings(state, _result, valueNode, overridableKeys);
     }
   } else {
-    if (!state.json && !_hasOwnProperty.call(overridableKeys, keyNode) && _hasOwnProperty.call(_result, keyNode)) {
+    if (!state.json && !_hasOwnProperty$2.call(overridableKeys, keyNode) && _hasOwnProperty$2.call(_result, keyNode)) {
       state.line = startLine || state.line;
       state.position = startPos || state.position;
       throwError(state, 'duplicated mapping key');
@@ -2944,7 +2874,7 @@ function readTagProperty(state) {
 
   if (isVerbatim) {
     state.tag = tagName;
-  } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) {
+  } else if (_hasOwnProperty$2.call(state.tagMap, tagHandle)) {
     state.tag = state.tagMap[tagHandle] + tagName;
   } else if (tagHandle === '!') {
     state.tag = '!' + tagName;
@@ -3133,7 +3063,7 @@ function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact
           break;
         }
       }
-    } else if (_hasOwnProperty.call(state.typeMap[state.kind || 'fallback'], state.tag)) {
+    } else if (_hasOwnProperty$2.call(state.typeMap[state.kind || 'fallback'], state.tag)) {
       type = state.typeMap[state.kind || 'fallback'][state.tag];
 
       if (state.result !== null && type.kind !== state.kind) {
@@ -3227,7 +3157,7 @@ function readDocument(state) {
 
     if (ch !== 0) readLineBreak(state);
 
-    if (_hasOwnProperty.call(directiveHandlers, directiveName)) {
+    if (_hasOwnProperty$2.call(directiveHandlers, directiveName)) {
       directiveHandlers[directiveName](state, directiveName, directiveArgs);
     } else {
       throwWarning(state, 'unknown document directive "' + directiveName + '"');
@@ -3314,7 +3244,7 @@ function loadDocuments(input, options) {
   return state.documents;
 }
 
-function loadAll$1(input, iterator, options) {
+function loadAll(input, iterator, options) {
   var documents = loadDocuments(input, options),
       index,
       length;
@@ -3328,7 +3258,7 @@ function loadAll$1(input, iterator, options) {
   }
 }
 
-function load$1(input, options) {
+function load(input, options) {
   var documents = loadDocuments(input, options);
 
   if (documents.length === 0) {
@@ -3341,28 +3271,28 @@ function load$1(input, options) {
   throw new exception('expected a single document in the stream, but found more');
 }
 
-function safeLoadAll$1(input, output, options) {
+function safeLoadAll(input, output, options) {
   if (typeof output === 'function') {
-    loadAll$1(input, output, common.extend({
+    loadAll(input, output, common.extend({
       schema: default_safe
     }, options));
   } else {
-    return loadAll$1(input, common.extend({
+    return loadAll(input, common.extend({
       schema: default_safe
     }, options));
   }
 }
 
-function safeLoad$1(input, options) {
-  return load$1(input, common.extend({
+function safeLoad(input, options) {
+  return load(input, common.extend({
     schema: default_safe
   }, options));
 }
 
-var loadAll_1 = loadAll$1;
-var load_1 = load$1;
-var safeLoadAll_1 = safeLoadAll$1;
-var safeLoad_1 = safeLoad$1;
+var loadAll_1 = loadAll;
+var load_1 = load;
+var safeLoadAll_1 = safeLoadAll;
+var safeLoad_1 = safeLoad;
 var loader = {
   loadAll: loadAll_1,
   load: load_1,
@@ -3612,11 +3542,11 @@ function needIndentIndicator(string) {
   return leadingSpaceRe.test(string);
 }
 
-var STYLE_PLAIN = 1;
-var STYLE_SINGLE = 2;
-var STYLE_LITERAL = 3;
-var STYLE_FOLDED = 4;
-var STYLE_DOUBLE = 5; // Determines which scalar styles are possible and returns the preferred style.
+var STYLE_PLAIN = 1,
+    STYLE_SINGLE = 2,
+    STYLE_LITERAL = 3,
+    STYLE_FOLDED = 4,
+    STYLE_DOUBLE = 5; // Determines which scalar styles are possible and returns the preferred style.
 // lineWidth = -1 => no limit.
 // Pre-conditions: str.length > 0.
 // Post-conditions:
@@ -3738,7 +3668,7 @@ function writeScalar(state, string, level, iskey) {
         return '>' + blockHeader(string, state.indent) + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
 
       case STYLE_DOUBLE:
-        return '"' + escapeString(string, lineWidth) + '"';
+        return '"' + escapeString(string) + '"';
 
       default:
         throw new exception('impossible error: invalid scalar style');
@@ -4183,7 +4113,7 @@ function inspectNode(object, objects, duplicatesIndexes) {
   }
 }
 
-function dump$1(input, options) {
+function dump(input, options) {
   options = options || {};
   var state = new State$1(options);
   if (!state.noRefs) getDuplicateReferences(input, state);
@@ -4191,14 +4121,14 @@ function dump$1(input, options) {
   return '';
 }
 
-function safeDump$1(input, options) {
-  return dump$1(input, common.extend({
+function safeDump(input, options) {
+  return dump(input, common.extend({
     schema: default_safe
   }, options));
 }
 
-var dump_1 = dump$1;
-var safeDump_1 = safeDump$1;
+var dump_1 = dump;
+var safeDump_1 = safeDump;
 var dumper = {
   dump: dump_1,
   safeDump: safeDump_1
@@ -4210,20 +4140,20 @@ function deprecated(name) {
   };
 }
 
-var Type = type;
-var Schema = schema;
+var Type$1 = type;
+var Schema$1 = schema;
 var FAILSAFE_SCHEMA = failsafe;
 var JSON_SCHEMA = json;
 var CORE_SCHEMA = core;
 var DEFAULT_SAFE_SCHEMA = default_safe;
 var DEFAULT_FULL_SCHEMA = default_full;
-var load = loader.load;
-var loadAll = loader.loadAll;
-var safeLoad = loader.safeLoad;
-var safeLoadAll = loader.safeLoadAll;
-var dump = dumper.dump;
-var safeDump = dumper.safeDump;
-var YAMLException = exception; // Deprecated schema names from JS-YAML 2.0.x
+var load$1 = loader.load;
+var loadAll$1 = loader.loadAll;
+var safeLoad$1 = loader.safeLoad;
+var safeLoadAll$1 = loader.safeLoadAll;
+var dump$1 = dumper.dump;
+var safeDump$1 = dumper.safeDump;
+var YAMLException$1 = exception; // Deprecated schema names from JS-YAML 2.0.x
 
 var MINIMAL_SCHEMA = failsafe;
 var SAFE_SCHEMA = default_safe;
@@ -4233,21 +4163,21 @@ var scan = deprecated('scan');
 var parse = deprecated('parse');
 var compose = deprecated('compose');
 var addConstructor = deprecated('addConstructor');
-var jsYaml$2 = {
-  Type: Type,
-  Schema: Schema,
+var jsYaml = {
+  Type: Type$1,
+  Schema: Schema$1,
   FAILSAFE_SCHEMA: FAILSAFE_SCHEMA,
   JSON_SCHEMA: JSON_SCHEMA,
   CORE_SCHEMA: CORE_SCHEMA,
   DEFAULT_SAFE_SCHEMA: DEFAULT_SAFE_SCHEMA,
   DEFAULT_FULL_SCHEMA: DEFAULT_FULL_SCHEMA,
-  load: load,
-  loadAll: loadAll,
-  safeLoad: safeLoad,
-  safeLoadAll: safeLoadAll,
-  dump: dump,
-  safeDump: safeDump,
-  YAMLException: YAMLException,
+  load: load$1,
+  loadAll: loadAll$1,
+  safeLoad: safeLoad$1,
+  safeLoadAll: safeLoadAll$1,
+  dump: dump$1,
+  safeDump: safeDump$1,
+  YAMLException: YAMLException$1,
   MINIMAL_SCHEMA: MINIMAL_SCHEMA,
   SAFE_SCHEMA: SAFE_SCHEMA,
   DEFAULT_SCHEMA: DEFAULT_SCHEMA,
@@ -4257,117 +4187,102 @@ var jsYaml$2 = {
   addConstructor: addConstructor
 };
 
-var jsYaml = jsYaml$2;
-
-var resolveFrom_1 = createCommonjsModule(function (module) {
-  'use strict';
-
-  var resolveFrom = function resolveFrom(fromDir, moduleId, silent) {
-    if (typeof fromDir !== 'string') {
-      throw new TypeError(`Expected \`fromDir\` to be of type \`string\`, got \`${typeof fromDir}\``);
-    }
+var jsYaml$1 = jsYaml;
 
-    if (typeof moduleId !== 'string') {
-      throw new TypeError(`Expected \`moduleId\` to be of type \`string\`, got \`${typeof moduleId}\``);
-    }
+var resolveFrom = function resolveFrom(fromDir, moduleId, silent) {
+  if (typeof fromDir !== 'string') {
+    throw new TypeError(`Expected \`fromDir\` to be of type \`string\`, got \`${typeof fromDir}\``);
+  }
 
-    fromDir = path.resolve(fromDir);
-    var fromFile = path.join(fromDir, 'noop.js');
+  if (typeof moduleId !== 'string') {
+    throw new TypeError(`Expected \`moduleId\` to be of type \`string\`, got \`${typeof moduleId}\``);
+  }
 
-    var resolveFileName = function resolveFileName() {
-      return module$1._resolveFilename(moduleId, {
-        id: fromFile,
-        filename: fromFile,
-        paths: module$1._nodeModulePaths(fromDir)
-      });
-    };
+  fromDir = path.resolve(fromDir);
+  var fromFile = path.join(fromDir, 'noop.js');
 
-    if (silent) {
-      try {
-        return resolveFileName();
-      } catch (err) {
-        return null;
-      }
-    }
-
-    return resolveFileName();
+  var resolveFileName = function resolveFileName() {
+    return module$1._resolveFilename(moduleId, {
+      id: fromFile,
+      filename: fromFile,
+      paths: module$1._nodeModulePaths(fromDir)
+    });
   };
 
-  module.exports = function (fromDir, moduleId) {
-    return resolveFrom(fromDir, moduleId);
-  };
+  if (silent) {
+    try {
+      return resolveFileName();
+    } catch (err) {
+      return null;
+    }
+  }
 
-  module.exports.silent = function (fromDir, moduleId) {
-    return resolveFrom(fromDir, moduleId, true);
-  };
-});
+  return resolveFileName();
+};
 
-var callsites = createCommonjsModule(function (module) {
-  'use strict';
+var resolveFrom_1 = function resolveFrom_1(fromDir, moduleId) {
+  return resolveFrom(fromDir, moduleId);
+};
 
-  module.exports = function () {
-    var _ = Error.prepareStackTrace;
+var silent = function silent(fromDir, moduleId) {
+  return resolveFrom(fromDir, moduleId, true);
+};
+resolveFrom_1.silent = silent;
 
-    Error.prepareStackTrace = function (_, stack) {
-      return stack;
-    };
+var callsites = function callsites() {
+  var _ = Error.prepareStackTrace;
 
-    var stack = new Error().stack.slice(1);
-    Error.prepareStackTrace = _;
+  Error.prepareStackTrace = function (_, stack) {
     return stack;
   };
-});
 
-var callerCallsite = createCommonjsModule(function (module) {
-  'use strict';
+  var stack = new Error().stack.slice(1);
+  Error.prepareStackTrace = _;
+  return stack;
+};
 
-  module.exports = function () {
-    var c = callsites();
-    var caller;
+var callerCallsite = function callerCallsite() {
+  var c = callsites();
+  var caller;
 
-    for (var i = 0; i < c.length; i++) {
-      var hasReceiver = c[i].getTypeName() !== null;
+  for (var i = 0; i < c.length; i++) {
+    var hasReceiver = c[i].getTypeName() !== null;
 
-      if (hasReceiver) {
-        caller = i;
-        break;
-      }
+    if (hasReceiver) {
+      caller = i;
+      break;
     }
+  }
 
-    return c[caller];
-  };
-});
+  return c[caller];
+};
 
 var callerPath = function callerPath() {
   return callerCallsite().getFileName();
 };
 
-var importFresh = createCommonjsModule(function (module) {
-  'use strict';
-
-  module.exports = function (moduleId) {
-    if (typeof moduleId !== 'string') {
-      throw new TypeError('Expected a string');
-    }
+var importFresh = function importFresh(moduleId) {
+  if (typeof moduleId !== 'string') {
+    throw new TypeError('Expected a string');
+  }
 
-    var filePath = resolveFrom_1(path.dirname(callerPath()), moduleId); // Delete itself from module parent
+  var filePath = resolveFrom_1(path.dirname(callerPath()), moduleId); // Delete itself from module parent
 
-    if (require.cache[filePath] && require.cache[filePath].parent) {
-      var i = require.cache[filePath].parent.children.length;
+  if (require.cache[filePath] && require.cache[filePath].parent) {
+    var i = require.cache[filePath].parent.children.length;
 
-      while (i--) {
-        if (require.cache[filePath].parent.children[i].id === filePath) {
-          require.cache[filePath].parent.children.splice(i, 1);
-        }
+    while (i--) {
+      if (require.cache[filePath].parent.children[i].id === filePath) {
+        require.cache[filePath].parent.children.splice(i, 1);
       }
-    } // Delete module from cache
+    }
+  } // Delete module from cache
 
 
-    delete require.cache[filePath]; // Return fresh module
+  delete require.cache[filePath]; // Return fresh module
 
-    return require(filePath);
-  };
-});
+  return require(filePath);
+};
 
 function loadJs(filepath) {
   var result = importFresh(filepath);
@@ -4376,7 +4291,7 @@ function loadJs(filepath) {
 
 function loadJson(filepath, content) {
   try {
-    return parseJson(content);
+    return parseJson$1(content);
   } catch (err) {
     err.message = `JSON Error in ${filepath}:\n${err.message}`;
     throw err;
@@ -4384,7 +4299,7 @@ function loadJson(filepath, content) {
 }
 
 function loadYaml(filepath, content) {
-  return jsYaml.safeLoad(content, {
+  return jsYaml$1.safeLoad(content, {
     filename: filepath
   });
 }
@@ -4428,6 +4343,7 @@ readFile.sync = function readFileSync(filepath, options) {
 var readFile_1 = readFile;
 
 //      
+
 function cacheWrapper(cache, key, fn) {
   if (!cache) {
     return fn();
@@ -4523,6 +4439,29 @@ getDirectory.sync = function getDirectorySync(filepath) {
 
 var getDirectory_1 = getDirectory;
 
+//      
+// strings or arrays of strings. Property names that are found on the source
+// object are used directly (even if they include a period).
+// Nested property names that include periods, within a path, are only
+// understood in array paths.
+
+function getPropertyByPath(source, path) {
+  if (typeof path === 'string' && source.hasOwnProperty(path)) {
+    return source[path];
+  }
+
+  var parsedPath = typeof path === 'string' ? path.split('.') : path;
+  return parsedPath.reduce(function (previous, key) {
+    if (previous === undefined) {
+      return previous;
+    }
+
+    return previous[key];
+  }, source);
+}
+
+var getPropertyByPath_1 = getPropertyByPath;
+
 var MODE_SYNC = 'sync'; // An object value represents a config object.
 // null represents that the loader did not find anything relevant.
 // undefined represents that the loader found something relevant
@@ -4739,7 +4678,7 @@ function () {
     key: "loadPackageProp",
     value: function loadPackageProp(filepath, content) {
       var parsedContent = loaders.loadJson(filepath, content);
-      var packagePropValue = parsedContent[this.config.packageProp];
+      var packagePropValue = getPropertyByPath_1(parsedContent, this.config.packageProp);
       return packagePropValue || null;
     }
   }, {
@@ -4969,14 +4908,13 @@ function identity(x) {
   return x;
 }
 
-var findParentDir$1 = createCommonjsModule(function (module, exports) {
-  'use strict';
+var findParentDir = createCommonjsModule(function (module, exports) {
 
   var exists = fs.exists || path.exists,
       existsSync = fs.existsSync || path.existsSync;
 
-  function splitPath(path$$2) {
-    var parts = path$$2.split(/(\/|\\)/);
+  function splitPath(path) {
+    var parts = path.split(/(\/|\\)/);
     if (!parts.length) return parts; // when path starts with a slash, the first part is empty string
 
     return !parts[0].length ? parts.slice(1) : parts;
@@ -5006,278 +4944,565 @@ var findParentDir$1 = createCommonjsModule(function (module, exports) {
     return testDir(splitPath(currentFullPath));
   };
 });
+var findParentDir_1 = findParentDir.sync;
+
+// Returns a wrapper function that returns a wrapped callback
+// The wrapper function should do some stuff, and return a
+// presumably different callback function.
+// This makes sure that own properties are retained, so that
+// decorations and such are not lost along the way.
+var wrappy_1 = wrappy;
+
+function wrappy(fn, cb) {
+  if (fn && cb) return wrappy(fn)(cb);
+  if (typeof fn !== 'function') throw new TypeError('need wrapper function');
+  Object.keys(fn).forEach(function (k) {
+    wrapper[k] = fn[k];
+  });
+  return wrapper;
 
-var bufferStream = createCommonjsModule(function (module) {
-  'use strict';
+  function wrapper() {
+    var args = new Array(arguments.length);
 
-  var PassThrough = stream.PassThrough;
+    for (var i = 0; i < args.length; i++) {
+      args[i] = arguments[i];
+    }
 
-  module.exports = function (opts) {
-    opts = Object.assign({}, opts);
-    var array = opts.array;
-    var encoding = opts.encoding;
-    var buffer = encoding === 'buffer';
-    var objectMode = false;
+    var ret = fn.apply(this, args);
+    var cb = args[args.length - 1];
 
-    if (array) {
-      objectMode = !(encoding || buffer);
-    } else {
-      encoding = encoding || 'utf8';
+    if (typeof ret === 'function' && ret !== cb) {
+      Object.keys(cb).forEach(function (k) {
+        ret[k] = cb[k];
+      });
     }
 
-    if (buffer) {
-      encoding = null;
-    }
+    return ret;
+  }
+}
 
-    var len = 0;
-    var ret = [];
-    var stream$$1 = new PassThrough({
-      objectMode
-    });
+var once_1 = wrappy_1(once);
+var strict = wrappy_1(onceStrict);
+once.proto = once(function () {
+  Object.defineProperty(Function.prototype, 'once', {
+    value: function value() {
+      return once(this);
+    },
+    configurable: true
+  });
+  Object.defineProperty(Function.prototype, 'onceStrict', {
+    value: function value() {
+      return onceStrict(this);
+    },
+    configurable: true
+  });
+});
 
-    if (encoding) {
-      stream$$1.setEncoding(encoding);
-    }
+function once(fn) {
+  var f = function f() {
+    if (f.called) return f.value;
+    f.called = true;
+    return f.value = fn.apply(this, arguments);
+  };
+
+  f.called = false;
+  return f;
+}
 
-    stream$$1.on('data', function (chunk) {
-      ret.push(chunk);
+function onceStrict(fn) {
+  var f = function f() {
+    if (f.called) throw new Error(f.onceError);
+    f.called = true;
+    return f.value = fn.apply(this, arguments);
+  };
 
-      if (objectMode) {
-        len = ret.length;
-      } else {
-        len += chunk.length;
-      }
+  var name = fn.name || 'Function wrapped with `once`';
+  f.onceError = name + " shouldn't be called more than once";
+  f.called = false;
+  return f;
+}
+once_1.strict = strict;
+
+var noop = function noop() {};
+
+var isRequest = function isRequest(stream) {
+  return stream.setHeader && typeof stream.abort === 'function';
+};
+
+var isChildProcess = function isChildProcess(stream) {
+  return stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3;
+};
+
+var eos = function eos(stream, opts, callback) {
+  if (typeof opts === 'function') return eos(stream, null, opts);
+  if (!opts) opts = {};
+  callback = once_1(callback || noop);
+  var ws = stream._writableState;
+  var rs = stream._readableState;
+  var readable = opts.readable || opts.readable !== false && stream.readable;
+  var writable = opts.writable || opts.writable !== false && stream.writable;
+
+  var onlegacyfinish = function onlegacyfinish() {
+    if (!stream.writable) onfinish();
+  };
+
+  var onfinish = function onfinish() {
+    writable = false;
+    if (!readable) callback.call(stream);
+  };
+
+  var onend = function onend() {
+    readable = false;
+    if (!writable) callback.call(stream);
+  };
+
+  var onexit = function onexit(exitCode) {
+    callback.call(stream, exitCode ? new Error('exited with error code: ' + exitCode) : null);
+  };
+
+  var onerror = function onerror(err) {
+    callback.call(stream, err);
+  };
+
+  var onclose = function onclose() {
+    if (readable && !(rs && rs.ended)) return callback.call(stream, new Error('premature close'));
+    if (writable && !(ws && ws.ended)) return callback.call(stream, new Error('premature close'));
+  };
+
+  var onrequest = function onrequest() {
+    stream.req.on('finish', onfinish);
+  };
+
+  if (isRequest(stream)) {
+    stream.on('complete', onfinish);
+    stream.on('abort', onclose);
+    if (stream.req) onrequest();else stream.on('request', onrequest);
+  } else if (writable && !ws) {
+    // legacy streams
+    stream.on('end', onlegacyfinish);
+    stream.on('close', onlegacyfinish);
+  }
+
+  if (isChildProcess(stream)) stream.on('exit', onexit);
+  stream.on('end', onend);
+  stream.on('finish', onfinish);
+  if (opts.error !== false) stream.on('error', onerror);
+  stream.on('close', onclose);
+  return function () {
+    stream.removeListener('complete', onfinish);
+    stream.removeListener('abort', onclose);
+    stream.removeListener('request', onrequest);
+    if (stream.req) stream.req.removeListener('finish', onfinish);
+    stream.removeListener('end', onlegacyfinish);
+    stream.removeListener('close', onlegacyfinish);
+    stream.removeListener('finish', onfinish);
+    stream.removeListener('exit', onexit);
+    stream.removeListener('end', onend);
+    stream.removeListener('error', onerror);
+    stream.removeListener('close', onclose);
+  };
+};
+
+var endOfStream = eos;
+
+var noop$1 = function noop() {};
+
+var ancient = /^v?\.0/.test(process.version);
+
+var isFn = function isFn(fn) {
+  return typeof fn === 'function';
+};
+
+var isFS = function isFS(stream) {
+  if (!ancient) return false; // newer node version do not need to care about fs is a special way
+
+  if (!fs) return false; // browser
+
+  return (stream instanceof (fs.ReadStream || noop$1) || stream instanceof (fs.WriteStream || noop$1)) && isFn(stream.close);
+};
+
+var isRequest$1 = function isRequest(stream) {
+  return stream.setHeader && isFn(stream.abort);
+};
+
+var destroyer = function destroyer(stream, reading, writing, callback) {
+  callback = once_1(callback);
+  var closed = false;
+  stream.on('close', function () {
+    closed = true;
+  });
+  endOfStream(stream, {
+    readable: reading,
+    writable: writing
+  }, function (err) {
+    if (err) return callback(err);
+    closed = true;
+    callback();
+  });
+  var destroyed = false;
+  return function (err) {
+    if (closed) return;
+    if (destroyed) return;
+    destroyed = true;
+    if (isFS(stream)) return stream.close(noop$1); // use close for fs streams to avoid fd leaks
+
+    if (isRequest$1(stream)) return stream.abort(); // request.destroy just do .end - .abort is what we want
+
+    if (isFn(stream.destroy)) return stream.destroy();
+    callback(err || new Error('stream was destroyed'));
+  };
+};
+
+var call = function call(fn) {
+  fn();
+};
+
+var pipe = function pipe(from, to) {
+  return from.pipe(to);
+};
+
+var pump = function pump() {
+  var streams = Array.prototype.slice.call(arguments);
+  var callback = isFn(streams[streams.length - 1] || noop$1) && streams.pop() || noop$1;
+  if (Array.isArray(streams[0])) streams = streams[0];
+  if (streams.length < 2) throw new Error('pump requires two streams per minimum');
+  var error;
+  var destroys = streams.map(function (stream, i) {
+    var reading = i < streams.length - 1;
+    var writing = i > 0;
+    return destroyer(stream, reading, writing, function (err) {
+      if (!error) error = err;
+      if (err) destroys.forEach(call);
+      if (reading) return;
+      destroys.forEach(call);
+      callback(error);
     });
+  });
+  return streams.reduce(pipe);
+};
 
-    stream$$1.getBufferedValue = function () {
-      if (array) {
-        return ret;
-      }
+var pump_1 = pump;
 
-      return buffer ? Buffer.concat(ret, len) : ret.join('');
-    };
+var PassThrough = stream.PassThrough;
 
-    stream$$1.getBufferedLength = function () {
-      return len;
-    };
+var bufferStream = function bufferStream(options) {
+  options = Object.assign({}, options);
+  var _options = options,
+      array = _options.array;
+  var _options2 = options,
+      encoding = _options2.encoding;
+  var buffer = encoding === 'buffer';
+  var objectMode = false;
+
+  if (array) {
+    objectMode = !(encoding || buffer);
+  } else {
+    encoding = encoding || 'utf8';
+  }
+
+  if (buffer) {
+    encoding = null;
+  }
 
-    return stream$$1;
+  var len = 0;
+  var ret = [];
+  var stream = new PassThrough({
+    objectMode
+  });
+
+  if (encoding) {
+    stream.setEncoding(encoding);
+  }
+
+  stream.on('data', function (chunk) {
+    ret.push(chunk);
+
+    if (objectMode) {
+      len = ret.length;
+    } else {
+      len += chunk.length;
+    }
+  });
+
+  stream.getBufferedValue = function () {
+    if (array) {
+      return ret;
+    }
+
+    return buffer ? Buffer.concat(ret, len) : ret.join('');
   };
-});
 
-function getStream(inputStream, opts) {
+  stream.getBufferedLength = function () {
+    return len;
+  };
+
+  return stream;
+};
+
+var MaxBufferError =
+/*#__PURE__*/
+function (_Error) {
+  _inherits(MaxBufferError, _Error);
+
+  function MaxBufferError() {
+    var _this;
+
+    _classCallCheck(this, MaxBufferError);
+
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(MaxBufferError).call(this, 'maxBuffer exceeded'));
+    _this.name = 'MaxBufferError';
+    return _this;
+  }
+
+  return MaxBufferError;
+}(_wrapNativeSuper(Error));
+
+function getStream(inputStream, options) {
   if (!inputStream) {
     return Promise.reject(new Error('Expected a stream'));
   }
 
-  opts = Object.assign({
+  options = Object.assign({
     maxBuffer: Infinity
-  }, opts);
-  var maxBuffer = opts.maxBuffer;
-  var stream$$1;
-  var clean;
-  var p = new Promise(function (resolve, reject) {
-    var error = function error(err) {
-      if (err) {
-        // null check
-        err.bufferedData = stream$$1.getBufferedValue();
+  }, options);
+  var _options = options,
+      maxBuffer = _options.maxBuffer;
+  var stream;
+  return new Promise(function (resolve, reject) {
+    var rejectPromise = function rejectPromise(error) {
+      if (error) {
+        // A null check
+        error.bufferedData = stream.getBufferedValue();
       }
 
-      reject(err);
+      reject(error);
     };
 
-    stream$$1 = bufferStream(opts);
-    inputStream.once('error', error);
-    inputStream.pipe(stream$$1);
-    stream$$1.on('data', function () {
-      if (stream$$1.getBufferedLength() > maxBuffer) {
-        reject(new Error('maxBuffer exceeded'));
+    stream = pump_1(inputStream, bufferStream(options), function (error) {
+      if (error) {
+        rejectPromise(error);
+        return;
       }
-    });
-    stream$$1.once('error', error);
-    stream$$1.on('end', resolve);
 
-    clean = function clean() {
-      // some streams doesn't implement the `stream.Readable` interface correctly
-      if (inputStream.unpipe) {
-        inputStream.unpipe(stream$$1);
+      resolve();
+    });
+    stream.on('data', function () {
+      if (stream.getBufferedLength() > maxBuffer) {
+        rejectPromise(new MaxBufferError());
       }
-    };
-  });
-  p.then(clean, clean);
-  return p.then(function () {
-    return stream$$1.getBufferedValue();
+    });
+  }).then(function () {
+    return stream.getBufferedValue();
   });
 }
 
 var getStream_1 = getStream;
 
-var buffer = function buffer(stream$$1, opts) {
-  return getStream(stream$$1, Object.assign({}, opts, {
+var buffer = function buffer(stream, options) {
+  return getStream(stream, Object.assign({}, options, {
     encoding: 'buffer'
   }));
 };
 
-var array = function array(stream$$1, opts) {
-  return getStream(stream$$1, Object.assign({}, opts, {
+var array = function array(stream, options) {
+  return getStream(stream, Object.assign({}, options, {
     array: true
   }));
 };
 
+var MaxBufferError_1 = MaxBufferError;
 getStream_1.buffer = buffer;
 getStream_1.array = array;
-
-var vendors = [{
-  "name": "AppVeyor",
-  "constant": "APPVEYOR",
-  "env": "APPVEYOR",
-  "pr": "APPVEYOR_PULL_REQUEST_NUMBER"
-}, {
-  "name": "Azure Pipelines",
-  "constant": "AZURE_PIPELINES",
-  "env": "SYSTEM_TEAMFOUNDATIONCOLLECTIONURI",
-  "pr": "SYSTEM_PULLREQUEST_PULLREQUESTID"
-}, {
-  "name": "Bamboo",
-  "constant": "BAMBOO",
-  "env": "bamboo_planKey"
-}, {
-  "name": "Bitbucket Pipelines",
-  "constant": "BITBUCKET",
-  "env": "BITBUCKET_COMMIT",
-  "pr": "BITBUCKET_PR_ID"
-}, {
-  "name": "Bitrise",
-  "constant": "BITRISE",
-  "env": "BITRISE_IO",
-  "pr": "BITRISE_PULL_REQUEST"
-}, {
-  "name": "Buddy",
-  "constant": "BUDDY",
-  "env": "BUDDY_WORKSPACE_ID",
-  "pr": "BUDDY_EXECUTION_PULL_REQUEST_ID"
-}, {
-  "name": "Buildkite",
-  "constant": "BUILDKITE",
-  "env": "BUILDKITE",
-  "pr": {
-    "env": "BUILDKITE_PULL_REQUEST",
-    "ne": "false"
-  }
-}, {
-  "name": "CircleCI",
-  "constant": "CIRCLE",
-  "env": "CIRCLECI",
-  "pr": "CIRCLE_PULL_REQUEST"
-}, {
-  "name": "Cirrus CI",
-  "constant": "CIRRUS",
-  "env": "CIRRUS_CI",
-  "pr": "CIRRUS_PR"
-}, {
-  "name": "AWS CodeBuild",
-  "constant": "CODEBUILD",
-  "env": "CODEBUILD_BUILD_ARN"
-}, {
-  "name": "Codeship",
-  "constant": "CODESHIP",
-  "env": {
-    "CI_NAME": "codeship"
-  }
-}, {
-  "name": "Drone",
-  "constant": "DRONE",
-  "env": "DRONE",
-  "pr": {
-    "DRONE_BUILD_EVENT": "pull_request"
-  }
-}, {
-  "name": "dsari",
-  "constant": "DSARI",
-  "env": "DSARI"
-}, {
-  "name": "GitLab CI",
-  "constant": "GITLAB",
-  "env": "GITLAB_CI"
-}, {
-  "name": "GoCD",
-  "constant": "GOCD",
-  "env": "GO_PIPELINE_LABEL"
-}, {
-  "name": "Hudson",
-  "constant": "HUDSON",
-  "env": "HUDSON_URL"
-}, {
-  "name": "Jenkins",
-  "constant": "JENKINS",
-  "env": ["JENKINS_URL", "BUILD_ID"],
-  "pr": {
-    "any": ["ghprbPullId", "CHANGE_ID"]
-  }
-}, {
-  "name": "Magnum CI",
-  "constant": "MAGNUM",
-  "env": "MAGNUM"
-}, {
-  "name": "Netlify CI",
-  "constant": "NETLIFY",
-  "env": "NETLIFY_BUILD_BASE",
-  "pr": {
-    "env": "PULL_REQUEST",
-    "ne": "false"
-  }
-}, {
-  "name": "Sail CI",
-  "constant": "SAIL",
-  "env": "SAILCI",
-  "pr": "SAIL_PULL_REQUEST_NUMBER"
-}, {
-  "name": "Semaphore",
-  "constant": "SEMAPHORE",
-  "env": "SEMAPHORE",
-  "pr": "PULL_REQUEST_NUMBER"
-}, {
-  "name": "Shippable",
-  "constant": "SHIPPABLE",
-  "env": "SHIPPABLE",
-  "pr": {
-    "IS_PULL_REQUEST": "true"
-  }
-}, {
-  "name": "Solano CI",
-  "constant": "SOLANO",
-  "env": "TDDIUM",
-  "pr": "TDDIUM_PR_ID"
-}, {
-  "name": "Strider CD",
-  "constant": "STRIDER",
-  "env": "STRIDER"
-}, {
-  "name": "TaskCluster",
-  "constant": "TASKCLUSTER",
-  "env": ["TASK_ID", "RUN_ID"]
-}, {
-  "name": "TeamCity",
-  "constant": "TEAMCITY",
-  "env": "TEAMCITY_VERSION"
-}, {
-  "name": "Travis CI",
-  "constant": "TRAVIS",
-  "env": "TRAVIS",
-  "pr": {
-    "env": "TRAVIS_PULL_REQUEST",
-    "ne": "false"
-  }
-}];
-
-var vendors$1 = Object.freeze({
-	default: vendors
+getStream_1.MaxBufferError = MaxBufferError_1;
+
+var vendors = [
+	{
+		name: "AppVeyor",
+		constant: "APPVEYOR",
+		env: "APPVEYOR",
+		pr: "APPVEYOR_PULL_REQUEST_NUMBER"
+	},
+	{
+		name: "Azure Pipelines",
+		constant: "AZURE_PIPELINES",
+		env: "SYSTEM_TEAMFOUNDATIONCOLLECTIONURI",
+		pr: "SYSTEM_PULLREQUEST_PULLREQUESTID"
+	},
+	{
+		name: "Bamboo",
+		constant: "BAMBOO",
+		env: "bamboo_planKey"
+	},
+	{
+		name: "Bitbucket Pipelines",
+		constant: "BITBUCKET",
+		env: "BITBUCKET_COMMIT",
+		pr: "BITBUCKET_PR_ID"
+	},
+	{
+		name: "Bitrise",
+		constant: "BITRISE",
+		env: "BITRISE_IO",
+		pr: "BITRISE_PULL_REQUEST"
+	},
+	{
+		name: "Buddy",
+		constant: "BUDDY",
+		env: "BUDDY_WORKSPACE_ID",
+		pr: "BUDDY_EXECUTION_PULL_REQUEST_ID"
+	},
+	{
+		name: "Buildkite",
+		constant: "BUILDKITE",
+		env: "BUILDKITE",
+		pr: {
+			env: "BUILDKITE_PULL_REQUEST",
+			ne: "false"
+		}
+	},
+	{
+		name: "CircleCI",
+		constant: "CIRCLE",
+		env: "CIRCLECI",
+		pr: "CIRCLE_PULL_REQUEST"
+	},
+	{
+		name: "Cirrus CI",
+		constant: "CIRRUS",
+		env: "CIRRUS_CI",
+		pr: "CIRRUS_PR"
+	},
+	{
+		name: "AWS CodeBuild",
+		constant: "CODEBUILD",
+		env: "CODEBUILD_BUILD_ARN"
+	},
+	{
+		name: "Codeship",
+		constant: "CODESHIP",
+		env: {
+			CI_NAME: "codeship"
+		}
+	},
+	{
+		name: "Drone",
+		constant: "DRONE",
+		env: "DRONE",
+		pr: {
+			DRONE_BUILD_EVENT: "pull_request"
+		}
+	},
+	{
+		name: "dsari",
+		constant: "DSARI",
+		env: "DSARI"
+	},
+	{
+		name: "GitLab CI",
+		constant: "GITLAB",
+		env: "GITLAB_CI"
+	},
+	{
+		name: "GoCD",
+		constant: "GOCD",
+		env: "GO_PIPELINE_LABEL"
+	},
+	{
+		name: "Hudson",
+		constant: "HUDSON",
+		env: "HUDSON_URL"
+	},
+	{
+		name: "Jenkins",
+		constant: "JENKINS",
+		env: [
+			"JENKINS_URL",
+			"BUILD_ID"
+		],
+		pr: {
+			any: [
+				"ghprbPullId",
+				"CHANGE_ID"
+			]
+		}
+	},
+	{
+		name: "Magnum CI",
+		constant: "MAGNUM",
+		env: "MAGNUM"
+	},
+	{
+		name: "Netlify CI",
+		constant: "NETLIFY",
+		env: "NETLIFY_BUILD_BASE",
+		pr: {
+			env: "PULL_REQUEST",
+			ne: "false"
+		}
+	},
+	{
+		name: "Sail CI",
+		constant: "SAIL",
+		env: "SAILCI",
+		pr: "SAIL_PULL_REQUEST_NUMBER"
+	},
+	{
+		name: "Semaphore",
+		constant: "SEMAPHORE",
+		env: "SEMAPHORE",
+		pr: "PULL_REQUEST_NUMBER"
+	},
+	{
+		name: "Shippable",
+		constant: "SHIPPABLE",
+		env: "SHIPPABLE",
+		pr: {
+			IS_PULL_REQUEST: "true"
+		}
+	},
+	{
+		name: "Solano CI",
+		constant: "SOLANO",
+		env: "TDDIUM",
+		pr: "TDDIUM_PR_ID"
+	},
+	{
+		name: "Strider CD",
+		constant: "STRIDER",
+		env: "STRIDER"
+	},
+	{
+		name: "TaskCluster",
+		constant: "TASKCLUSTER",
+		env: [
+			"TASK_ID",
+			"RUN_ID"
+		]
+	},
+	{
+		name: "TeamCity",
+		constant: "TEAMCITY",
+		env: "TEAMCITY_VERSION"
+	},
+	{
+		name: "Travis CI",
+		constant: "TRAVIS",
+		env: "TRAVIS",
+		pr: {
+			env: "TRAVIS_PULL_REQUEST",
+			ne: "false"
+		}
+	}
+];
+
+var vendors$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  'default': vendors
 });
 
-var vendors$2 = ( vendors$1 && vendors ) || vendors$1;
+var vendors$2 = getCjsExportFromNamespace(vendors$1);
 
 var ciInfo = createCommonjsModule(function (module, exports) {
-  'use strict';
 
   var env = process.env; // Used for testing only
 
@@ -5339,19 +5564,27 @@ var ciInfo = createCommonjsModule(function (module, exports) {
     });
   }
 });
+var ciInfo_1 = ciInfo.name;
+var ciInfo_2 = ciInfo.isPR;
+var ciInfo_3 = ciInfo.isCI;
 
 var isCi = ciInfo.isCI;
 
-var findParentDir = findParentDir$1.sync;
 var thirdParty = {
   cosmiconfig: dist,
-  findParentDir,
+  findParentDir: findParentDir.sync,
   getStream: getStream_1,
-  isCI:
-  /* istanbul ignore next */
-  function isCI() {
+  isCI: function isCI() {
     return isCi;
   }
 };
-
-module.exports = thirdParty;
+var thirdParty_1 = thirdParty.cosmiconfig;
+var thirdParty_2 = thirdParty.findParentDir;
+var thirdParty_3 = thirdParty.getStream;
+var thirdParty_4 = thirdParty.isCI;
+
+exports.cosmiconfig = thirdParty_1;
+exports.default = thirdParty;
+exports.findParentDir = thirdParty_2;
+exports.getStream = thirdParty_3;
+exports.isCI = thirdParty_4;