prettier 1.14.3 → 1.15.3

package/third-party.js

@@ -6,6 +6,7 @@ var stream = _interopDefault(require('stream'));
 var os = _interopDefault(require('os'));
 var path = _interopDefault(require('path'));
 var util = _interopDefault(require('util'));
+var module$1 = _interopDefault(require('module'));
 var fs = _interopDefault(require('fs'));
 
 function commonjsRequire () {
@@ -160,6 +161,191 @@ 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 + ")");
+  }
+
+  keys.push(element.key);
+}
+
+function _fromElementDescriptor(element) {
+  var obj = {
+    kind: element.kind,
+    key: element.key,
+    placement: element.placement,
+    descriptor: element.descriptor
+  };
+  var desc = {
+    value: "Descriptor",
+    configurable: true
+  };
+  Object.defineProperty(obj, Symbol.toStringTag, desc);
+  if (element.kind === "field") obj.initializer = element.initializer;
+  return obj;
+}
+
+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");
+
+    return element;
+  });
+}
+
+function _toElementDescriptor(elementObject) {
+  var kind = String(elementObject.kind);
+
+  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 + '"');
+  }
+
+  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");
+  } 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;
+  }
+
+  return element;
+}
+
+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 _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 _toClassDescriptor(obj) {
+  var kind = String(obj.kind);
+
+  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");
+
+  _disallowProperty(obj, "extras", "A class descriptor");
+
+  var finisher = _optionalCallableProperty(obj, "finisher");
+
+  var elements = _toElementDescriptors(obj.elements);
+
+  return {
+    elements: elements,
+    finisher: finisher
+  };
+}
+
+function _disallowProperty(obj, name, objectType) {
+  if (obj[name] !== undefined) {
+    throw new TypeError(objectType + " can't have a ." + name + " property.");
+  }
+}
+
+function _optionalCallableProperty(obj, name) {
+  var value = obj[name];
+
+  if (value !== undefined && typeof value !== "function") {
+    throw new TypeError("Expected '" + name + "' to be a function");
+  }
+
+  return value;
+}
+
 var isArrayish = function isArrayish(obj) {
   if (!obj) {
     return false;
@@ -211,17 +397,25 @@ var errorEx = function errorEx(name, properties) {
         message = v;
       }
     });
+    var overwrittenStack = null;
     var stackDescriptor = Object.getOwnPropertyDescriptor(this, 'stack');
     var stackGetter = stackDescriptor.get;
     var stackValue = stackDescriptor.value;
     delete stackDescriptor.value;
     delete stackDescriptor.writable;
 
