prettier 2.0.4 → 2.0.5

package/bin-prettier.js

@@ -3,15 +3,15 @@
 
 function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
 
-var fs$2 = _interopDefault(require('fs'));
-var path$1 = _interopDefault(require('path'));
-var os = _interopDefault(require('os'));
-var tty = _interopDefault(require('tty'));
-var assert = _interopDefault(require('assert'));
-var util$3 = _interopDefault(require('util'));
-var stream$5 = _interopDefault(require('stream'));
-var events = _interopDefault(require('events'));
-var readline = _interopDefault(require('readline'));
+var fs$3 = _interopDefault(require('fs'));
+var path$2 = _interopDefault(require('path'));
+var os$1 = _interopDefault(require('os'));
+var tty$1 = _interopDefault(require('tty'));
+var assert$1 = _interopDefault(require('assert'));
+var util$4 = _interopDefault(require('util'));
+var stream$6 = _interopDefault(require('stream'));
+var events$1 = _interopDefault(require('events'));
+var readline$1 = _interopDefault(require('readline'));
 
 var semverCompare = function cmp(a, b) {
   var pa = a.split('.');
@@ -50,7 +50,7 @@ var pleaseUpgradeNode = function pleaseUpgradeNode(pkg, opts) {
 };
 
 var name = "prettier";
-var version = "2.0.4";
+var version = "2.0.5";
 var description = "Prettier is an opinionated code formatter";
 var bin = "./bin/prettier.js";
 var repository = "prettier/prettier";
@@ -112,6 +112,7 @@ var dependencies = {
 	"regexp-util": "1.2.2",
 	"remark-math": "1.0.6",
 	"remark-parse": "5.0.0",
+	resolve: "1.16.1",
 	semver: "7.1.3",
 	srcset: "2.0.1",
 	"string-width": "4.2.0",
@@ -147,7 +148,7 @@ var devDependencies = {
 	"jest-snapshot-serializer-ansi": "1.0.0",
 	"jest-snapshot-serializer-raw": "1.1.0",
 	"jest-watch-typeahead": "0.5.0",
-	prettier: "2.0.3",
+	prettier: "2.0.4",
 	rimraf: "3.0.2",
 	rollup: "2.3.2",
 	"rollup-plugin-babel": "4.4.0",
@@ -165,7 +166,8 @@ var scripts = {
 	prepublishOnly: "echo \"Error: must publish from dist/\" && exit 1",
 	"prepare-release": "yarn && yarn build && yarn test:dist",
 	test: "jest",
-	"test:dist": "node ./scripts/test-dist.js",
+	"test:dist": "cross-env NODE_ENV=production jest",
+	"test:dist-standalone": "cross-env NODE_ENV=production TEST_STANDALONE=1 jest tests/",
 	"test:integration": "jest tests_integration",
 	"perf:repeat": "yarn && yarn build && cross-env NODE_ENV=production node ./dist/bin-prettier.js --debug-repeat ${PERF_REPEAT:-1000} --loglevel debug ${PERF_FILE:-./index.js} > /dev/null",
 	"perf:repeat-inspect": "yarn && yarn build && cross-env NODE_ENV=production node --inspect-brk ./dist/bin-prettier.js --debug-repeat ${PERF_REPEAT:-1000} --loglevel debug ${PERF_FILE:-./index.js} > /dev/null",
@@ -1782,7 +1784,7 @@ class LineByLine {
     if (typeof file === 'number') {
       this.fd = file;
     } else {
-      this.fd = fs$2.openSync(file, 'r');
+      this.fd = fs$3.openSync(file, 'r');
     }
 
     this.options = options;
@@ -1812,7 +1814,7 @@ class LineByLine {
   }
 
   close() {
-    fs$2.closeSync(this.fd);
+    fs$3.closeSync(this.fd);
     this.fd = null;
   }
 
@@ -1850,7 +1852,7 @@ class LineByLine {
 
     do {
       const readBuffer = new Buffer(this.options.readChunk);
-      bytesRead = fs$2.readSync(this.fd, readBuffer, 0, this.options.readChunk, this.fdPosition);
+      bytesRead = fs$3.readSync(this.fd, readBuffer, 0, this.options.readChunk, this.fdPosition);
       totalBytesRead = totalBytesRead + bytesRead;
       this.fdPosition = this.fdPosition + bytesRead;
       buffers.push(readBuffer);
@@ -4827,7 +4829,7 @@ function supportsColor(stream) {
     // release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
     // release that supports 256 colors. Windows 10 build 14931 is the first release
     // that supports 16m/TrueColor.
-    const osRelease = os.release().split('.');
+    const osRelease = os$1.release().split('.');
 
     if (Number(process.versions.node.split('.')[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
       return Number(osRelease[2]) >= 14931 ? 3 : 2;
@@ -7754,7 +7756,7 @@ function supportsColor$1(haveStream, streamIsTTY) {
   if (process.platform === 'win32') {
     // Windows 10 build 10586 is the first Windows release that supports 256 colors.
     // Windows 10 build 14931 is the first release that supports 16m/TrueColor.
-    const osRelease = os.release().split('.');
+    const osRelease = os$1.release().split('.');
 
     if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
       return Number(osRelease[2]) >= 14931 ? 3 : 2;
@@ -7818,8 +7820,8 @@ function getSupportLevel$1(stream) {
 
 var supportsColor_1$1 = {
   supportsColor: getSupportLevel$1,
-  stdout: translateLevel$1(supportsColor$1(true, tty.isatty(1))),
-  stderr: translateLevel$1(supportsColor$1(true, tty.isatty(2)))
+  stdout: translateLevel$1(supportsColor$1(true, tty$1.isatty(1))),
+  stderr: translateLevel$1(supportsColor$1(true, tty$1.isatty(2)))
 };
 
 const stringReplaceAll = (string, substring, replacer) => {
@@ -10527,7 +10529,7 @@ function supportsColor$2(stream) {
     // release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
     // release that supports 256 colors. Windows 10 build 14931 is the first release
     // that supports 16m/TrueColor.
-    const osRelease = os.release().split('.');
+    const osRelease = os$1.release().split('.');
 
     if (Number(process.versions.node.split('.')[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
       return Number(osRelease[2]) >= 14931 ? 3 : 2;
@@ -11371,7 +11373,7 @@ function resolveParser(opts, parsers) {
     {
       try {
         return {
-          parse: require(path$1.resolve(process.cwd(), opts.parser)),
+          parse: require(path$2.resolve(process.cwd(), opts.parser)),
           astFormat: "estree",
           locStart: locStart$1,
           locEnd: locEnd$1
@@ -11527,7 +11529,7 @@ function getInterpreter(filepath) {
   let fd;
 
   try {
-    fd = fs$2.openSync(filepath, "r");
+    fd = fs$3.openSync(filepath, "r");
   } catch (err) {
     // istanbul ignore next
     return "";
@@ -11559,14 +11561,14 @@ function getInterpreter(filepath) {
     try {
       // There are some weird cases where paths are missing, causing Jest
       // failures. It's unclear what these correspond to in the real world.
-      fs$2.closeSync(fd);
+      fs$3.closeSync(fd);
     } catch (err) {// nop
     }
   }
 }
 
 function inferParser(filepath, plugins) {
-  const filename = path$1.basename(filepath).toLowerCase();
+  const filename = path$2.basename(filepath).toLowerCase();
   const languages = getSupportInfo$1({
     plugins
   }).languages.filter(language => language.since !== null); // If the file has no extension, we can try to infer the language from the
@@ -14072,8 +14074,8 @@ function breakTies(tiesToBreak, text, options) {
 
   for (indexOfFirstLeadingComment = tieCount; indexOfFirstLeadingComment > 0; --indexOfFirstLeadingComment) {
     const comment = tiesToBreak[indexOfFirstLeadingComment - 1];
-    assert.strictEqual(comment.precedingNode, precedingNode);
-    assert.strictEqual(comment.followingNode, followingNode);
+    assert$1.strictEqual(comment.precedingNode, precedingNode);
+    assert$1.strictEqual(comment.followingNode, followingNode);
     const gap = text.slice(options.locEnd(comment), gapEndPos);
 
     if (gapRegExp.test(gap)) {
@@ -14581,7 +14583,7 @@ function printAstToDoc(ast, options, alignmentSize = 0) {
 }
 
 function callPluginPrintFunction(path, options, printPath, args) {
-  assert.ok(path instanceof fastPath);
+  assert$1.ok(path instanceof fastPath);
   const node = path.getValue();
   const {
     printer
@@ -15442,7 +15444,7 @@ var ignore = options => new IgnoreBase(options);
 
 function getFileContentOrNull(filename) {
   return new Promise((resolve, reject) => {
-    fs$2.readFile(filename, "utf8", (error, data) => {
+    fs$3.readFile(filename, "utf8", (error, data) => {
       if (error && error.code !== "ENOENT") {
         reject(createError(filename, error));
       } else {
@@ -15459,7 +15461,7 @@ function getFileContentOrNull(filename) {
 
 getFileContentOrNull.sync = function (filename) {
   try {
-    return fs$2.readFileSync(filename, "utf8");
+    return fs$3.readFileSync(filename, "utf8");
   } catch (error) {
     if (error && error.code === "ENOENT") {
       return null;
@@ -15482,7 +15484,7 @@ var getFileContentOrNull_1 = getFileContentOrNull;
 
 
 async function createIgnorer(ignorePath, withNodeModules) {
-  const ignoreContent = ignorePath ? await getFileContentOrNull_1(path$1.resolve(ignorePath)) : null;
+  const ignoreContent = ignorePath ? await getFileContentOrNull_1(path$2.resolve(ignorePath)) : null;
   return _createIgnorer(ignoreContent, withNodeModules);
 }
 /**
@@ -15492,7 +15494,7 @@ async function createIgnorer(ignorePath, withNodeModules) {
 
 
 createIgnorer.sync = function (ignorePath, withNodeModules) {
-  const ignoreContent = !ignorePath ? null : getFileContentOrNull_1.sync(path$1.resolve(ignorePath));
+  const ignoreContent = !ignorePath ? null : getFileContentOrNull_1.sync(path$2.resolve(ignorePath));
   return _createIgnorer(ignoreContent, withNodeModules);
 };
 /**
@@ -15770,7 +15772,7 @@ var path = {
 };
 
 try {
-  path = path$1;
+  path = path$2;
 } catch (er) {}
 
 var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
@@ -19196,7 +19198,7 @@ LRUCache.prototype.inspect = function (n, opts) {
       str += ',';
     }
 
-    str += '\n  max: ' + util$3.inspect(max, opts);
+    str += '\n  max: ' + util$4.inspect(max, opts);
     extras = true;
   }
 
@@ -19207,7 +19209,7 @@ LRUCache.prototype.inspect = function (n, opts) {
       str += ',';
     }
 
-    str += '\n  maxAge: ' + util$3.inspect(maxAge, opts);
+    str += '\n  maxAge: ' + util$4.inspect(maxAge, opts);
     extras = true;
   }
 
@@ -19218,7 +19220,7 @@ LRUCache.prototype.inspect = function (n, opts) {
       str += ',';
     }
 
-    str += '\n  length: ' + util$3.inspect(this[LENGTH], opts);
+    str += '\n  length: ' + util$4.inspect(this[LENGTH], opts);
     extras = true;
   }
 
@@ -19235,7 +19237,7 @@ LRUCache.prototype.inspect = function (n, opts) {
       str += '\n  ';
     }
 
-    var key = util$3.inspect(item.key).split('\n').join('\n  ');
+    var key = util$4.inspect(item.key).split('\n').join('\n  ');
     var val = {
       value: item.value
     };
@@ -19252,7 +19254,7 @@ LRUCache.prototype.inspect = function (n, opts) {
       val.stale = true;
     }
 
-    val = util$3.inspect(val, opts).split('\n').join('\n  ');
+    val = util$4.inspect(val, opts).split('\n').join('\n  ');
     str += key + ' => ' + val;
   });
 
@@ -20311,7 +20313,7 @@ var fnmatch = createCommonjsModule(function (module, exports) {
     }
 
     if (options.matchBase && pattern.length === 1) {
-      file = path$1.basename(file.join("/")).split("/");
+      file = path$2.basename(file.join("/")).split("/");
     }
 
     if (options.debug) {
@@ -20636,7 +20638,7 @@ var ini = createCommonjsModule(function (module, exports) {
     value: true
   });
 
-  var fs = __importStar(fs$2);
+  var fs = __importStar(fs$3);
   /**
    * define the possible values:
    * section: [section]
@@ -20966,9 +20968,9 @@ var src = createCommonjsModule(function (module, exports) {
     value: true
   });
 
-  var fs = __importStar(fs$2);
+  var fs = __importStar(fs$3);
 
-  var path = __importStar(path$1);
+  var path = __importStar(path$2);
 
   var semver = __importStar(semver$2);
 
@@ -21335,14 +21337,14 @@ function markerExists(files, markers) {
 }
 
 function traverseFolder(directory, levels, markers) {
-  var files = fs$2.readdirSync(directory);
+  var files = fs$3.readdirSync(directory);
 
   if (levels === 0) {
     return null;
   } else if (markerExists(files, markers)) {
     return directory;
   } else {
-    return traverseFolder(path$1.resolve(directory, '..'), levels - 1, markers);
+    return traverseFolder(path$2.resolve(directory, '..'), levels - 1, markers);
   }
 }
 
@@ -21368,11 +21370,11 @@ const maybeParse = (filePath, parse) => {
   // it, which is possible, for example, when the path is given via
   // --stdin-filepath. So, first, traverse up until we find an existing
   // directory.
-  let dirPath = path$1.dirname(path$1.resolve(filePath));
-  const fsRoot = path$1.parse(dirPath).root;
+  let dirPath = path$2.dirname(path$2.resolve(filePath));
+  const fsRoot = path$2.parse(dirPath).root;
 
-  while (dirPath !== fsRoot && !fs$2.existsSync(dirPath)) {
-    dirPath = path$1.dirname(dirPath);
+  while (dirPath !== fsRoot && !fs$3.existsSync(dirPath)) {
+    dirPath = path$2.dirname(dirPath);
   }
 
   const root = findProjectRoot(dirPath);
@@ -23298,18 +23300,961 @@ var loadToml = function (filePath, content) {
   }
 };
 
-let {
-  resolve
-} = eval("require"); // In the VS Code extension `require` is overridden and `require.resolve` doesn't support the 2nd argument.
+var caller = function () {
+  // see https://code.google.com/p/v8/wiki/JavaScriptStackTraceApi
+  var origPrepareStackTrace = Error.prepareStackTrace;
 
-if (resolve.length === 1) {
-  const Module = require("module");
+  Error.prepareStackTrace = function (_, stack) {
+    return stack;
+  };
+
+  var stack = new Error().stack;
+  Error.prepareStackTrace = origPrepareStackTrace;
+  return stack[2].getFileName();
+};
+
+var pathParse = createCommonjsModule(function (module) {
+
+  var isWindows = process.platform === 'win32'; // Regex to split a windows path into three parts: [*, device, slash,
+  // tail] windows-only
+
+  var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/; // Regex to split the tail part of the above into [*, dir, basename, ext]
+
+  var splitTailRe = /^([\s\S]*?)((?:\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))(?:[\\\/]*)$/;
+  var win32 = {}; // Function to split a filename into [root, dir, basename, ext]
+
+  function win32SplitPath(filename) {
+    // Separate device+slash from tail
+    var result = splitDeviceRe.exec(filename),
+        device = (result[1] || '') + (result[2] || ''),
+        tail = result[3] || ''; // Split the tail into dir, basename and extension
+
+    var result2 = splitTailRe.exec(tail),
+        dir = result2[1],
+        basename = result2[2],
+        ext = result2[3];
+    return [device, dir, basename, ext];
+  }
+
+  win32.parse = function (pathString) {
+    if (typeof pathString !== 'string') {
+      throw new TypeError("Parameter 'pathString' must be a string, not " + typeof pathString);
+    }
+
+    var allParts = win32SplitPath(pathString);
+
+    if (!allParts || allParts.length !== 4) {
+      throw new TypeError("Invalid path '" + pathString + "'");
+    }
+
+    return {
+      root: allParts[0],
+      dir: allParts[0] + allParts[1].slice(0, -1),
+      base: allParts[2],
+      ext: allParts[3],
+      name: allParts[2].slice(0, allParts[2].length - allParts[3].length)
+    };
+  }; // Split a filename into [root, dir, basename, ext], unix version
+  // 'root' is just a slash, or nothing.
+
+
+  var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+  var posix = {};
+
+  function posixSplitPath(filename) {
+    return splitPathRe.exec(filename).slice(1);
+  }
+
+  posix.parse = function (pathString) {
+    if (typeof pathString !== 'string') {
+      throw new TypeError("Parameter 'pathString' must be a string, not " + typeof pathString);
+    }
+
+    var allParts = posixSplitPath(pathString);
+
+    if (!allParts || allParts.length !== 4) {
+      throw new TypeError("Invalid path '" + pathString + "'");
+    }
+
+    allParts[1] = allParts[1] || '';
+    allParts[2] = allParts[2] || '';
+    allParts[3] = allParts[3] || '';
+    return {
+      root: allParts[0],
+      dir: allParts[0] + allParts[1].slice(0, -1),
+      base: allParts[2],
+      ext: allParts[3],
+      name: allParts[2].slice(0, allParts[2].length - allParts[3].length)
+    };
+  };
+
+  if (isWindows) module.exports = win32.parse;else
+    /* posix */
+    module.exports = posix.parse;
+  module.exports.posix = posix.parse;
+  module.exports.win32 = win32.parse;
+});
+var pathParse_1 = pathParse.posix;
+var pathParse_2 = pathParse.win32;
+
+var parse$2 = path$2.parse || pathParse;
+
+var getNodeModulesDirs = function getNodeModulesDirs(absoluteStart, modules) {
+  var prefix = '/';
+
+  if (/^([A-Za-z]:)/.test(absoluteStart)) {
+    prefix = '';
+  } else if (/^\\\\/.test(absoluteStart)) {
+    prefix = '\\\\';
+  }
+
+  var paths = [absoluteStart];
+  var parsed = parse$2(absoluteStart);
+
+  while (parsed.dir !== paths[paths.length - 1]) {
+    paths.push(parsed.dir);
+    parsed = parse$2(parsed.dir);
+  }
+
+  return paths.reduce(function (dirs, aPath) {
+    return dirs.concat(modules.map(function (moduleDir) {
+      return path$2.resolve(prefix, aPath, moduleDir);
+    }));
+  }, []);
+};
+
+var nodeModulesPaths = function nodeModulesPaths(start, opts, request) {
+  var modules = opts && opts.moduleDirectory ? [].concat(opts.moduleDirectory) : ['node_modules'];
+
+  if (opts && typeof opts.paths === 'function') {
+    return opts.paths(request, start, function () {
+      return getNodeModulesDirs(start, modules);
+    }, opts);
+  }
+
+  var dirs = getNodeModulesDirs(start, modules);
+  return opts && opts.paths ? dirs.concat(opts.paths) : dirs;
+};
+
+var normalizeOptions$2 = function (x, opts) {
+  /**
+   * This file is purposefully a passthrough. It's expected that third-party
+   * environments will override it at runtime in order to inject special logic
+   * into `resolve` (by manipulating the options). One such example is the PnP
+   * code path in Yarn.
+   */
+  return opts || {};
+};
+
+var assert = true;
+var async_hooks = ">= 8";
+var buffer_ieee754 = "< 0.9.7";
+var buffer = true;
+var child_process = true;
+var cluster = true;
+var console$1 = true;
+var constants$1 = true;
+var crypto = true;
+var _debug_agent = ">= 1 && < 8";
+var _debugger = "< 8";
+var dgram = true;
+var dns = true;
+var domain = true;
+var events = true;
+var freelist = "< 6";
+var fs = true;
+var _http_agent = ">= 0.11.1";
+var _http_client = ">= 0.11.1";
+var _http_common = ">= 0.11.1";
+var _http_incoming = ">= 0.11.1";
+var _http_outgoing = ">= 0.11.1";
+var _http_server = ">= 0.11.1";
+var http = true;
+var http2 = ">= 8.8";
+var https = true;
+var inspector = ">= 8.0.0";
+var _linklist = "< 8";
+var module$1 = true;
+var net = true;
+var os = true;
+var path$1 = true;
+var perf_hooks = ">= 8.5";
+var process$1 = ">= 1";
+var punycode = true;
+var querystring = true;
+var readline = true;
+var repl = true;
+var smalloc = ">= 0.11.5 && < 3";
+var _stream_duplex = ">= 0.9.4";
+var _stream_transform = ">= 0.9.4";
+var _stream_wrap = ">= 1.4.1";
+var _stream_passthrough = ">= 0.9.4";
+var _stream_readable = ">= 0.9.4";
+var _stream_writable = ">= 0.9.4";
+var stream = true;
+var string_decoder = true;
+var sys = true;
+var timers = true;
+var _tls_common = ">= 0.11.13";
+var _tls_legacy = ">= 0.11.3 && < 10";
+var _tls_wrap = ">= 0.11.3";
+var tls = true;
+var trace_events = ">= 10";
+var tty = true;
+var url = true;
+var util$2 = true;
+var v8 = ">= 1";
+var vm = true;
+var wasi = ">= 13.4 && < 13.5";
+var worker_threads = ">= 11.7";
+var zlib = true;
+var core$1 = {
+	assert: assert,
+	async_hooks: async_hooks,
+	buffer_ieee754: buffer_ieee754,
+	buffer: buffer,
+	child_process: child_process,
+	cluster: cluster,
+	console: console$1,
+	constants: constants$1,
+	crypto: crypto,
+	_debug_agent: _debug_agent,
+	_debugger: _debugger,
+	dgram: dgram,
+	dns: dns,
+	domain: domain,
+	events: events,
+	freelist: freelist,
+	fs: fs,
+	"fs/promises": [
+	">= 10 && < 10.1",
+	">= 14"
+],
+	_http_agent: _http_agent,
+	_http_client: _http_client,
+	_http_common: _http_common,
+	_http_incoming: _http_incoming,
+	_http_outgoing: _http_outgoing,
+	_http_server: _http_server,
+	http: http,
+	http2: http2,
+	https: https,
+	inspector: inspector,
+	_linklist: _linklist,
+	module: module$1,
+	net: net,
+	"node-inspect/lib/_inspect": ">= 7.6.0 && < 12",
+	"node-inspect/lib/internal/inspect_client": ">= 7.6.0 && < 12",
+	"node-inspect/lib/internal/inspect_repl": ">= 7.6.0 && < 12",
+	os: os,
+	path: path$1,
+	perf_hooks: perf_hooks,
+	process: process$1,
+	punycode: punycode,
+	querystring: querystring,
+	readline: readline,
+	repl: repl,
+	smalloc: smalloc,
+	_stream_duplex: _stream_duplex,
+	_stream_transform: _stream_transform,
+	_stream_wrap: _stream_wrap,
+	_stream_passthrough: _stream_passthrough,
+	_stream_readable: _stream_readable,
+	_stream_writable: _stream_writable,
+	stream: stream,
+	string_decoder: string_decoder,
+	sys: sys,
+	timers: timers,
+	_tls_common: _tls_common,
+	_tls_legacy: _tls_legacy,
+	_tls_wrap: _tls_wrap,
+	tls: tls,
+	trace_events: trace_events,
+	tty: tty,
+	url: url,
+	util: util$2,
+	"v8/tools/arguments": ">= 10 && < 12",
+	"v8/tools/codemap": [
+	">= 4.4.0 && < 5",
+	">= 5.2.0 && < 12"
+],
+	"v8/tools/consarray": [
+	">= 4.4.0 && < 5",
+	">= 5.2.0 && < 12"
+],
+	"v8/tools/csvparser": [
+	">= 4.4.0 && < 5",
+	">= 5.2.0 && < 12"
+],
+	"v8/tools/logreader": [
+	">= 4.4.0 && < 5",
+	">= 5.2.0 && < 12"
+],
+	"v8/tools/profile_view": [
+	">= 4.4.0 && < 5",
+	">= 5.2.0 && < 12"
+],
+	"v8/tools/splaytree": [
+	">= 4.4.0 && < 5",
+	">= 5.2.0 && < 12"
+],
+	v8: v8,
+	vm: vm,
+	wasi: wasi,
+	worker_threads: worker_threads,
+	zlib: zlib
+};
+
+var core$2 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    assert: assert,
+    async_hooks: async_hooks,
+    buffer_ieee754: buffer_ieee754,
+    buffer: buffer,
+    child_process: child_process,
+    cluster: cluster,
+    console: console$1,
+    constants: constants$1,
+    crypto: crypto,
+    _debug_agent: _debug_agent,
+    _debugger: _debugger,
+    dgram: dgram,
+    dns: dns,
+    domain: domain,
+    events: events,
+    freelist: freelist,
+    fs: fs,
+    _http_agent: _http_agent,
+    _http_client: _http_client,
+    _http_common: _http_common,
+    _http_incoming: _http_incoming,
+    _http_outgoing: _http_outgoing,
+    _http_server: _http_server,
+    http: http,
+    http2: http2,
+    https: https,
+    inspector: inspector,
+    _linklist: _linklist,
+    module: module$1,
+    net: net,
+    os: os,
+    path: path$1,
+    perf_hooks: perf_hooks,
+    process: process$1,
+    punycode: punycode,
+    querystring: querystring,
+    readline: readline,
+    repl: repl,
+    smalloc: smalloc,
+    _stream_duplex: _stream_duplex,
+    _stream_transform: _stream_transform,
+    _stream_wrap: _stream_wrap,
+    _stream_passthrough: _stream_passthrough,
+    _stream_readable: _stream_readable,
+    _stream_writable: _stream_writable,
+    stream: stream,
+    string_decoder: string_decoder,
+    sys: sys,
+    timers: timers,
+    _tls_common: _tls_common,
+    _tls_legacy: _tls_legacy,
+    _tls_wrap: _tls_wrap,
+    tls: tls,
+    trace_events: trace_events,
+    tty: tty,
+    url: url,
+    util: util$2,
+    v8: v8,
+    vm: vm,
+    wasi: wasi,
+    worker_threads: worker_threads,
+    zlib: zlib,
+    'default': core$1
+});
+
+var data = getCjsExportFromNamespace(core$2);
+
+var current = process.versions && process.versions.node && process.versions.node.split('.') || [];
+
+function specifierIncluded(specifier) {
+  var parts = specifier.split(' ');
+  var op = parts.length > 1 ? parts[0] : '=';
+  var versionParts = (parts.length > 1 ? parts[1] : parts[0]).split('.');
+
+  for (var i = 0; i < 3; ++i) {
+    var cur = Number(current[i] || 0);
+    var ver = Number(versionParts[i] || 0);
+
+    if (cur === ver) {
+      continue; // eslint-disable-line no-restricted-syntax, no-continue
+    }
+
+    if (op === '<') {
+      return cur < ver;
+    } else if (op === '>=') {
+      return cur >= ver;
+    } else {
+      return false;
+    }
+  }
+
+  return op === '>=';
+}
+
+function matchesRange(range) {
+  var specifiers = range.split(/ ?&& ?/);
+
+  if (specifiers.length === 0) {
+    return false;
+  }
+
+  for (var i = 0; i < specifiers.length; ++i) {
+    if (!specifierIncluded(specifiers[i])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function versionIncluded(specifierValue) {
+  if (typeof specifierValue === 'boolean') {
+    return specifierValue;
+  }
+
+  if (specifierValue && typeof specifierValue === 'object') {
+    for (var i = 0; i < specifierValue.length; ++i) {
+      if (matchesRange(specifierValue[i])) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  return matchesRange(specifierValue);
+}
+
+var core$3 = {};
+
+for (var mod in data) {
+  // eslint-disable-line no-restricted-syntax
+  if (Object.prototype.hasOwnProperty.call(data, mod)) {
+    core$3[mod] = versionIncluded(data[mod]);
+  }
+}
+
+var core_1 = core$3;
+
+var isCore = function isCore(x) {
+  return Object.prototype.hasOwnProperty.call(core_1, x);
+};
+
+var realpath = fs$3.realpath && typeof fs$3.realpath.native === 'function' ? fs$3.realpath.native : fs$3.realpath;
+
+var defaultIsFile = function isFile(file, cb) {
+  fs$3.stat(file, function (err, stat) {
+    if (!err) {
+      return cb(null, stat.isFile() || stat.isFIFO());
+    }
+
+    if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+    return cb(err);
+  });
+};
+
+var defaultIsDir = function isDirectory(dir, cb) {
+  fs$3.stat(dir, function (err, stat) {
+    if (!err) {
+      return cb(null, stat.isDirectory());
+    }
+
+    if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+    return cb(err);
+  });
+};
+
+var maybeUnwrapSymlink = function maybeUnwrapSymlink(x, opts, cb) {
+  if (opts && opts.preserveSymlinks === false) {
+    realpath(x, function (realPathErr, realPath) {
+      if (realPathErr && realPathErr.code !== 'ENOENT') cb(realPathErr);else cb(null, realPathErr ? x : realPath);
+    });
+  } else {
+    cb(null, x);
+  }
+};
+
+var getPackageCandidates = function getPackageCandidates(x, start, opts) {
+  var dirs = nodeModulesPaths(start, opts, x);
+
+  for (var i = 0; i < dirs.length; i++) {
+    dirs[i] = path$2.join(dirs[i], x);
+  }
+
+  return dirs;
+};
+
+var async = function resolve(x, options, callback) {
+  var cb = callback;
+  var opts = options;
+
+  if (typeof options === 'function') {
+    cb = opts;
+    opts = {};
+  }
+
+  if (typeof x !== 'string') {
+    var err = new TypeError('Path must be a string.');
+    return process.nextTick(function () {
+      cb(err);
+    });
+  }
+
+  opts = normalizeOptions$2(x, opts);
+  var isFile = opts.isFile || defaultIsFile;
+  var isDirectory = opts.isDirectory || defaultIsDir;
+  var readFile = opts.readFile || fs$3.readFile;
+  var packageIterator = opts.packageIterator;
+  var extensions = opts.extensions || ['.js'];
+  var basedir = opts.basedir || path$2.dirname(caller());
+  var parent = opts.filename || basedir;
+  opts.paths = opts.paths || []; // ensure that `basedir` is an absolute path at this point, resolving against the process' current working directory
+
+  var absoluteStart = path$2.resolve(basedir);
+  maybeUnwrapSymlink(absoluteStart, opts, function (err, realStart) {
+    if (err) cb(err);else init(realStart);
+  });
+  var res;
+
+  function init(basedir) {
+    if (/^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/.test(x)) {
+      res = path$2.resolve(basedir, x);
+      if (x === '.' || x === '..' || x.slice(-1) === '/') res += '/';
+
+      if (/\/$/.test(x) && res === basedir) {
+        loadAsDirectory(res, opts.package, onfile);
+      } else loadAsFile(res, opts.package, onfile);
+    } else if (isCore(x)) {
+      return cb(null, x);
+    } else loadNodeModules(x, basedir, function (err, n, pkg) {
+      if (err) cb(err);else if (n) {
+        return maybeUnwrapSymlink(n, opts, function (err, realN) {
+          if (err) {
+            cb(err);
+          } else {
+            cb(null, realN, pkg);
+          }
+        });
+      } else {
+        var moduleError = new Error("Cannot find module '" + x + "' from '" + parent + "'");
+        moduleError.code = 'MODULE_NOT_FOUND';
+        cb(moduleError);
+      }
+    });
+  }
+
+  function onfile(err, m, pkg) {
+    if (err) cb(err);else if (m) cb(null, m, pkg);else loadAsDirectory(res, function (err, d, pkg) {
+      if (err) cb(err);else if (d) {
+        maybeUnwrapSymlink(d, opts, function (err, realD) {
+          if (err) {
+            cb(err);
+          } else {
+            cb(null, realD, pkg);
+          }
+        });
+      } else {
+        var moduleError = new Error("Cannot find module '" + x + "' from '" + parent + "'");
+        moduleError.code = 'MODULE_NOT_FOUND';
+        cb(moduleError);
+      }
+    });
+  }
+
+  function loadAsFile(x, thePackage, callback) {
+    var loadAsFilePackage = thePackage;
+    var cb = callback;
+
+    if (typeof loadAsFilePackage === 'function') {
+      cb = loadAsFilePackage;
+      loadAsFilePackage = undefined;
+    }
+
+    var exts = [''].concat(extensions);
+    load(exts, x, loadAsFilePackage);
+
+    function load(exts, x, loadPackage) {
+      if (exts.length === 0) return cb(null, undefined, loadPackage);
+      var file = x + exts[0];
+      var pkg = loadPackage;
+      if (pkg) onpkg(null, pkg);else loadpkg(path$2.dirname(file), onpkg);
+
+      function onpkg(err, pkg_, dir) {
+        pkg = pkg_;
+        if (err) return cb(err);
+
+        if (dir && pkg && opts.pathFilter) {
+          var rfile = path$2.relative(dir, file);
+          var rel = rfile.slice(0, rfile.length - exts[0].length);
+          var r = opts.pathFilter(pkg, x, rel);
+          if (r) return load([''].concat(extensions.slice()), path$2.resolve(dir, r), pkg);
+        }
+
+        isFile(file, onex);
+      }
+
+      function onex(err, ex) {
+        if (err) return cb(err);
+        if (ex) return cb(null, file, pkg);
+        load(exts.slice(1), x, pkg);
+      }
+    }
+  }
+
+  function loadpkg(dir, cb) {
+    if (dir === '' || dir === '/') return cb(null);
+
+    if (process.platform === 'win32' && /^\w:[/\\]*$/.test(dir)) {
+      return cb(null);
+    }
+
+    if (/[/\\]node_modules[/\\]*$/.test(dir)) return cb(null);
+    maybeUnwrapSymlink(dir, opts, function (unwrapErr, pkgdir) {
+      if (unwrapErr) return loadpkg(path$2.dirname(dir), cb);
+      var pkgfile = path$2.join(pkgdir, 'package.json');
+      isFile(pkgfile, function (err, ex) {
+        // on err, ex is false
+        if (!ex) return loadpkg(path$2.dirname(dir), cb);
+        readFile(pkgfile, function (err, body) {
+          if (err) cb(err);
+
+          try {
+            var pkg = JSON.parse(body);
+          } catch (jsonErr) {}
+
+          if (pkg && opts.packageFilter) {
+            pkg = opts.packageFilter(pkg, pkgfile);
+          }
+
+          cb(null, pkg, dir);
+        });
+      });
+    });
+  }
+
+  function loadAsDirectory(x, loadAsDirectoryPackage, callback) {
+    var cb = callback;
+    var fpkg = loadAsDirectoryPackage;
+
+    if (typeof fpkg === 'function') {
+      cb = fpkg;
+      fpkg = opts.package;
+    }
+
+    maybeUnwrapSymlink(x, opts, function (unwrapErr, pkgdir) {
+      if (unwrapErr) return cb(unwrapErr);
+      var pkgfile = path$2.join(pkgdir, 'package.json');
+      isFile(pkgfile, function (err, ex) {
+        if (err) return cb(err);
+        if (!ex) return loadAsFile(path$2.join(x, 'index'), fpkg, cb);
+        readFile(pkgfile, function (err, body) {
+          if (err) return cb(err);
+
+          try {
+            var pkg = JSON.parse(body);
+          } catch (jsonErr) {}
+
+          if (pkg && opts.packageFilter) {
+            pkg = opts.packageFilter(pkg, pkgfile);
+          }
+
+          if (pkg && pkg.main) {
+            if (typeof pkg.main !== 'string') {
+              var mainError = new TypeError('package “' + pkg.name + '” `main` must be a string');
+              mainError.code = 'INVALID_PACKAGE_MAIN';
+              return cb(mainError);
+            }
 
-  const createRequire = Module.createRequire || Module.createRequireFromPath;
-  resolve = createRequire(__dirname).resolve;
+            if (pkg.main === '.' || pkg.main === './') {
+              pkg.main = 'index';
+            }
+
+            loadAsFile(path$2.resolve(x, pkg.main), pkg, function (err, m, pkg) {
+              if (err) return cb(err);
+              if (m) return cb(null, m, pkg);
+              if (!pkg) return loadAsFile(path$2.join(x, 'index'), pkg, cb);
+              var dir = path$2.resolve(x, pkg.main);
+              loadAsDirectory(dir, pkg, function (err, n, pkg) {
+                if (err) return cb(err);
+                if (n) return cb(null, n, pkg);
+                loadAsFile(path$2.join(x, 'index'), pkg, cb);
+              });
+            });
+            return;
+          }
+
+          loadAsFile(path$2.join(x, '/index'), pkg, cb);
+        });
+      });
+    });
+  }
+
+  function processDirs(cb, dirs) {
+    if (dirs.length === 0) return cb(null, undefined);
+    var dir = dirs[0];
+    isDirectory(path$2.dirname(dir), isdir);
+
+    function isdir(err, isdir) {
+      if (err) return cb(err);
+      if (!isdir) return processDirs(cb, dirs.slice(1));
+      loadAsFile(dir, opts.package, onfile);
+    }
+
+    function onfile(err, m, pkg) {
+      if (err) return cb(err);
+      if (m) return cb(null, m, pkg);
+      loadAsDirectory(dir, opts.package, ondir);
+    }
+
+    function ondir(err, n, pkg) {
+      if (err) return cb(err);
+      if (n) return cb(null, n, pkg);
+      processDirs(cb, dirs.slice(1));
+    }
+  }
+
+  function loadNodeModules(x, start, cb) {
+    var thunk = function () {
+      return getPackageCandidates(x, start, opts);
+    };
+
+    processDirs(cb, packageIterator ? packageIterator(x, start, thunk, opts) : thunk());
+  }
+};
+
+var realpath$1 = fs$3.realpathSync && typeof fs$3.realpathSync.native === 'function' ? fs$3.realpathSync.native : fs$3.realpathSync;
+
+var defaultIsFile$1 = function isFile(file) {
+  try {
+    var stat = fs$3.statSync(file);
+  } catch (e) {
+    if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+    throw e;
+  }
+
+  return stat.isFile() || stat.isFIFO();
+};
+
+var defaultIsDir$1 = function isDirectory(dir) {
+  try {
+    var stat = fs$3.statSync(dir);
+  } catch (e) {
+    if (e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) return false;
+    throw e;
+  }
+
+  return stat.isDirectory();
+};
+
+var maybeUnwrapSymlink$1 = function maybeUnwrapSymlink(x, opts) {
+  if (opts && opts.preserveSymlinks === false) {
+    try {
+      return realpath$1(x);
+    } catch (realPathErr) {
+      if (realPathErr.code !== 'ENOENT') {
+        throw realPathErr;
+      }
+    }
+  }
+
+  return x;
+};
+
+var getPackageCandidates$1 = function getPackageCandidates(x, start, opts) {
+  var dirs = nodeModulesPaths(start, opts, x);
+
+  for (var i = 0; i < dirs.length; i++) {
+    dirs[i] = path$2.join(dirs[i], x);
+  }
+
+  return dirs;
+};
+
+var sync = function resolveSync(x, options) {
+  if (typeof x !== 'string') {
+    throw new TypeError('Path must be a string.');
+  }
+
+  var opts = normalizeOptions$2(x, options);
+  var isFile = opts.isFile || defaultIsFile$1;
+  var readFileSync = opts.readFileSync || fs$3.readFileSync;
+  var isDirectory = opts.isDirectory || defaultIsDir$1;
+  var packageIterator = opts.packageIterator;
+  var extensions = opts.extensions || ['.js'];
+  var basedir = opts.basedir || path$2.dirname(caller());
+  var parent = opts.filename || basedir;
+  opts.paths = opts.paths || []; // ensure that `basedir` is an absolute path at this point, resolving against the process' current working directory
+
+  var absoluteStart = maybeUnwrapSymlink$1(path$2.resolve(basedir), opts);
+
+  if (/^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/.test(x)) {
+    var res = path$2.resolve(absoluteStart, x);
+    if (x === '.' || x === '..' || x.slice(-1) === '/') res += '/';
+    var m = loadAsFileSync(res) || loadAsDirectorySync(res);
+    if (m) return maybeUnwrapSymlink$1(m, opts);
+  } else if (isCore(x)) {
+    return x;
+  } else {
+    var n = loadNodeModulesSync(x, absoluteStart);
+    if (n) return maybeUnwrapSymlink$1(n, opts);
+  }
+
+  var err = new Error("Cannot find module '" + x + "' from '" + parent + "'");
+  err.code = 'MODULE_NOT_FOUND';
+  throw err;
+
+  function loadAsFileSync(x) {
+    var pkg = loadpkg(path$2.dirname(x));
+
+    if (pkg && pkg.dir && pkg.pkg && opts.pathFilter) {
+      var rfile = path$2.relative(pkg.dir, x);
+      var r = opts.pathFilter(pkg.pkg, x, rfile);
+
+      if (r) {
+        x = path$2.resolve(pkg.dir, r); // eslint-disable-line no-param-reassign
+      }
+    }
+
+    if (isFile(x)) {
+      return x;
+    }
+
+    for (var i = 0; i < extensions.length; i++) {
+      var file = x + extensions[i];
+
+      if (isFile(file)) {
+        return file;
+      }
+    }
+  }
+
+  function loadpkg(dir) {
+    if (dir === '' || dir === '/') return;
+
+    if (process.platform === 'win32' && /^\w:[/\\]*$/.test(dir)) {
+      return;
+    }
+
+    if (/[/\\]node_modules[/\\]*$/.test(dir)) return;
+    var pkgfile = path$2.join(maybeUnwrapSymlink$1(dir, opts), 'package.json');
+
+    if (!isFile(pkgfile)) {
+      return loadpkg(path$2.dirname(dir));
+    }
+
+    var body = readFileSync(pkgfile);
+
+    try {
+      var pkg = JSON.parse(body);
+    } catch (jsonErr) {}
+
+    if (pkg && opts.packageFilter) {
+      // v2 will pass pkgfile
+      pkg = opts.packageFilter(pkg,
+      /*pkgfile,*/
+      dir); // eslint-disable-line spaced-comment
+    }
+
+    return {
+      pkg: pkg,
+      dir: dir
+    };
+  }
+
+  function loadAsDirectorySync(x) {
+    var pkgfile = path$2.join(maybeUnwrapSymlink$1(x, opts), '/package.json');
+
+    if (isFile(pkgfile)) {
+      try {
+        var body = readFileSync(pkgfile, 'UTF8');
+        var pkg = JSON.parse(body);
+      } catch (e) {}
+
+      if (pkg && opts.packageFilter) {
+        // v2 will pass pkgfile
+        pkg = opts.packageFilter(pkg,
+        /*pkgfile,*/
+        x); // eslint-disable-line spaced-comment
+      }
+
+      if (pkg && pkg.main) {
+        if (typeof pkg.main !== 'string') {
+          var mainError = new TypeError('package “' + pkg.name + '” `main` must be a string');
+          mainError.code = 'INVALID_PACKAGE_MAIN';
+          throw mainError;
+        }
+
+        if (pkg.main === '.' || pkg.main === './') {
+          pkg.main = 'index';
+        }
+
+        try {
+          var m = loadAsFileSync(path$2.resolve(x, pkg.main));
+          if (m) return m;
+          var n = loadAsDirectorySync(path$2.resolve(x, pkg.main));
+          if (n) return n;
+        } catch (e) {}
+      }
+    }
+
+    return loadAsFileSync(path$2.join(x, '/index'));
+  }
+
+  function loadNodeModulesSync(x, start) {
+    var thunk = function () {
+      return getPackageCandidates$1(x, start, opts);
+    };
+
+    var dirs = packageIterator ? packageIterator(x, start, thunk, opts) : thunk();
+
+    for (var i = 0; i < dirs.length; i++) {
+      var dir = dirs[i];
+
+      if (isDirectory(path$2.dirname(dir))) {
+        var m = loadAsFileSync(dir);
+        if (m) return m;
+        var n = loadAsDirectorySync(dir);
+        if (n) return n;
+      }
+    }
+  }
+};
+
+async.core = core_1;
+async.isCore = isCore;
+async.sync = sync;
+var resolve = async;
+
+// eslint-disable-next-line prefer-destructuring
+
+
+let resolve$1 = require.resolve; // In the VS Code and Atom extensions `require` is overridden and `require.resolve` doesn't support the 2nd argument.
+
+if (resolve$1.length === 1 || process.env.PRETTIER_FALLBACK_RESOLVE) {
+  resolve$1 = (id, options) => {
+    let basedir;
+
+    if (options && options.paths && options.paths.length === 1) {
+      basedir = options.paths[0];
+    }
+
+    return resolve.sync(id, {
+      basedir
+    });
+  };
 }
 
-var resolve_1 = resolve;
+var resolve_1 = resolve$1;
 
 const getExplorerMemoized = mem_1(opts => {
   const cosmiconfig = thirdParty["cosmiconfig" + (opts.sync ? "Sync" : "")];
@@ -23318,7 +24263,7 @@ const getExplorerMemoized = mem_1(opts => {
     transform: result => {
       if (result && result.config) {
         if (typeof result.config === "string") {
-          const dir = path$1.dirname(result.filepath);
+          const dir = path$2.dirname(result.filepath);
 
           try {
             const modulePath = resolve_1(result.config, {
@@ -23382,7 +24327,7 @@ function _resolveConfig(filePath, opts, sync) {
     ["plugins", "pluginSearchDirs"].forEach(optionName => {
       if (Array.isArray(merged[optionName])) {
         merged[optionName] = merged[optionName].map(value => typeof value === "string" && value.startsWith(".") // relative path
-        ? path$1.resolve(path$1.dirname(result.filepath), value) : value);
+        ? path$2.resolve(path$2.dirname(result.filepath), value) : value);
       }
     });
 
@@ -23442,7 +24387,7 @@ function mergeOverrides(configResult, filePath) {
         options = _objectWithoutPropertiesLoose(_ref, ["overrides"]);
 
   if (filePath && overrides) {
-    const relativeFilePath = path$1.relative(path$1.dirname(configPath), filePath);
+    const relativeFilePath = path$2.relative(path$2.dirname(configPath), filePath);
 
     for (const override of overrides) {
       if (pathMatchesGlobs(relativeFilePath, override.files, override.excludeFiles)) {
@@ -23557,7 +24502,7 @@ function _getFileInfo({
 }
 
 function normalizeFilePath(filePath, ignorePath) {
-  return ignorePath ? path$1.relative(path$1.dirname(ignorePath), filePath) : filePath;
+  return ignorePath ? path$2.relative(path$2.dirname(ignorePath), filePath) : filePath;
 }
 
 var getFileInfo_1 = getFileInfo;
@@ -26975,7 +27920,7 @@ var arrayUnion = (...arguments_) => {
  */
 
 
-const PassThrough = stream$5.PassThrough;
+const PassThrough = stream$6.PassThrough;
 const slice = Array.prototype.slice;
 var merge2_1 = merge2;
 
@@ -27124,7 +28069,7 @@ var errno = createCommonjsModule(function (module, exports) {
 unwrapExports(errno);
 var errno_1 = errno.isEnoentCodeError;
 
-var fs = createCommonjsModule(function (module, exports) {
+var fs$1 = createCommonjsModule(function (module, exports) {
 
   Object.defineProperty(exports, "__esModule", {
     value: true
@@ -27150,8 +28095,8 @@ var fs = createCommonjsModule(function (module, exports) {
 
   exports.createDirentFromStats = createDirentFromStats;
 });
-unwrapExports(fs);
-var fs_1 = fs.createDirentFromStats;
+unwrapExports(fs$1);
+var fs_1 = fs$1.createDirentFromStats;
 
 var path_1 = createCommonjsModule(function (module, exports) {
 
@@ -27172,7 +28117,7 @@ var path_1 = createCommonjsModule(function (module, exports) {
   exports.unixify = unixify;
 
   function makeAbsolute(cwd, filepath) {
-    return path$1.resolve(cwd, filepath);
+    return path$2.resolve(cwd, filepath);
   }
 
   exports.makeAbsolute = makeAbsolute;
@@ -27279,8 +28224,8 @@ var isGlob = function isGlob(str, options) {
   return false;
 };
 
-var pathPosixDirname = path$1.posix.dirname;
-var isWin32 = os.platform() === 'win32';
+var pathPosixDirname = path$2.posix.dirname;
+var isWin32 = os$1.platform() === 'win32';
 var slash = '/';
 var backslash = /\\/g;
 var enclosure = /[\{\[].*[\/]*.*[\}\]]$/;
@@ -27916,7 +28861,7 @@ const toRegex = (start, end, options) => {
 };
 
 const rangeError = (...args) => {
-  return new RangeError('Invalid range arguments: ' + util$3.inspect(...args));
+  return new RangeError('Invalid range arguments: ' + util$4.inspect(...args));
 };
 
 const invalidRange = (start, end, options) => {
@@ -28227,7 +29172,7 @@ const expand$1 = (ast, options = {}) => {
 
 var expand_1 = expand$1;
 
-var constants$1 = {
+var constants$2 = {
   MAX_LENGTH: 1024 * 64,
   // Digits
   CHAR_0: '0',
@@ -28411,12 +29356,12 @@ const {
   /* ' */
   CHAR_NO_BREAK_SPACE,
   CHAR_ZERO_WIDTH_NOBREAK_SPACE
-} = constants$1;
+} = constants$2;
 /**
  * parse
  */
 
-const parse$2 = (input, options = {}) => {
+const parse$3 = (input, options = {}) => {
   if (typeof input !== 'string') {
     throw new TypeError('Expected a string');
   }
@@ -28766,7 +29711,7 @@ const parse$2 = (input, options = {}) => {
   return ast;
 };
 
-var parse_1 = parse$2;
+var parse_1 = parse$3;
 
 /**
  * Expand the given pattern or create a regex-compatible string.
@@ -29009,7 +29954,7 @@ const POSIX_REGEX_SOURCE = {
   word: 'A-Za-z0-9_',
   xdigit: 'A-Fa-f0-9'
 };
-var constants$2 = {
+var constants$3 = {
   MAX_LENGTH: 1024 * 64,
   POSIX_REGEX_SOURCE,
   // regular expressions
@@ -29157,7 +30102,7 @@ var constants$2 = {
   CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
 
   /* \uFEFF */
-  SEP: path$1.sep,
+  SEP: path$2.sep,
 
   /**
    * Create EXTGLOB_CHARS
@@ -29209,7 +30154,7 @@ var utils$3 = createCommonjsModule(function (module, exports) {
     REGEX_REMOVE_BACKSLASH,
     REGEX_SPECIAL_CHARS,
     REGEX_SPECIAL_CHARS_GLOBAL
-  } = constants$2;
+  } = constants$3;
 
   exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
 
@@ -29242,7 +30187,7 @@ var utils$3 = createCommonjsModule(function (module, exports) {
       return options.windows;
     }
 
-    return win32 === true || path$1.sep === '\\';
+    return win32 === true || path$2.sep === '\\';
   };
 
   exports.escapeLast = (input, char, lastIdx) => {
@@ -29333,7 +30278,7 @@ const {
   CHAR_RIGHT_SQUARE_BRACKET: CHAR_RIGHT_SQUARE_BRACKET$1
   /* ] */
 
-} = constants$2;
+} = constants$3;
 
 const isPathSeparator = code => {
   return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
@@ -29725,7 +30670,7 @@ const {
   REGEX_NON_SPECIAL_CHARS,
   REGEX_SPECIAL_CHARS_BACKREF,
   REPLACEMENTS
-} = constants$2;
+} = constants$3;
 /**
  * Helpers
  */
@@ -29763,7 +30708,7 @@ const syntaxError = (type, char) => {
  */
 
 
-const parse$3 = (input, options) => {
+const parse$4 = (input, options) => {
   if (typeof input !== 'string') {
     throw new TypeError('Expected a string');
   }
@@ -29786,8 +30731,8 @@ const parse$3 = (input, options) => {
   const capture = opts.capture ? '' : '?:';
   const win32 = utils$3.isWindows(options); // create constants based on platform, for windows or posix
 
-  const PLATFORM_CHARS = constants$2.globChars(win32);
-  const EXTGLOB_CHARS = constants$2.extglobChars(PLATFORM_CHARS);
+  const PLATFORM_CHARS = constants$3.globChars(win32);
+  const EXTGLOB_CHARS = constants$3.extglobChars(PLATFORM_CHARS);
   const {
     DOT_LITERAL,
     PLUS_LITERAL,
@@ -30843,7 +31788,7 @@ const parse$3 = (input, options) => {
  */
 
 
-parse$3.fastpaths = (input, options) => {
+parse$4.fastpaths = (input, options) => {
   const opts = Object.assign({}, options);
   const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$3, opts.maxLength) : MAX_LENGTH$3;
   const len = input.length;
@@ -30865,7 +31810,7 @@ parse$3.fastpaths = (input, options) => {
     NO_DOTS_SLASH,
     STAR,
     START_ANCHOR
-  } = constants$2.globChars(win32);
+  } = constants$3.globChars(win32);
   const nodot = opts.dot ? NO_DOTS : NO_DOT;
   const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
   const capture = opts.capture ? '' : '?:';
@@ -30931,7 +31876,7 @@ parse$3.fastpaths = (input, options) => {
   return source;
 };
 
-var parse_1$1 = parse$3;
+var parse_1$1 = parse$4;
 
 const isObject$2 = val => val && typeof val === 'object' && !Array.isArray(val);
 /**
@@ -31121,7 +32066,7 @@ picomatch.test = (input, regex, options, {
 
 picomatch.matchBase = (input, glob, options, posix = utils$3.isWindows(options)) => {
   const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
-  return regex.test(path$1.basename(input));
+  return regex.test(path$2.basename(input));
 };
 /**
  * Returns true if **any** of the given glob `patterns` match the specified `string`.
@@ -31296,7 +32241,7 @@ picomatch.toRegex = (source, options) => {
  */
 
 
-picomatch.constants = constants$2;
+picomatch.constants = constants$3;
 /**
  * Expose "picomatch"
  */
@@ -31490,7 +32435,7 @@ micromatch.not = (list, patterns, options = {}) => {
 
 micromatch.contains = (str, pattern, options) => {
   if (typeof str !== 'string') {
-    throw new TypeError(`Expected a string: "${util$3.inspect(str)}"`);
+    throw new TypeError(`Expected a string: "${util$4.inspect(str)}"`);
   }
 
   if (Array.isArray(pattern)) {
@@ -31645,7 +32590,7 @@ micromatch.every = (list, patterns, options) => {
 
 micromatch.all = (str, patterns, options) => {
   if (typeof str !== 'string') {
-    throw new TypeError(`Expected a string: "${util$3.inspect(str)}"`);
+    throw new TypeError(`Expected a string: "${util$4.inspect(str)}"`);
   }
 
   return [].concat(patterns).every(p => picomatch$1(p, options)(str));
@@ -31888,7 +32833,7 @@ var pattern = createCommonjsModule(function (module, exports) {
   exports.endsWithSlashGlobStar = endsWithSlashGlobStar;
 
   function isAffectDepthOfReadingPattern(pattern) {
-    const basename = path$1.basename(pattern);
+    const basename = path$2.basename(pattern);
     return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
   }
 
@@ -31963,7 +32908,7 @@ var pattern_16 = pattern.makeRe;
 var pattern_17 = pattern.convertPatternsToRe;
 var pattern_18 = pattern.matchAny;
 
-var stream = createCommonjsModule(function (module, exports) {
+var stream$1 = createCommonjsModule(function (module, exports) {
 
   Object.defineProperty(exports, "__esModule", {
     value: true
@@ -31985,8 +32930,8 @@ var stream = createCommonjsModule(function (module, exports) {
     streams.forEach(stream => stream.emit('close'));
   }
 });
-unwrapExports(stream);
-var stream_1 = stream.merge;
+unwrapExports(stream$1);
+var stream_1 = stream$1.merge;
 
 var string$1 = createCommonjsModule(function (module, exports) {
 
@@ -32017,10 +32962,10 @@ var utils$4 = createCommonjsModule(function (module, exports) {
   });
   exports.array = array$2;
   exports.errno = errno;
-  exports.fs = fs;
+  exports.fs = fs$1;
   exports.path = path_1;
   exports.pattern = pattern;
-  exports.stream = stream;
+  exports.stream = stream$1;
   exports.string = string$1;
 });
 unwrapExports(utils$4);
@@ -32128,7 +33073,7 @@ var tasks_5 = tasks.groupPatternsByBaseDirectory;
 var tasks_6 = tasks.convertPatternGroupsToTasks;
 var tasks_7 = tasks.convertPatternGroupToTask;
 
-var async = createCommonjsModule(function (module, exports) {
+var async$1 = createCommonjsModule(function (module, exports) {
 
   Object.defineProperty(exports, "__esModule", {
     value: true
@@ -32172,10 +33117,10 @@ var async = createCommonjsModule(function (module, exports) {
     callback(null, result);
   }
 });
-unwrapExports(async);
-var async_1 = async.read;
+unwrapExports(async$1);
+var async_1 = async$1.read;
 
-var sync = createCommonjsModule(function (module, exports) {
+var sync$1 = createCommonjsModule(function (module, exports) {
 
   Object.defineProperty(exports, "__esModule", {
     value: true
@@ -32207,8 +33152,8 @@ var sync = createCommonjsModule(function (module, exports) {
 
   exports.read = read;
 });
-unwrapExports(sync);
-var sync_1 = sync.read;
+unwrapExports(sync$1);
+var sync_1 = sync$1.read;
 
 var fs_1$1 = createCommonjsModule(function (module, exports) {
 
@@ -32216,10 +33161,10 @@ var fs_1$1 = createCommonjsModule(function (module, exports) {
     value: true
   });
   exports.FILE_SYSTEM_ADAPTER = {
-    lstat: fs$2.lstat,
-    stat: fs$2.stat,
-    lstatSync: fs$2.lstatSync,
-    statSync: fs$2.statSync
+    lstat: fs$3.lstat,
+    stat: fs$3.stat,
+    lstatSync: fs$3.lstatSync,
+    statSync: fs$3.statSync
   };
 
   function createFileSystemAdapter(fsMethods) {
@@ -32270,17 +33215,17 @@ var out = createCommonjsModule(function (module, exports) {
 
   function stat(path, optionsOrSettingsOrCallback, callback) {
     if (typeof optionsOrSettingsOrCallback === 'function') {
-      return async.read(path, getSettings(), optionsOrSettingsOrCallback);
+      return async$1.read(path, getSettings(), optionsOrSettingsOrCallback);
     }
 
-    async.read(path, getSettings(optionsOrSettingsOrCallback), callback);
+    async$1.read(path, getSettings(optionsOrSettingsOrCallback), callback);
   }
 
   exports.stat = stat;
 
   function statSync(path, optionsOrSettings) {
     const settings = getSettings(optionsOrSettings);
-    return sync.read(path, settings);
+    return sync$1.read(path, settings);
   }
 
   exports.statSync = statSync;
@@ -32352,7 +33297,7 @@ function runParallel(tasks, cb) {
   isSync = false;
 }
 
-var constants$3 = createCommonjsModule(function (module, exports) {
+var constants$4 = createCommonjsModule(function (module, exports) {
 
   Object.defineProperty(exports, "__esModule", {
     value: true
@@ -32370,10 +33315,10 @@ var constants$3 = createCommonjsModule(function (module, exports) {
 
   exports.IS_SUPPORT_READDIR_WITH_FILE_TYPES = IS_MATCHED_BY_MAJOR || IS_MATCHED_BY_MAJOR_AND_MINOR;
 });
-unwrapExports(constants$3);
-var constants_1 = constants$3.IS_SUPPORT_READDIR_WITH_FILE_TYPES;
+unwrapExports(constants$4);
+var constants_1 = constants$4.IS_SUPPORT_READDIR_WITH_FILE_TYPES;
 
-var fs$1 = createCommonjsModule(function (module, exports) {
+var fs$2 = createCommonjsModule(function (module, exports) {
 
   Object.defineProperty(exports, "__esModule", {
     value: true
@@ -32399,27 +33344,27 @@ var fs$1 = createCommonjsModule(function (module, exports) {
 
   exports.createDirentFromStats = createDirentFromStats;
 });
-unwrapExports(fs$1);
-var fs_1$2 = fs$1.createDirentFromStats;
+unwrapExports(fs$2);
+var fs_1$2 = fs$2.createDirentFromStats;
 
 var utils$5 = createCommonjsModule(function (module, exports) {
 
   Object.defineProperty(exports, "__esModule", {
     value: true
   });
-  exports.fs = fs$1;
+  exports.fs = fs$2;
 });
 unwrapExports(utils$5);
 var utils_1$5 = utils$5.fs;
 
-var async$1 = createCommonjsModule(function (module, exports) {
+var async$2 = createCommonjsModule(function (module, exports) {
 
   Object.defineProperty(exports, "__esModule", {
     value: true
   });
 
   function read(directory, settings, callback) {
-    if (!settings.stats && constants$3.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
+    if (!settings.stats && constants$4.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
       return readdirWithFileTypes(directory, settings, callback);
     }
 
@@ -32525,19 +33470,19 @@ var async$1 = createCommonjsModule(function (module, exports) {
     callback(null, result);
   }
 });
-unwrapExports(async$1);
-var async_1$1 = async$1.read;
-var async_2 = async$1.readdirWithFileTypes;
-var async_3 = async$1.readdir;
+unwrapExports(async$2);
+var async_1$1 = async$2.read;
+var async_2 = async$2.readdirWithFileTypes;
+var async_3 = async$2.readdir;
 
-var sync$1 = createCommonjsModule(function (module, exports) {
+var sync$2 = createCommonjsModule(function (module, exports) {
 
   Object.defineProperty(exports, "__esModule", {
     value: true
   });
 
   function read(directory, settings) {
-    if (!settings.stats && constants$3.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
+    if (!settings.stats && constants$4.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
       return readdirWithFileTypes(directory, settings);
     }
 
@@ -32595,10 +33540,10 @@ var sync$1 = createCommonjsModule(function (module, exports) {
 
   exports.readdir = readdir;
 });
-unwrapExports(sync$1);
-var sync_1$1 = sync$1.read;
-var sync_2 = sync$1.readdirWithFileTypes;
-var sync_3 = sync$1.readdir;
+unwrapExports(sync$2);
+var sync_1$1 = sync$2.read;
+var sync_2 = sync$2.readdirWithFileTypes;
+var sync_3 = sync$2.readdir;
 
 var fs_1$3 = createCommonjsModule(function (module, exports) {
 
@@ -32606,12 +33551,12 @@ var fs_1$3 = createCommonjsModule(function (module, exports) {
     value: true
   });
   exports.FILE_SYSTEM_ADAPTER = {
-    lstat: fs$2.lstat,
-    stat: fs$2.stat,
-    lstatSync: fs$2.lstatSync,
-    statSync: fs$2.statSync,
-    readdir: fs$2.readdir,
-    readdirSync: fs$2.readdirSync
+    lstat: fs$3.lstat,
+    stat: fs$3.stat,
+    lstatSync: fs$3.lstatSync,
+    statSync: fs$3.statSync,
+    readdir: fs$3.readdir,
+    readdirSync: fs$3.readdirSync
   };
 
   function createFileSystemAdapter(fsMethods) {
@@ -32639,7 +33584,7 @@ var settings$1 = createCommonjsModule(function (module, exports) {
       this._options = _options;
       this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
       this.fs = fs_1$3.createFileSystemAdapter(this._options.fs);
-      this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$1.sep);
+      this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$2.sep);
       this.stats = this._getValue(this._options.stats, false);
       this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
       this.fsStatSettings = new out.Settings({
@@ -32668,17 +33613,17 @@ var out$1 = createCommonjsModule(function (module, exports) {
 
   function scandir(path, optionsOrSettingsOrCallback, callback) {
     if (typeof optionsOrSettingsOrCallback === 'function') {
-      return async$1.read(path, getSettings(), optionsOrSettingsOrCallback);
+      return async$2.read(path, getSettings(), optionsOrSettingsOrCallback);
     }
 
-    async$1.read(path, getSettings(optionsOrSettingsOrCallback), callback);
+    async$2.read(path, getSettings(optionsOrSettingsOrCallback), callback);
   }
 
   exports.scandir = scandir;
 
   function scandirSync(path, optionsOrSettings) {
     const settings = getSettings(optionsOrSettings);
-    return sync$1.read(path, settings);
+    return sync$2.read(path, settings);
   }
 
   exports.scandirSync = scandirSync;
@@ -32960,7 +33905,7 @@ var reader = createCommonjsModule(function (module, exports) {
 });
 unwrapExports(reader);
 
-var async$2 = createCommonjsModule(function (module, exports) {
+var async$3 = createCommonjsModule(function (module, exports) {
 
   Object.defineProperty(exports, "__esModule", {
     value: true
@@ -32971,7 +33916,7 @@ var async$2 = createCommonjsModule(function (module, exports) {
       super(_root, _settings);
       this._settings = _settings;
       this._scandir = out$1.scandir;
-      this._emitter = new events.EventEmitter();
+      this._emitter = new events$1.EventEmitter();
       this._queue = queue(this._worker.bind(this), this._settings.concurrency);
       this._isFatalError = false;
       this._isDestroyed = false;
@@ -33080,9 +34025,9 @@ var async$2 = createCommonjsModule(function (module, exports) {
 
   exports.default = AsyncReader;
 });
-unwrapExports(async$2);
+unwrapExports(async$3);
 
-var async$3 = createCommonjsModule(function (module, exports) {
+var async$4 = createCommonjsModule(function (module, exports) {
 
   Object.defineProperty(exports, "__esModule", {
     value: true
@@ -33092,7 +34037,7 @@ var async$3 = createCommonjsModule(function (module, exports) {
     constructor(_root, _settings) {
       this._root = _root;
       this._settings = _settings;
-      this._reader = new async$2.default(this._root, this._settings);
+      this._reader = new async$3.default(this._root, this._settings);
       this._storage = new Set();
     }
 
@@ -33124,9 +34069,9 @@ var async$3 = createCommonjsModule(function (module, exports) {
     callback(null, entries);
   }
 });
-unwrapExports(async$3);
+unwrapExports(async$4);
 
-var stream$1 = createCommonjsModule(function (module, exports) {
+var stream$2 = createCommonjsModule(function (module, exports) {
 
   Object.defineProperty(exports, "__esModule", {
     value: true
@@ -33136,8 +34081,8 @@ var stream$1 = createCommonjsModule(function (module, exports) {
     constructor(_root, _settings) {
       this._root = _root;
       this._settings = _settings;
-      this._reader = new async$2.default(this._root, this._settings);
-      this._stream = new stream$5.Readable({
+      this._reader = new async$3.default(this._root, this._settings);
+      this._stream = new stream$6.Readable({
         objectMode: true,
         read: () => {},
         destroy: this._reader.destroy.bind(this._reader)
@@ -33166,9 +34111,9 @@ var stream$1 = createCommonjsModule(function (module, exports) {
 
   exports.default = StreamProvider;
 });
-unwrapExports(stream$1);
+unwrapExports(stream$2);
 
-var sync$2 = createCommonjsModule(function (module, exports) {
+var sync$3 = createCommonjsModule(function (module, exports) {
 
   Object.defineProperty(exports, "__esModule", {
     value: true
@@ -33247,9 +34192,9 @@ var sync$2 = createCommonjsModule(function (module, exports) {
 
   exports.default = SyncReader;
 });
-unwrapExports(sync$2);
+unwrapExports(sync$3);
 
-var sync$3 = createCommonjsModule(function (module, exports) {
+var sync$4 = createCommonjsModule(function (module, exports) {
 
   Object.defineProperty(exports, "__esModule", {
     value: true
@@ -33259,7 +34204,7 @@ var sync$3 = createCommonjsModule(function (module, exports) {
     constructor(_root, _settings) {
       this._root = _root;
       this._settings = _settings;
-      this._reader = new sync$2.default(this._root, this._settings);
+      this._reader = new sync$3.default(this._root, this._settings);
     }
 
     read() {
@@ -33270,7 +34215,7 @@ var sync$3 = createCommonjsModule(function (module, exports) {
 
   exports.default = SyncProvider;
 });
-unwrapExports(sync$3);
+unwrapExports(sync$4);
 
 var settings$2 = createCommonjsModule(function (module, exports) {
 
@@ -33286,7 +34231,7 @@ var settings$2 = createCommonjsModule(function (module, exports) {
       this.deepFilter = this._getValue(this._options.deepFilter, null);
       this.entryFilter = this._getValue(this._options.entryFilter, null);
       this.errorFilter = this._getValue(this._options.errorFilter, null);
-      this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$1.sep);
+      this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$2.sep);
       this.fsScandirSettings = new out$1.Settings({
         followSymbolicLinks: this._options.followSymbolicLinks,
         fs: this._options.fs,
@@ -33315,17 +34260,17 @@ var out$2 = createCommonjsModule(function (module, exports) {
 
   function walk(directory, optionsOrSettingsOrCallback, callback) {
     if (typeof optionsOrSettingsOrCallback === 'function') {
-      return new async$3.default(directory, getSettings()).read(optionsOrSettingsOrCallback);
+      return new async$4.default(directory, getSettings()).read(optionsOrSettingsOrCallback);
     }
 
-    new async$3.default(directory, getSettings(optionsOrSettingsOrCallback)).read(callback);
+    new async$4.default(directory, getSettings(optionsOrSettingsOrCallback)).read(callback);
   }
 
   exports.walk = walk;
 
   function walkSync(directory, optionsOrSettings) {
     const settings = getSettings(optionsOrSettings);
-    const provider = new sync$3.default(directory, settings);
+    const provider = new sync$4.default(directory, settings);
     return provider.read();
   }
 
@@ -33333,7 +34278,7 @@ var out$2 = createCommonjsModule(function (module, exports) {
 
   function walkStream(directory, optionsOrSettings) {
     const settings = getSettings(optionsOrSettings);
-    const provider = new stream$1.default(directory, settings);
+    const provider = new stream$2.default(directory, settings);
     return provider.read();
   }
 
@@ -33370,7 +34315,7 @@ var reader$1 = createCommonjsModule(function (module, exports) {
     }
 
     _getFullEntryPath(filepath) {
-      return path$1.resolve(this._settings.cwd, filepath);
+      return path$2.resolve(this._settings.cwd, filepath);
     }
 
     _makeEntry(stats, pattern) {
@@ -33397,7 +34342,7 @@ var reader$1 = createCommonjsModule(function (module, exports) {
 });
 unwrapExports(reader$1);
 
-var stream$2 = createCommonjsModule(function (module, exports) {
+var stream$3 = createCommonjsModule(function (module, exports) {
 
   Object.defineProperty(exports, "__esModule", {
     value: true
@@ -33416,7 +34361,7 @@ var stream$2 = createCommonjsModule(function (module, exports) {
 
     static(patterns, options) {
       const filepaths = patterns.map(this._getFullEntryPath, this);
-      const stream = new stream$5.PassThrough({
+      const stream = new stream$6.PassThrough({
         objectMode: true
       });
 
@@ -33463,7 +34408,7 @@ var stream$2 = createCommonjsModule(function (module, exports) {
 
   exports.default = ReaderStream;
 });
-unwrapExports(stream$2);
+unwrapExports(stream$3);
 
 var matcher = createCommonjsModule(function (module, exports) {
 
@@ -33823,7 +34768,7 @@ var provider = createCommonjsModule(function (module, exports) {
     }
 
     _getRootDirectory(task) {
-      return path$1.resolve(this._settings.cwd, task.base);
+      return path$2.resolve(this._settings.cwd, task.base);
     }
 
     _getReaderOptions(task) {
@@ -33862,7 +34807,7 @@ var provider = createCommonjsModule(function (module, exports) {
 });
 unwrapExports(provider);
 
-var async$4 = createCommonjsModule(function (module, exports) {
+var async$5 = createCommonjsModule(function (module, exports) {
 
   Object.defineProperty(exports, "__esModule", {
     value: true
@@ -33871,7 +34816,7 @@ var async$4 = createCommonjsModule(function (module, exports) {
   class ProviderAsync extends provider.default {
     constructor() {
       super(...arguments);
-      this._reader = new stream$2.default(this._settings);
+      this._reader = new stream$3.default(this._settings);
     }
 
     read(task) {
@@ -33900,9 +34845,9 @@ var async$4 = createCommonjsModule(function (module, exports) {
 
   exports.default = ProviderAsync;
 });
-unwrapExports(async$4);
+unwrapExports(async$5);
 
-var stream$3 = createCommonjsModule(function (module, exports) {
+var stream$4 = createCommonjsModule(function (module, exports) {
 
   Object.defineProperty(exports, "__esModule", {
     value: true
@@ -33911,7 +34856,7 @@ var stream$3 = createCommonjsModule(function (module, exports) {
   class ProviderStream extends provider.default {
     constructor() {
       super(...arguments);
-      this._reader = new stream$2.default(this._settings);
+      this._reader = new stream$3.default(this._settings);
     }
 
     read(task) {
@@ -33920,7 +34865,7 @@ var stream$3 = createCommonjsModule(function (module, exports) {
       const options = this._getReaderOptions(task);
 
       const source = this.api(root, task, options);
-      const destination = new stream$5.Readable({
+      const destination = new stream$6.Readable({
         objectMode: true,
         read: () => {}
       });
@@ -33941,9 +34886,9 @@ var stream$3 = createCommonjsModule(function (module, exports) {
 
   exports.default = ProviderStream;
 });
-unwrapExports(stream$3);
+unwrapExports(stream$4);
 
-var sync$4 = createCommonjsModule(function (module, exports) {
+var sync$5 = createCommonjsModule(function (module, exports) {
 
   Object.defineProperty(exports, "__esModule", {
     value: true
@@ -34000,9 +34945,9 @@ var sync$4 = createCommonjsModule(function (module, exports) {
 
   exports.default = ReaderSync;
 });
-unwrapExports(sync$4);
+unwrapExports(sync$5);
 
-var sync$5 = createCommonjsModule(function (module, exports) {
+var sync$6 = createCommonjsModule(function (module, exports) {
 
   Object.defineProperty(exports, "__esModule", {
     value: true
@@ -34011,7 +34956,7 @@ var sync$5 = createCommonjsModule(function (module, exports) {
   class ProviderSync extends provider.default {
     constructor() {
       super(...arguments);
-      this._reader = new sync$4.default(this._settings);
+      this._reader = new sync$5.default(this._settings);
     }
 
     read(task) {
@@ -34035,21 +34980,21 @@ var sync$5 = createCommonjsModule(function (module, exports) {
 
   exports.default = ProviderSync;
 });
-unwrapExports(sync$5);
+unwrapExports(sync$6);
 
 var settings$3 = createCommonjsModule(function (module, exports) {
 
   Object.defineProperty(exports, "__esModule", {
     value: true
   });
-  const CPU_COUNT = os.cpus().length;
+  const CPU_COUNT = os$1.cpus().length;
   exports.DEFAULT_FILE_SYSTEM_ADAPTER = {
-    lstat: fs$2.lstat,
-    lstatSync: fs$2.lstatSync,
-    stat: fs$2.stat,
-    statSync: fs$2.statSync,
-    readdir: fs$2.readdir,
-    readdirSync: fs$2.readdirSync
+    lstat: fs$3.lstat,
+    lstatSync: fs$3.lstatSync,
+    stat: fs$3.stat,
+    statSync: fs$3.statSync,
+    readdir: fs$3.readdir,
+    readdirSync: fs$3.readdirSync
   };
 
   class Settings {
@@ -34103,7 +35048,7 @@ var settings_1 = settings$3.DEFAULT_FILE_SYSTEM_ADAPTER;
 
 async function FastGlob(source, options) {
   assertPatternsInput(source);
-  const works = getWorks(source, async$4.default, options);
+  const works = getWorks(source, async$5.default, options);
   const result = await Promise.all(works);
   return utils$4.array.flatten(result);
 } // https://github.com/typescript-eslint/typescript-eslint/issues/60
@@ -34113,7 +35058,7 @@ async function FastGlob(source, options) {
 (function (FastGlob) {
   function sync(source, options) {
     assertPatternsInput(source);
-    const works = getWorks(source, sync$5.default, options);
+    const works = getWorks(source, sync$6.default, options);
     return utils$4.array.flatten(works);
   }
 
@@ -34121,7 +35066,7 @@ async function FastGlob(source, options) {
 
   function stream(source, options) {
     assertPatternsInput(source);
-    const works = getWorks(source, stream$3.default, options);
+    const works = getWorks(source, stream$4.default, options);
     /**
      * The stream returned by the provider cannot work with an asynchronous iterator.
      * To support asynchronous iterators, regardless of the number of tasks, we always multiplex streams.
@@ -34179,7 +35124,7 @@ var out$3 = FastGlob;
 
 const {
   promisify
-} = util$3;
+} = util$4;
 
 async function isType(fsStatType, statsMethodName, filePath) {
   if (typeof filePath !== 'string') {
@@ -34187,7 +35132,7 @@ async function isType(fsStatType, statsMethodName, filePath) {
   }
 
   try {
-    const stats = await promisify(fs$2[fsStatType])(filePath);
+    const stats = await promisify(fs$3[fsStatType])(filePath);
     return stats[statsMethodName]();
   } catch (error) {
     if (error.code === 'ENOENT') {
@@ -34204,7 +35149,7 @@ function isTypeSync(fsStatType, statsMethodName, filePath) {
   }
 
   try {
-    return fs$2[fsStatType](filePath)[statsMethodName]();
+    return fs$3[fsStatType](filePath)[statsMethodName]();
   } catch (error) {
     if (error.code === 'ENOENT') {
       return false;
@@ -34233,11 +35178,11 @@ const getExtensions = extensions => extensions.length > 1 ? `{${extensions.join(
 
 const getPath = (filepath, cwd) => {
   const pth = filepath[0] === '!' ? filepath.slice(1) : filepath;
-  return path$1.isAbsolute(pth) ? pth : path$1.join(cwd, pth);
+  return path$2.isAbsolute(pth) ? pth : path$2.join(cwd, pth);
 };
 
 const addExtensions = (file, extensions) => {
-  if (path$1.extname(file)) {
+  if (path$2.extname(file)) {
     return `**/${file}`;
   }
 
@@ -34254,18 +35199,18 @@ const getGlob = (directory, options) => {
   }
 
   if (options.files && options.extensions) {
-    return options.files.map(x => path$1.posix.join(directory, addExtensions(x, options.extensions)));
+    return options.files.map(x => path$2.posix.join(directory, addExtensions(x, options.extensions)));
   }
 
   if (options.files) {
-    return options.files.map(x => path$1.posix.join(directory, `**/${x}`));
+    return options.files.map(x => path$2.posix.join(directory, `**/${x}`));
   }
 
   if (options.extensions) {
-    return [path$1.posix.join(directory, `**/*.${getExtensions(options.extensions)}`)];
+    return [path$2.posix.join(directory, `**/*.${getExtensions(options.extensions)}`)];
   }
 
-  return [path$1.posix.join(directory, '**')];
+  return [path$2.posix.join(directory, '**')];
 };
 
 var dirGlob = async (input, options) => {
@@ -34284,7 +35229,7 @@ var dirGlob = async (input, options) => {
   return [].concat.apply([], globs); // eslint-disable-line prefer-spread
 };
 
-var sync$6 = (input, options) => {
+var sync$7 = (input, options) => {
   options = Object.assign({
     cwd: process.cwd()
   }, options);
@@ -34296,7 +35241,7 @@ var sync$6 = (input, options) => {
   const globs = [].concat(input).map(x => pathType.isDirectorySync(getPath(x, options.cwd)) ? getGlob(x, options) : x);
   return [].concat.apply([], globs); // eslint-disable-line prefer-spread
 };
-dirGlob.sync = sync$6;
+dirGlob.sync = sync$7;
 
 // A simple implementation of make-array
 function makeArray(subject) {
@@ -34707,20 +35652,20 @@ var slash$1 = path => {
 
 const {
   promisify: promisify$1
-} = util$3;
+} = util$4;
 const DEFAULT_IGNORE = ['**/node_modules/**', '**/flow-typed/**', '**/coverage/**', '**/.git'];
-const readFileP = promisify$1(fs$2.readFile);
+const readFileP = promisify$1(fs$3.readFile);
 
 const mapGitIgnorePatternTo = base => ignore => {
   if (ignore.startsWith('!')) {
-    return '!' + path$1.posix.join(base, ignore.slice(1));
+    return '!' + path$2.posix.join(base, ignore.slice(1));
   }
 
-  return path$1.posix.join(base, ignore);
+  return path$2.posix.join(base, ignore);
 };
 
 const parseGitIgnore = (content, options) => {
-  const base = slash$1(path$1.relative(options.cwd, path$1.dirname(options.fileName)));
+  const base = slash$1(path$2.relative(options.cwd, path$2.dirname(options.fileName)));
   return content.split(/\r?\n/).filter(Boolean).filter(line => !line.startsWith('#')).map(mapGitIgnorePatternTo(base));
 };
 
@@ -34735,7 +35680,7 @@ const reduceIgnore = files => {
 };
 
 const ensureAbsolutePathForCwd = (cwd, p) => {
-  if (path$1.isAbsolute(p)) {
+  if (path$2.isAbsolute(p)) {
     if (p.startsWith(cwd)) {
       return p;
     }
@@ -34743,15 +35688,15 @@ const ensureAbsolutePathForCwd = (cwd, p) => {
     throw new Error(`Path ${p} is not in cwd ${cwd}`);
   }
 
-  return path$1.join(cwd, p);
+  return path$2.join(cwd, p);
 };
 
 const getIsIgnoredPredecate = (ignores, cwd) => {
-  return p => ignores.ignores(slash$1(path$1.relative(cwd, ensureAbsolutePathForCwd(cwd, p))));
+  return p => ignores.ignores(slash$1(path$2.relative(cwd, ensureAbsolutePathForCwd(cwd, p))));
 };
 
 const getFile = async (file, cwd) => {
-  const filePath = path$1.join(cwd, file);
+  const filePath = path$2.join(cwd, file);
   const content = await readFileP(filePath, 'utf8');
   return {
     cwd,
@@ -34761,8 +35706,8 @@ const getFile = async (file, cwd) => {
 };
 
 const getFileSync = (file, cwd) => {
-  const filePath = path$1.join(cwd, file);
-  const content = fs$2.readFileSync(filePath, 'utf8');
+  const filePath = path$2.join(cwd, file);
+  const content = fs$3.readFileSync(filePath, 'utf8');
   return {
     cwd,
     filePath,
@@ -34770,7 +35715,7 @@ const getFileSync = (file, cwd) => {
   };
 };
 
-const normalizeOptions$2 = ({
+const normalizeOptions$3 = ({
   ignore = [],
   cwd = slash$1(process.cwd())
 } = {}) => {
@@ -34781,7 +35726,7 @@ const normalizeOptions$2 = ({
 };
 
 var gitignore = async options => {
-  options = normalizeOptions$2(options);
+  options = normalizeOptions$3(options);
   const paths = await out$3('**/.gitignore', {
     ignore: DEFAULT_IGNORE.concat(options.ignore),
     cwd: options.cwd
@@ -34791,8 +35736,8 @@ var gitignore = async options => {
   return getIsIgnoredPredecate(ignores, options.cwd);
 };
 
-var sync$7 = options => {
-  options = normalizeOptions$2(options);
+var sync$8 = options => {
+  options = normalizeOptions$3(options);
   const paths = out$3.sync('**/.gitignore', {
     ignore: DEFAULT_IGNORE.concat(options.ignore),
     cwd: options.cwd
@@ -34801,11 +35746,11 @@ var sync$7 = options => {
   const ignores = reduceIgnore(files);
   return getIsIgnoredPredecate(ignores, options.cwd);
 };
-gitignore.sync = sync$7;
+gitignore.sync = sync$8;
 
 const {
   Transform
-} = stream$5;
+} = stream$6;
 
 class ObjectTransform extends Transform {
   constructor() {
@@ -34878,7 +35823,7 @@ const checkCwdOption = (options = {}) => {
   let stat;
 
   try {
-    stat = fs$2.statSync(options.cwd);
+    stat = fs$3.statSync(options.cwd);
   } catch (_) {
     return;
   }
@@ -34888,7 +35833,7 @@ const checkCwdOption = (options = {}) => {
   }
 };
 
-const getPathString = p => p.stats instanceof fs$2.Stats ? p.path : p;
+const getPathString = p => p.stats instanceof fs$3.Stats ? p.path : p;
 
 const generateGlobTasks = (patterns, taskOptions) => {
   patterns = arrayUnion([].concat(patterns));
@@ -34983,7 +35928,7 @@ var globby$1 = async (patterns, options) => {
   return arrayUnion(...paths).filter(path_ => !filter(getPathString(path_)));
 };
 
-var sync$8 = (patterns, options) => {
+var sync$9 = (patterns, options) => {
   const globTasks = generateGlobTasks(patterns, options);
   const tasks = globTasks.reduce((tasks, task) => {
     const newTask = getPattern(task, dirGlob.sync).map(globToTask(task));
@@ -34993,7 +35938,7 @@ var sync$8 = (patterns, options) => {
   return tasks.reduce((matches, task) => arrayUnion(matches, out$3.sync(task.pattern, task.options)), []).filter(path_ => !filter(path_));
 };
 
-var stream$4 = (patterns, options) => {
+var stream$5 = (patterns, options) => {
   const globTasks = generateGlobTasks(patterns, options);
   const tasks = globTasks.reduce((tasks, task) => {
     const newTask = getPattern(task, dirGlob.sync).map(globToTask(task));
@@ -35010,8 +35955,8 @@ var generateGlobTasks_1 = generateGlobTasks;
 var hasMagic = (patterns, options) => [].concat(patterns).some(pattern => out$3.isDynamicPattern(pattern, options));
 
 var gitignore_1 = gitignore;
-globby$1.sync = sync$8;
-globby$1.stream = stream$4;
+globby$1.sync = sync$9;
+globby$1.stream = stream$5;
 globby$1.generateGlobTasks = generateGlobTasks_1;
 globby$1.hasMagic = hasMagic;
 globby$1.gitignore = gitignore_1;
@@ -36213,7 +37158,7 @@ var build = createCommonjsModule(function (module, exports) {
   exports.print = print;
 
   function _os() {
-    const data = os;
+    const data = os$1;
 
     _os = function () {
       return data;
@@ -37472,7 +38417,7 @@ function needsParens(path, options) {
             }
 
             if (pp === np && name === "right") {
-              assert.strictEqual(parent.right, node);
+              assert$1.strictEqual(parent.right, node);
               return true;
             }
 
@@ -39972,7 +40917,7 @@ function printPathNoParens(path, options, print, args) {
       return nodeStr(n, options);
 
     case "NumberLiteralTypeAnnotation":
-      assert.strictEqual(typeof n.value, "number");
+      assert$1.strictEqual(typeof n.value, "number");
 
       if (n.extra != null) {
         return printNumber$1(n.extra.raw);
@@ -40589,7 +41534,7 @@ function printMethod(path, options, print) {
       parts.push("*");
     }
   } else {
-    assert.ok(kind === "get" || kind === "set");
+    assert$1.ok(kind === "get" || kind === "set");
     parts.push(kind, " ");
   }
 
@@ -41072,7 +42017,7 @@ function printFlowDeclaration(path, parts) {
   const parentExportDecl = getParentExportDeclaration$1(path);
 
   if (parentExportDecl) {
-    assert.strictEqual(parentExportDecl.type, "DeclareExportDeclaration");
+    assert$1.strictEqual(parentExportDecl.type, "DeclareExportDeclaration");
   } else {
     // If the parent node has type DeclareExportDeclaration, then it
     // will be responsible for printing the "declare" token. Otherwise
@@ -42907,7 +43852,7 @@ const DELIMITER_MAP = {
   "+++": "toml"
 };
 
-function parse$4(text) {
+function parse$5(text) {
   const delimiterRegex = Object.keys(DELIMITER_MAP).map(escapeStringRegexp$2).join("|");
   const match = text.match( // trailing spaces after delimiters are allowed
   new RegExp(`^(${delimiterRegex})[^\\n\\S]*\\n(?:([\\s\\S]*?)\\n)?\\1[^\\n\\S]*(\\n|$)`));
@@ -42930,7 +43875,7 @@ function parse$4(text) {
   };
 }
 
-var frontMatter = parse$4;
+var frontMatter = parse$5;
 
 function hasPragma$1(text) {
   return pragma.hasPragma(frontMatter(text).content);
@@ -47012,7 +47957,7 @@ var colgroup = [
 	"valign",
 	"width"
 ];
-var data = [
+var data$1 = [
 	"value"
 ];
 var del$1 = [
@@ -47505,7 +48450,7 @@ var index$1 = {
 	caption: caption,
 	col: col,
 	colgroup: colgroup,
-	data: data,
+	data: data$1,
 	del: del$1,
 	details: details,
 	dfn: dfn,
@@ -47588,7 +48533,7 @@ var htmlElementAttributes = /*#__PURE__*/Object.freeze({
     caption: caption,
     col: col,
     colgroup: colgroup,
-    data: data,
+    data: data$1,
     del: del$1,
     details: details,
     dfn: dfn,
@@ -48648,7 +49593,7 @@ function deepUnique(array) {
   });
 }
 
-var parse$5 = string => {
+var parse$6 = string => {
   return deepUnique(string.split(',').map(part => {
     const result = {};
     part.trim().split(/\s+/).forEach((element, index) => {
@@ -48701,7 +49646,7 @@ var stringify$2 = array => {
 };
 
 var srcset = {
-  parse: parse$5,
+  parse: parse$6,
   stringify: stringify$2
 };
 
@@ -49276,7 +50221,7 @@ function printOpeningTagStartMarker(node) {
 }
 
 function printOpeningTagEndMarker(node) {
-  assert(!node.isSelfClosing);
+  assert$1(!node.isSelfClosing);
 
   switch (node.type) {
     case "ieConditionalComment":
@@ -49295,7 +50240,7 @@ function printOpeningTagEndMarker(node) {
 }
 
 function printClosingTagStartMarker(node, options) {
-  assert(!node.isSelfClosing);
+  assert$1(!node.isSelfClosing);
 
   if (shouldNotPrintClosingTag$1(node, options)) {
     return "";
@@ -50643,7 +51588,7 @@ function load(plugins, pluginSearchDirs) {
 
     try {
       // try local files
-      requirePath = resolve_1(path$1.resolve(process.cwd(), pluginName));
+      requirePath = resolve_1(path$2.resolve(process.cwd(), pluginName));
     } catch (_) {
       // try node modules
       requirePath = resolve_1(pluginName, {
@@ -50657,8 +51602,8 @@ function load(plugins, pluginSearchDirs) {
     };
   });
   const externalAutoLoadPluginInfos = pluginSearchDirs.map(pluginSearchDir => {
-    const resolvedPluginSearchDir = path$1.resolve(process.cwd(), pluginSearchDir);
-    const nodeModulesDir = path$1.resolve(resolvedPluginSearchDir, "node_modules"); // In some fringe cases (ex: files "mounted" as virtual directories), the
+    const resolvedPluginSearchDir = path$2.resolve(process.cwd(), pluginSearchDir);
+    const nodeModulesDir = path$2.resolve(resolvedPluginSearchDir, "node_modules"); // In some fringe cases (ex: files "mounted" as virtual directories), the
     // isDirectory(resolvedPluginSearchDir) check might be false even though
     // the node_modules actually exists.
 
@@ -50684,12 +51629,12 @@ function findPluginsInNodeModules(nodeModulesDir) {
     cwd: nodeModulesDir,
     expandDirectories: false
   });
-  return pluginPackageJsonPaths.map(path$1.dirname);
+  return pluginPackageJsonPaths.map(path$2.dirname);
 }
 
 function isDirectory$1(dir) {
   try {
-    return fs$2.statSync(dir).isDirectory();
+    return fs$3.statSync(dir).isDirectory();
   } catch (e) {
     return false;
   }
@@ -51027,7 +51972,7 @@ value = function () {
 // functions and variables.
 
 
-var parse$6 = function (source, reviver) {
+var parse$7 = function (source, reviver) {
   var result;
   text = source;
   at = 0;
@@ -51221,10 +52166,10 @@ var stringify$3 = function (value, replacer, space) {
   });
 };
 
-var parse$7 = parse$6;
+var parse$8 = parse$7;
 var stringify$4 = stringify$3;
 var jsonify = {
-  parse: parse$7,
+  parse: parse$8,
   stringify: stringify$4
 };
 
@@ -52145,7 +53090,7 @@ function* expandPatterns(context) {
       continue;
     }
 
-    const relativePath = path$1.relative(cwd, pathOrError); // filter out duplicates
+    const relativePath = path$2.relative(cwd, pathOrError); // filter out duplicates
 
     if (seen.has(relativePath)) {
       continue;
@@ -52186,7 +53131,7 @@ function* expandPatternsInternal(context) {
   const entries = [];
 
   for (const pattern of context.filePatterns) {
-    const absolutePath = path$1.resolve(cwd, pattern);
+    const absolutePath = path$2.resolve(cwd, pattern);
 
     if (containsIgnoredPathSegment(absolutePath, cwd, silentlyIgnoredDirs)) {
       continue;
@@ -52277,7 +53222,7 @@ const errorMessages = {
  */
 
 function containsIgnoredPathSegment(absolutePath, cwd, ignoredDirectories) {
-  return path$1.relative(cwd, absolutePath).split(path$1.sep).some(dir => ignoredDirectories[dir]);
+  return path$2.relative(cwd, absolutePath).split(path$2.sep).some(dir => ignoredDirectories[dir]);
 }
 /**
  * @param {string[]} paths
@@ -52296,7 +53241,7 @@ function sortPaths(paths) {
 
 function statSafeSync(filePath) {
   try {
-    return fs$2.statSync(filePath);
+    return fs$3.statSync(filePath);
   } catch (error) {
     /* istanbul ignore next */
     if (error.code !== "ENOENT") {
@@ -52318,7 +53263,7 @@ function escapePathForGlob(path) {
   .replace(/\0/g, "@(\\\\)"); // Workaround for fast-glob#262 (part 2)
 }
 
-const isWindows = path$1.sep === "\\";
+const isWindows = path$2.sep === "\\";
 /**
  * Using backslashes in globs is probably not okay, but not accepting
  * backslashes as path separators on Windows is even more not okay.
@@ -52573,8 +53518,8 @@ function diff(a, b) {
 function handleError(context, filename, error) {
   if (error instanceof errors.UndefinedParserError) {
     if (context.argv.write && isTty()) {
-      readline.clearLine(process.stdout, 0);
-      readline.cursorTo(process.stdout, 0, null);
+      readline$1.clearLine(process.stdout, 0);
+      readline$1.cursorTo(process.stdout, 0, null);
     }
 
     if (!context.argv.check && !context.argv["list-different"]) {
@@ -52617,7 +53562,7 @@ function logResolvedConfigPathOrDie(context) {
   const configFile = prettier.resolveConfigFile.sync(context.argv["find-config-path"]);
 
   if (configFile) {
-    context.logger.log(path$1.relative(process.cwd(), configFile));
+    context.logger.log(path$2.relative(process.cwd(), configFile));
   } else {
     process.exit(1);
   }
@@ -52835,11 +53780,11 @@ function applyConfigPrecedence(context, options) {
 }
 
 function formatStdin(context) {
-  const filepath = context.argv["stdin-filepath"] ? path$1.resolve(process.cwd(), context.argv["stdin-filepath"]) : process.cwd();
+  const filepath = context.argv["stdin-filepath"] ? path$2.resolve(process.cwd(), context.argv["stdin-filepath"]) : process.cwd();
   const ignorer = createIgnorerFromContextOrDie(context); // If there's an ignore-path set, the filename must be relative to the
   // ignore path, not the current working directory.
 
-  const relativeFilepath = context.argv["ignore-path"] ? path$1.relative(path$1.dirname(context.argv["ignore-path"]), filepath) : path$1.relative(process.cwd(), filepath);
+  const relativeFilepath = context.argv["ignore-path"] ? path$2.relative(path$2.dirname(context.argv["ignore-path"]), filepath) : path$2.relative(process.cwd(), filepath);
   thirdParty.getStream(process.stdin).then(input => {
     if (relativeFilepath && ignorer.filter([relativeFilepath]).length === 0) {
       writeOutput(context, {
@@ -52890,7 +53835,7 @@ function formatFiles(context) {
     const filename = pathOrError; // If there's an ignore-path set, the filename must be relative to the
     // ignore path, not the current working directory.
 
-    const ignoreFilename = context.argv["ignore-path"] ? path$1.relative(path$1.dirname(context.argv["ignore-path"]), filename) : filename;
+    const ignoreFilename = context.argv["ignore-path"] ? path$2.relative(path$2.dirname(context.argv["ignore-path"]), filename) : filename;
     const fileIgnored = ignorer.filter([ignoreFilename]).length === 0;
 
     if (fileIgnored && (context.argv["debug-check"] || context.argv.write || context.argv.check || context.argv["list-different"])) {
@@ -52910,7 +53855,7 @@ function formatFiles(context) {
     let input;
 
     try {
-      input = fs$2.readFileSync(filename, "utf8");
+      input = fs$3.readFileSync(filename, "utf8");
     } catch (error) {
       // Add newline to split errors from filename line.
       context.logger.log("");
@@ -52943,8 +53888,8 @@ function formatFiles(context) {
 
     if (isTty()) {
       // Remove previously printed filename to log it with duration.
-      readline.clearLine(process.stdout, 0);
-      readline.cursorTo(process.stdout, 0, null);
+      readline$1.clearLine(process.stdout, 0);
+      readline$1.cursorTo(process.stdout, 0, null);
     }
 
     if (context.argv.write) {
@@ -52956,7 +53901,7 @@ function formatFiles(context) {
         }
 
         try {
-          fs$2.writeFileSync(filename, output, "utf8");
+          fs$3.writeFileSync(filename, output, "utf8");
         } catch (error) {
           context.logger.error(`Unable to write file: ${filename}\n${error.message}`); // Don't exit the process if one file failed
 
@@ -53318,7 +54263,7 @@ function normalizeContextArgv(context, keys) {
 } //------------------------------context-util-end--------------------------------
 
 
-var util$2 = {
+var util$3 = {
   createContext,
   createDetailedOptionMap,
   createDetailedUsage,
@@ -53335,10 +54280,10 @@ var util$2 = {
 pleaseUpgradeNode(require$$1);
 
 function run(args) {
-  const context = util$2.createContext(args);
+  const context = util$3.createContext(args);
 
   try {
-    util$2.initContext(context);
+    util$3.initContext(context);
     context.logger.debug(`normalized argv: ${JSON.stringify(context.argv)}`);
 
     if (context.argv.check && context.argv["list-different"]) {
@@ -53367,7 +54312,7 @@ function run(args) {
     }
 
     if (context.argv.help !== undefined) {
-      context.logger.log(typeof context.argv.help === "string" && context.argv.help !== "" ? util$2.createDetailedUsage(context, context.argv.help) : util$2.createUsage(context));
+      context.logger.log(typeof context.argv.help === "string" && context.argv.help !== "" ? util$3.createDetailedUsage(context, context.argv.help) : util$3.createUsage(context));
       process.exit(0);
     }
 
@@ -53382,15 +54327,15 @@ function run(args) {
     const useStdin = !hasFilePatterns && (!process.stdin.isTTY || context.args["stdin-filepath"]);
 
     if (context.argv["find-config-path"]) {
-      util$2.logResolvedConfigPathOrDie(context);
+      util$3.logResolvedConfigPathOrDie(context);
     } else if (context.argv["file-info"]) {
-      util$2.logFileInfoOrDie(context);
+      util$3.logFileInfoOrDie(context);
     } else if (useStdin) {
-      util$2.formatStdin(context);
+      util$3.formatStdin(context);
     } else if (hasFilePatterns) {
-      util$2.formatFiles(context);
+      util$3.formatFiles(context);
     } else {
-      context.logger.log(util$2.createUsage(context));
+      context.logger.log(util$3.createUsage(context));
       process.exit(1);
     }
   } catch (error) {