+    stackDescriptor.set = function (newstack) {
+      overwrittenStack = newstack;
+    };
+
     stackDescriptor.get = function () {
-      var stack = stackGetter ? stackGetter.call(this).split(/\r?\n+/g) : stackValue.split(/\r?\n+/g); // starting in Node 7, the stack builder caches the message.
+      var stack = (overwrittenStack || (stackGetter ? stackGetter.call(this) : stackValue)).split(/\r?\n+/g); // starting in Node 7, the stack builder caches the message.
       // just replace it.
 
-      stack[0] = this.name + ': ' + this.message;
+      if (!overwrittenStack) {
+        stack[0] = this.name + ': ' + this.message;
+      }
+
       var lineCount = 1;
 
       for (var key in properties) {
@@ -922,17 +1116,19 @@ var int_1 = new type('tag:yaml.org,2002:int', {
   construct: constructYamlInteger,
   predicate: isInteger,
   represent: {
-    binary: function binary(object) {
-      return '0b' + object.toString(2);
+    binary: function binary(obj) {
+      return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).slice(1);
     },
-    octal: function octal(object) {
-      return '0' + object.toString(8);
+    octal: function octal(obj) {
+      return obj >= 0 ? '0' + obj.toString(8) : '-0' + obj.toString(8).slice(1);
     },
-    decimal: function decimal(object) {
-      return object.toString(10);
+    decimal: function decimal(obj) {
+      return obj.toString(10);
     },
-    hexadecimal: function hexadecimal(object) {
-      return '0x' + object.toString(16).toUpperCase();
+
+    /* eslint-disable max-len */
+    hexadecimal: function hexadecimal(obj) {
+      return obj >= 0 ? '0x' + obj.toString(16).toUpperCase() : '-0x' + obj.toString(16).toUpperCase().slice(1);
     }
   },
   defaultStyle: 'decimal',
@@ -1525,7 +1721,7 @@ function resolveJavascriptFunction(data) {
       range: true
     });
 
-    if (ast.type !== 'Program' || ast.body.length !== 1 || ast.body[0].type !== 'ExpressionStatement' || ast.body[0].expression.type !== 'FunctionExpression') {
+    if (ast.type !== 'Program' || ast.body.length !== 1 || ast.body[0].type !== 'ExpressionStatement' || ast.body[0].expression.type !== 'ArrowFunctionExpression' && ast.body[0].expression.type !== 'FunctionExpression') {
       return false;
     }
 
@@ -1544,7 +1740,7 @@ function constructJavascriptFunction(data) {
       params = [],
       body;
 
-  if (ast.type !== 'Program' || ast.body.length !== 1 || ast.body[0].type !== 'ExpressionStatement' || ast.body[0].expression.type !== 'FunctionExpression') {
+  if (ast.type !== 'Program' || ast.body.length !== 1 || ast.body[0].type !== 'ExpressionStatement' || ast.body[0].expression.type !== 'ArrowFunctionExpression' && ast.body[0].expression.type !== 'FunctionExpression') {
     throw new Error('Failed to resolve function');
   }
 
@@ -1554,9 +1750,16 @@ function constructJavascriptFunction(data) {
   body = ast.body[0].expression.body.range; // Esprima's ranges include the first '{' and the last '}' characters on
   // function expressions. So cut them out.
 
+  if (ast.body[0].expression.body.type === 'BlockStatement') {
+    /*eslint-disable no-new-func*/
+    return new Function(params, source.slice(body[0] + 1, body[1] - 1));
+  } // ES6 arrow functions can omit the BlockStatement. In that case, just return
+  // the body.
+
   /*eslint-disable no-new-func*/
 
-  return new Function(params, source.slice(body[0] + 1, body[1] - 1));
+
+  return new Function(params, 'return ' + source.slice(body[0], body[1]));
 }
 
 function representJavascriptFunction(object
@@ -3492,6 +3695,12 @@ function isPlainSafeFirst(c) {
   && c !== CHAR_MINUS && c !== CHAR_QUESTION && c !== CHAR_COLON && c !== CHAR_COMMA && c !== CHAR_LEFT_SQUARE_BRACKET && c !== CHAR_RIGHT_SQUARE_BRACKET && c !== CHAR_LEFT_CURLY_BRACKET && c !== CHAR_RIGHT_CURLY_BRACKET // | “#” | “&” | “*” | “!” | “|” | “>” | “'” | “"”
   && c !== CHAR_SHARP && c !== CHAR_AMPERSAND && c !== CHAR_ASTERISK && c !== CHAR_EXCLAMATION && c !== CHAR_VERTICAL_LINE && c !== CHAR_GREATER_THAN && c !== CHAR_SINGLE_QUOTE && c !== CHAR_DOUBLE_QUOTE // | “%” | “@” | “`”)
   && c !== CHAR_PERCENT && c !== CHAR_COMMERCIAL_AT && c !== CHAR_GRAVE_ACCENT;
+} // Determines whether block indentation indicator is required.
+
+
+function needIndentIndicator(string) {
+  var leadingSpaceRe = /^\n* /;
+  return leadingSpaceRe.test(string);
 }
 
 var STYLE_PLAIN = 1;
@@ -3563,7 +3772,7 @@ function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, te
   } // Edge case: block indentation indicator can only have one digit.
 
 
-  if (string[0] === ' ' && indentPerLevel > 9) {
+  if (indentPerLevel > 9 && needIndentIndicator(string)) {
     return STYLE_DOUBLE;
   } // At this point we know block styles are valid.
   // Prefer literal style unless we want to fold.
@@ -3630,7 +3839,7 @@ function writeScalar(state, string, level, iskey) {
 
 
 function blockHeader(string, indentPerLevel) {
-  var indentIndicator = string[0] === ' ' ? String(indentPerLevel) : ''; // note the special case: the string '\n' counts as a "trailing" empty line.
+  var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : ''; // note the special case: the string '\n' counts as a "trailing" empty line.
 
   var clip = string[string.length - 1] === '\n';
   var keep = clip && (string[string.length - 2] === '\n' || string === '\n');
@@ -4139,9 +4348,118 @@ var jsYaml$2 = {
 
 var jsYaml = jsYaml$2;
 
-function loadJs(filepath) {
-  var result = require(filepath);
+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}\``);
+    }
+
+    if (typeof moduleId !== 'string') {
+      throw new TypeError(`Expected \`moduleId\` to be of type \`string\`, got \`${typeof moduleId}\``);
+    }
+
+    fromDir = path.resolve(fromDir);
+    var fromFile = path.join(fromDir, 'noop.js');
+
+    var resolveFileName = function resolveFileName() {
+      return module$1._resolveFilename(moduleId, {
+        id: fromFile,
+        filename: fromFile,
+        paths: module$1._nodeModulePaths(fromDir)
+      });
+    };
 
+    if (silent) {
+      try {
+        return resolveFileName();
+      } catch (err) {
+        return null;
+      }
+    }
+
+    return resolveFileName();
+  };
+
+  module.exports = function (fromDir, moduleId) {
+    return resolveFrom(fromDir, moduleId);
+  };
+
+  module.exports.silent = function (fromDir, moduleId) {
+    return resolveFrom(fromDir, moduleId, true);
+  };
+});
+
+var callsites = createCommonjsModule(function (module) {
+  'use strict';
+
+  module.exports = function () {
+    var _ = Error.prepareStackTrace;
+
+    Error.prepareStackTrace = function (_, stack) {
+      return stack;
+    };
+
+    var stack = new Error().stack.slice(1);
+    Error.prepareStackTrace = _;
+    return stack;
+  };
+});
+
+var callerCallsite = createCommonjsModule(function (module) {
+  'use strict';
+
+  module.exports = function () {
+    var c = callsites();
+    var caller;
+
+    for (var i = 0; i < c.length; i++) {
+      var hasReceiver = c[i].getTypeName() !== null;
+
+      if (hasReceiver) {
+        caller = i;
+        break;
+      }
+    }
+
+    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 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;
+
+      while (i--) {
+        if (require.cache[filePath].parent.children[i].id === filePath) {
+          require.cache[filePath].parent.children.splice(i, 1);
+        }
+      }
+    } // Delete module from cache
+
+
+    delete require.cache[filePath]; // Return fresh module
+
+    return require(filePath);
+  };
+});
+
+function loadJs(filepath) {
+  var result = importFresh(filepath);
   return result;
 }
 
@@ -4525,7 +4843,7 @@ function () {
       }
 
       var loaderKey = path.extname(filepath) || 'noExt';
-      return this.config.loaders[loaderKey];
+      return this.config.loaders[loaderKey] || {};
     }
   }, {
     key: "getSyncLoaderForFile",