prettier 2.0.1 → 2.0.5

package/index.js

@@ -2,17 +2,17 @@
 
 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$2 = _interopDefault(require('util'));
-var stream$5 = _interopDefault(require('stream'));
-var events = _interopDefault(require('events'));
+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$3 = _interopDefault(require('util'));
+var stream$6 = _interopDefault(require('stream'));
+var events$1 = _interopDefault(require('events'));
 
 var name = "prettier";
-var version = "2.0.1";
+var version = "2.0.5";
 var description = "Prettier is an opinionated code formatter";
 var bin = "./bin/prettier.js";
 var repository = "prettier/prettier";
@@ -26,14 +26,14 @@ var engines = {
 var dependencies = {
 	"@angular/compiler": "9.0.5",
 	"@babel/code-frame": "7.8.0",
-	"@babel/parser": "7.9.2",
-	"@glimmer/syntax": "0.48.0",
+	"@babel/parser": "7.9.4",
+	"@glimmer/syntax": "0.50.0",
 	"@iarna/toml": "2.2.3",
-	"@typescript-eslint/typescript-estree": "2.24.0",
+	"@typescript-eslint/typescript-estree": "2.26.0",
 	"angular-estree-parser": "1.3.0",
 	"angular-html-parser": "1.4.0",
 	camelcase: "5.3.1",
-	chalk: "3.0.0",
+	chalk: "4.0.0",
 	"ci-info": "watson/ci-info#f43f6a1cefff47fb361c88cf4b943fdbcaafe540",
 	"cjk-regex": "2.0.0",
 	cosmiconfig: "6.0.0",
@@ -47,24 +47,25 @@ var dependencies = {
 	"fast-glob": "3.2.2",
 	"find-parent-dir": "0.3.0",
 	"find-project-root": "1.1.1",
-	"flow-parser": "0.121.0",
+	"flow-parser": "0.122.0",
 	"get-stream": "5.1.0",
 	globby: "11.0.0",
-	graphql: "14.6.0",
+	graphql: "15.0.0",
 	"html-element-attributes": "2.2.1",
 	"html-styles": "1.0.0",
 	"html-tag-names": "1.1.5",
 	ignore: "4.0.6",
-	"jest-docblock": "25.1.0",
+	"jest-docblock": "25.2.6",
 	"json-stable-stringify": "1.0.1",
 	leven: "3.1.0",
 	"lines-and-columns": "1.1.6",
-	"linguist-languages": "7.8.0",
+	"linguist-languages": "7.9.0",
 	lodash: "4.17.15",
 	mem: "6.0.1",
 	minimatch: "3.0.4",
 	minimist: "1.2.5",
 	"n-readlines": "1.0.0",
+	"please-upgrade-node": "3.2.0",
 	"postcss-less": "3.1.4",
 	"postcss-media-query-parser": "0.2.3",
 	"postcss-scss": "2.0.0",
@@ -73,45 +74,45 @@ 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",
 	typescript: "3.8.3",
 	"unicode-regex": "3.0.0",
-	unified: "8.4.2",
+	unified: "9.0.0",
 	vnopts: "1.0.2",
 	"yaml-unist-parser": "1.1.1"
 };
 var devDependencies = {
-	"@babel/core": "7.8.7",
-	"@babel/preset-env": "7.8.7",
+	"@babel/core": "7.9.0",
+	"@babel/preset-env": "7.9.0",
 	"@rollup/plugin-alias": "3.0.1",
 	"@rollup/plugin-commonjs": "11.0.2",
 	"@rollup/plugin-json": "4.0.2",
 	"@rollup/plugin-node-resolve": "7.1.1",
 	"@rollup/plugin-replace": "2.3.1",
-	"babel-loader": "8.0.6",
+	"babel-loader": "8.1.0",
 	benchmark: "2.1.4",
 	"builtin-modules": "3.1.0",
 	codecov: "3.6.5",
 	"cross-env": "7.0.2",
 	cspell: "4.0.55",
 	eslint: "6.8.0",
-	"eslint-config-prettier": "6.10.0",
+	"eslint-config-prettier": "6.10.1",
 	"eslint-formatter-friendly": "7.0.0",
-	"eslint-plugin-import": "2.20.1",
+	"eslint-plugin-import": "2.20.2",
 	"eslint-plugin-prettier": "3.1.2",
 	"eslint-plugin-react": "7.19.0",
-	"eslint-plugin-unicorn": "17.2.0",
+	"eslint-plugin-unicorn": "18.0.1",
 	execa: "4.0.0",
-	jest: "25.1.0",
-	"jest-junit": "10.0.0",
+	jest: "25.2.7",
 	"jest-snapshot-serializer-ansi": "1.0.0",
 	"jest-snapshot-serializer-raw": "1.1.0",
-	"jest-watch-typeahead": "0.4.2",
-	prettier: "2.0.0",
+	"jest-watch-typeahead": "0.5.0",
+	prettier: "2.0.4",
 	rimraf: "3.0.2",
-	rollup: "2.1.0",
+	rollup: "2.3.2",
 	"rollup-plugin-babel": "4.4.0",
 	"rollup-plugin-node-globals": "1.4.0",
 	"rollup-plugin-terser": "5.3.0",
@@ -121,13 +122,14 @@ var devDependencies = {
 	"synchronous-promise": "2.0.10",
 	tempy: "0.5.0",
 	"terser-webpack-plugin": "2.3.5",
-	webpack: "4.42.0"
+	webpack: "4.42.1"
 };
 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",
@@ -137,7 +139,7 @@ var scripts = {
 	"lint:changelog": "node ./scripts/lint-changelog.js",
 	"lint:prettier": "prettier \"**/*.{md,json,yml,html,css}\" --check",
 	"lint:dist": "eslint --no-eslintrc --no-ignore --env=es6,browser --parser-options=ecmaVersion:2016 \"dist/!(bin-prettier|index|third-party).js\"",
-	"lint:spellcheck": "cspell {bin,scripts,src}/**/*.js {docs,website/blog,changelog_unreleased}/**/*.md",
+	"lint:spellcheck": "cspell {bin,scripts,src,website}/**/*.js {docs,website/blog,changelog_unreleased}/**/*.md",
 	"lint:deps": "node ./scripts/check-deps.js",
 	build: "node --max-old-space-size=3072 ./scripts/build/build.js",
 	"build-docs": "node ./scripts/build-docs.js"
@@ -1744,7 +1746,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;
@@ -1774,7 +1776,7 @@ class LineByLine {
   }
 
   close() {
-    fs$2.closeSync(this.fd);
+    fs$3.closeSync(this.fd);
     this.fd = null;
   }
 
@@ -1812,7 +1814,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);
@@ -4787,7 +4789,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;
@@ -7714,7 +7716,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;
@@ -7778,8 +7780,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) => {
@@ -7826,7 +7828,7 @@ var util = {
 const TEMPLATE_REGEX$1 = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
 const STYLE_REGEX$1 = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
 const STRING_REGEX$1 = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
-const ESCAPE_REGEX$1 = /\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.)|([^\\])/gi;
+const ESCAPE_REGEX$1 = /\\(u(?:[a-f\d]{4}|{[a-f\d]{1,6}})|x[a-f\d]{2}|.)|([^\\])/gi;
 const ESCAPES$1 = new Map([['n', '\n'], ['r', '\r'], ['t', '\t'], ['b', '\b'], ['f', '\f'], ['v', '\v'], ['0', '\0'], ['\\', '\\'], ['e', '\u001B'], ['a', '\u0007']]);
 
 function unescape$1(c) {
@@ -7940,8 +7942,8 @@ var templates$1 = (chalk, temporary) => {
   chunks.push(chunk.join(''));
 
   if (styles.length > 0) {
-    const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
-    throw new Error(errMsg);
+    const errMessage = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
+    throw new Error(errMessage);
   }
 
   return chunks.join('');
@@ -7960,7 +7962,7 @@ const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m'];
 const styles = Object.create(null);
 
 const applyOptions = (object, options = {}) => {
-  if (options.level > 3 || options.level < 0) {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
     throw new Error('The `level` option should be an integer from 0 to 3');
   } // Detect level if not set manually
 
@@ -7971,6 +7973,7 @@ const applyOptions = (object, options = {}) => {
 
 class ChalkClass {
   constructor(options) {
+    // eslint-disable-next-line no-constructor-return
     return chalkFactory(options);
   }
 
@@ -8094,12 +8097,11 @@ const createBuilder = (self, _styler, _isEmpty) => {
     // Single argument is hot path, implicit coercion is faster than anything
     // eslint-disable-next-line no-implicit-coercion
     return applyStyle(builder, arguments_.length === 1 ? '' + arguments_[0] : arguments_.join(' '));
-  }; // `__proto__` is used because we must return a function, but there is
+  }; // We alter the prototype because we must return a function, but there is
   // no way to create a function with a different prototype
 
 
-  builder.__proto__ = proto; // eslint-disable-line no-proto
-
+  Object.setPrototypeOf(builder, proto);
   builder._generator = self;
   builder._styler = _styler;
   builder._isEmpty = _isEmpty;
@@ -8177,18 +8179,7 @@ chalk$1.stderr = Chalk({
   level: stderrColor ? stderrColor.level : 0
 }); // eslint-disable-line new-cap
 
-chalk$1.stderr.supportsColor = stderrColor; // For TypeScript
-
-chalk$1.Level = {
-  None: 0,
-  Basic: 1,
-  Ansi256: 2,
-  TrueColor: 3,
-  0: 'None',
-  1: 'Basic',
-  2: 'Ansi256',
-  3: 'TrueColor'
-};
+chalk$1.stderr.supportsColor = stderrColor;
 var source = chalk$1;
 
 const cliDescriptor = {
@@ -10498,7 +10489,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;
@@ -11342,7 +11333,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
@@ -11498,8 +11489,9 @@ function getInterpreter(filepath) {
   let fd;
 
   try {
-    fd = fs$2.openSync(filepath, "r");
+    fd = fs$3.openSync(filepath, "r");
   } catch (err) {
+    // istanbul ignore next
     return "";
   }
 
@@ -11529,20 +11521,27 @@ 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(); // If the file has no extension, we can try to infer the language from the
+  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
   // interpreter in the shebang line, if any; but since this requires FS access,
   // do it last.
 
-  const language = getSupportInfo$1({
-    plugins
-  }).languages.find(language => language.since !== null && (language.extensions && language.extensions.some(extension => filename.endsWith(extension)) || language.filenames && language.filenames.find(name => name.toLowerCase() === filename) || !filename.includes(".") && language.interpreters && language.interpreters.includes(getInterpreter(filepath))));
+  let language = languages.find(language => language.extensions && language.extensions.some(extension => filename.endsWith(extension)) || language.filenames && language.filenames.find(name => name.toLowerCase() === filename));
+
+  if (!language && !filename.includes(".")) {
+    const interpreter = getInterpreter(filepath);
+    language = languages.find(language => language.interpreters && language.interpreters.includes(interpreter));
+  }
+
   return language && language.parsers[0];
 }
 
@@ -12636,7 +12635,11 @@ function hasIgnoreComment(path) {
 }
 
 function hasNodeIgnoreComment(node) {
-  return node && node.comments && node.comments.length > 0 && node.comments.some(comment => comment.value.trim() === "prettier-ignore");
+  return node && (node.comments && node.comments.length > 0 && node.comments.some(comment => isNodeIgnoreComment(comment) && !comment.unignore) || node.prettierIgnore);
+}
+
+function isNodeIgnoreComment(comment) {
+  return comment.value.trim() === "prettier-ignore";
 }
 
 function addCommentHelper(node, comment) {
@@ -12736,6 +12739,7 @@ var util$1 = {
   printNumber,
   hasIgnoreComment,
   hasNodeIgnoreComment,
+  isNodeIgnoreComment,
   makeString,
   addLeadingComment,
   addDanglingComment,
@@ -13048,8 +13052,9 @@ function printDocToString(doc, options) {
     const [ind, mode, doc] = cmds.pop();
 
     if (typeof doc === "string") {
-      out.push(doc);
-      pos += getStringWidth$1(doc);
+      const formatted = newLine !== "\n" && doc.includes("\n") ? doc.replace(/\n/g, newLine) : doc;
+      out.push(formatted);
+      pos += getStringWidth$1(formatted);
     } else {
       switch (doc.type) {
         case "cursor":
@@ -14029,8 +14034,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)) {
@@ -14538,7 +14543,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
@@ -14717,9 +14722,6 @@ const {
   convertEndOfLineToChars: convertEndOfLineToChars$2
 } = endOfLine;
 const {
-  utils: {
-    mapDoc: mapDoc$1
-  },
   printer: {
     printDocToString: printDocToString$1
   },
@@ -14741,7 +14743,7 @@ function ensureAllCommentsPrinted(astComments) {
   }
 
   for (let i = 0; i < astComments.length; ++i) {
-    if (astComments[i].value.trim() === "prettier-ignore") {
+    if (util$1.isNodeIgnoreComment(astComments[i])) {
       // If there's a prettier-ignore, we're not printing that sub-tree so we
       // don't know if the comments was printed or not.
       return;
@@ -14795,8 +14797,7 @@ function coreFormat(text, opts, addAlignmentSize) {
 
   const astComments = attachComments(text, ast, opts);
   const doc = astToDoc(ast, opts, addAlignmentSize);
-  const eol = convertEndOfLineToChars$2(opts.endOfLine);
-  const result = printDocToString$1(opts.endOfLine === "lf" ? doc : mapDoc$1(doc, currentDoc => typeof currentDoc === "string" && currentDoc.includes("\n") ? currentDoc.replace(/\n/g, eol) : currentDoc), opts);
+  const result = printDocToString$1(doc, opts);
   ensureAllCommentsPrinted(astComments); // Remove extra leading indentation as well as the added indentation after last newline
 
   if (addAlignmentSize > 0) {
@@ -15401,7 +15402,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 {
@@ -15418,7 +15419,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;
@@ -15441,7 +15442,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);
 }
 /**
@@ -15451,7 +15452,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);
 };
 /**
@@ -15729,7 +15730,7 @@ var path = {
 };
 
 try {
-  path = path$1;
+  path = path$2;
 } catch (er) {}
 
 var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
@@ -19155,7 +19156,7 @@ LRUCache.prototype.inspect = function (n, opts) {
       str += ',';
     }
 
-    str += '\n  max: ' + util$2.inspect(max, opts);
+    str += '\n  max: ' + util$3.inspect(max, opts);
     extras = true;
   }
 
@@ -19166,7 +19167,7 @@ LRUCache.prototype.inspect = function (n, opts) {
       str += ',';
     }
 
-    str += '\n  maxAge: ' + util$2.inspect(maxAge, opts);
+    str += '\n  maxAge: ' + util$3.inspect(maxAge, opts);
     extras = true;
   }
 
@@ -19177,7 +19178,7 @@ LRUCache.prototype.inspect = function (n, opts) {
       str += ',';
     }
 
-    str += '\n  length: ' + util$2.inspect(this[LENGTH], opts);
+    str += '\n  length: ' + util$3.inspect(this[LENGTH], opts);
     extras = true;
   }
 
@@ -19194,7 +19195,7 @@ LRUCache.prototype.inspect = function (n, opts) {
       str += '\n  ';
     }
 
-    var key = util$2.inspect(item.key).split('\n').join('\n  ');
+    var key = util$3.inspect(item.key).split('\n').join('\n  ');
     var val = {
       value: item.value
     };
@@ -19211,7 +19212,7 @@ LRUCache.prototype.inspect = function (n, opts) {
       val.stale = true;
     }
 
-    val = util$2.inspect(val, opts).split('\n').join('\n  ');
+    val = util$3.inspect(val, opts).split('\n').join('\n  ');
     str += key + ' => ' + val;
   });
 
@@ -20270,7 +20271,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) {
@@ -20595,7 +20596,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]
@@ -20925,9 +20926,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);
 
@@ -21294,14 +21295,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);
   }
 }
 
@@ -21327,11 +21328,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);
@@ -21818,7 +21819,7 @@ function isList(obj) {
 let _custom;
 
 try {
-  const utilInspect = util$2.inspect;
+  const utilInspect = util$3.inspect;
   _custom = utilInspect.custom;
 } catch (_) {}
 /* eval require not available in transpiled bundle */
@@ -23257,6 +23258,962 @@ var loadToml = function (filePath, content) {
   }
 };
 
+var caller = function () {
+  // see https://code.google.com/p/v8/wiki/JavaScriptStackTraceApi
+  var origPrepareStackTrace = Error.prepareStackTrace;
+
+  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);
+            }
+
+            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$1;
+
 const getExplorerMemoized = mem_1(opts => {
   const cosmiconfig = thirdParty["cosmiconfig" + (opts.sync ? "Sync" : "")];
   const explorer = cosmiconfig("prettier", {
@@ -23264,13 +24221,12 @@ 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 = require.resolve(result.config, {
+            const modulePath = resolve_1(result.config, {
               paths: [dir]
             });
-
             result.config = require(modulePath);
           } catch (error) {
             // Original message contains `__filename`, can't pass tests
@@ -23329,7 +24285,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);
       }
     });
 
@@ -23389,7 +24345,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)) {
@@ -23504,7 +24460,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;
@@ -26922,7 +27878,7 @@ var arrayUnion = (...arguments_) => {
  */
 
 
-const PassThrough = stream$5.PassThrough;
+const PassThrough = stream$6.PassThrough;
 const slice = Array.prototype.slice;
 var merge2_1 = merge2;
 
@@ -27071,7 +28027,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
@@ -27097,8 +28053,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) {
 
@@ -27119,7 +28075,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;
@@ -27226,8 +28182,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 = /[\{\[].*[\/]*.*[\}\]]$/;
@@ -27863,7 +28819,7 @@ const toRegex = (start, end, options) => {
 };
 
 const rangeError = (...args) => {
-  return new RangeError('Invalid range arguments: ' + util$2.inspect(...args));
+  return new RangeError('Invalid range arguments: ' + util$3.inspect(...args));
 };
 
 const invalidRange = (start, end, options) => {
@@ -28174,7 +29130,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',
@@ -28358,12 +29314,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');
   }
@@ -28713,7 +29669,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.
@@ -28956,7 +29912,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
@@ -29104,7 +30060,7 @@ var constants$2 = {
   CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
 
   /* \uFEFF */
-  SEP: path$1.sep,
+  SEP: path$2.sep,
 
   /**
    * Create EXTGLOB_CHARS
@@ -29156,7 +30112,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);
 
@@ -29189,7 +30145,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) => {
@@ -29280,7 +30236,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;
@@ -29672,7 +30628,7 @@ const {
   REGEX_NON_SPECIAL_CHARS,
   REGEX_SPECIAL_CHARS_BACKREF,
   REPLACEMENTS
-} = constants$2;
+} = constants$3;
 /**
  * Helpers
  */
@@ -29710,7 +30666,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');
   }
@@ -29733,8 +30689,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,
@@ -30790,7 +31746,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;
@@ -30812,7 +31768,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 ? '' : '?:';
@@ -30878,7 +31834,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);
 /**
@@ -31068,7 +32024,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`.
@@ -31243,7 +32199,7 @@ picomatch.toRegex = (source, options) => {
  */
 
 
-picomatch.constants = constants$2;
+picomatch.constants = constants$3;
 /**
  * Expose "picomatch"
  */
@@ -31437,7 +32393,7 @@ micromatch.not = (list, patterns, options = {}) => {
 
 micromatch.contains = (str, pattern, options) => {
   if (typeof str !== 'string') {
-    throw new TypeError(`Expected a string: "${util$2.inspect(str)}"`);
+    throw new TypeError(`Expected a string: "${util$3.inspect(str)}"`);
   }
 
   if (Array.isArray(pattern)) {
@@ -31592,7 +32548,7 @@ micromatch.every = (list, patterns, options) => {
 
 micromatch.all = (str, patterns, options) => {
   if (typeof str !== 'string') {
-    throw new TypeError(`Expected a string: "${util$2.inspect(str)}"`);
+    throw new TypeError(`Expected a string: "${util$3.inspect(str)}"`);
   }
 
   return [].concat(patterns).every(p => picomatch$1(p, options)(str));
@@ -31835,7 +32791,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);
   }
 
@@ -31910,7 +32866,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
@@ -31932,8 +32888,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) {
 
@@ -31964,10 +32920,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);
@@ -32075,7 +33031,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
@@ -32119,10 +33075,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
@@ -32154,8 +33110,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) {
 
@@ -32163,10 +33119,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) {
@@ -32217,17 +33173,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;
@@ -32299,7 +33255,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
@@ -32317,10 +33273,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
@@ -32346,27 +33302,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);
     }
 
@@ -32472,19 +33428,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);
     }
 
@@ -32542,10 +33498,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) {
 
@@ -32553,12 +33509,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) {
@@ -32586,7 +33542,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({
@@ -32615,17 +33571,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;
@@ -32907,7 +33863,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
@@ -32918,7 +33874,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;
@@ -33027,9 +33983,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
@@ -33039,7 +33995,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();
     }
 
@@ -33071,9 +34027,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
@@ -33083,8 +34039,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)
@@ -33113,9 +34069,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
@@ -33194,9 +34150,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
@@ -33206,7 +34162,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() {
@@ -33217,7 +34173,7 @@ var sync$3 = createCommonjsModule(function (module, exports) {
 
   exports.default = SyncProvider;
 });
-unwrapExports(sync$3);
+unwrapExports(sync$4);
 
 var settings$2 = createCommonjsModule(function (module, exports) {
 
@@ -33233,7 +34189,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,
@@ -33262,17 +34218,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();
   }
 
@@ -33280,7 +34236,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();
   }
 
@@ -33317,7 +34273,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) {
@@ -33344,7 +34300,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
@@ -33363,7 +34319,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
       });
 
@@ -33410,7 +34366,7 @@ var stream$2 = createCommonjsModule(function (module, exports) {
 
   exports.default = ReaderStream;
 });
-unwrapExports(stream$2);
+unwrapExports(stream$3);
 
 var matcher = createCommonjsModule(function (module, exports) {
 
@@ -33770,7 +34726,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) {
@@ -33809,7 +34765,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
@@ -33818,7 +34774,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) {
@@ -33847,9 +34803,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
@@ -33858,7 +34814,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) {
@@ -33867,7 +34823,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: () => {}
       });
@@ -33888,9 +34844,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
@@ -33947,9 +34903,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
@@ -33958,7 +34914,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) {
@@ -33982,21 +34938,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 {
@@ -34050,7 +35006,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
@@ -34060,7 +35016,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);
   }
 
@@ -34068,7 +35024,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.
@@ -34126,7 +35082,7 @@ var out$3 = FastGlob;
 
 const {
   promisify
-} = util$2;
+} = util$3;
 
 async function isType(fsStatType, statsMethodName, filePath) {
   if (typeof filePath !== 'string') {
@@ -34134,7 +35090,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') {
@@ -34151,7 +35107,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;
@@ -34180,11 +35136,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}`;
   }
 
@@ -34201,18 +35157,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) => {
@@ -34231,7 +35187,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);
@@ -34243,7 +35199,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) {
@@ -34654,20 +35610,20 @@ var slash$1 = path => {
 
 const {
   promisify: promisify$1
-} = util$2;
+} = util$3;
 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));
 };
 
@@ -34682,7 +35638,7 @@ const reduceIgnore = files => {
 };
 
 const ensureAbsolutePathForCwd = (cwd, p) => {
-  if (path$1.isAbsolute(p)) {
+  if (path$2.isAbsolute(p)) {
     if (p.startsWith(cwd)) {
       return p;
     }
@@ -34690,15 +35646,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,
@@ -34708,8 +35664,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,
@@ -34717,7 +35673,7 @@ const getFileSync = (file, cwd) => {
   };
 };
 
-const normalizeOptions$2 = ({
+const normalizeOptions$3 = ({
   ignore = [],
   cwd = slash$1(process.cwd())
 } = {}) => {
@@ -34728,7 +35684,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
@@ -34738,8 +35694,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
@@ -34748,11 +35704,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() {
@@ -34825,7 +35781,7 @@ const checkCwdOption = (options = {}) => {
   let stat;
 
   try {
-    stat = fs$2.statSync(options.cwd);
+    stat = fs$3.statSync(options.cwd);
   } catch (_) {
     return;
   }
@@ -34835,7 +35791,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));
@@ -34930,7 +35886,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));
@@ -34940,7 +35896,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));
@@ -34957,8 +35913,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;
@@ -35336,8 +36292,22 @@ function handleCallExpressionComments(precedingNode, enclosingNode, comment) {
 
 function handleUnionTypeComments(precedingNode, enclosingNode, followingNode, comment) {
   if (enclosingNode && (enclosingNode.type === "UnionTypeAnnotation" || enclosingNode.type === "TSUnionType")) {
-    addTrailingComment$3(precedingNode, comment);
-    return true;
+    if (util$1.isNodeIgnoreComment(comment)) {
+      followingNode.prettierIgnore = true;
+      comment.unignore = true;
+    }
+
+    if (precedingNode) {
+      addTrailingComment$3(precedingNode, comment);
+      return true;
+    }
+
+    return false;
+  }
+
+  if (followingNode && (followingNode.type === "UnionTypeAnnotation" || followingNode.type === "TSUnionType") && util$1.isNodeIgnoreComment(comment)) {
+    followingNode.types[0].prettierIgnore = true;
+    comment.unignore = true;
   }
 
   return false;
@@ -35523,7 +36493,7 @@ const {
     dedentToRoot: dedentToRoot$1
   },
   utils: {
-    mapDoc: mapDoc$2,
+    mapDoc: mapDoc$1,
     stripTrailingHardline: stripTrailingHardline$1
   }
 } = document;
@@ -35546,7 +36516,7 @@ function embed(path, print, textToDoc, options) {
             return idx === 0 ? currVal : prevVal + "@prettier-placeholder-" + placeholderID++ + "-id" + currVal;
           }, "");
           const doc = textToDoc(text, {
-            parser: "css"
+            parser: "scss"
           });
           return transformCssDoc(doc, path, print);
         }
@@ -35672,7 +36642,7 @@ function uncook(cookedValue) {
 }
 
 function escapeTemplateCharacters(doc, raw) {
-  return mapDoc$2(doc, currentDoc => {
+  return mapDoc$1(doc, currentDoc => {
     if (!currentDoc.parts) {
       return currentDoc;
     }
@@ -35721,7 +36691,7 @@ function replacePlaceholders(quasisDoc, expressionDocs) {
 
   const expressions = expressionDocs.slice();
   let replaceCounter = 0;
-  const newDoc = mapDoc$2(quasisDoc, doc => {
+  const newDoc = mapDoc$1(quasisDoc, doc => {
     if (!doc || !doc.parts || !doc.parts.length) {
       return doc;
     }
@@ -35936,7 +36906,7 @@ function printHtmlTemplateLiteral(path, print, textToDoc, parser, options) {
 
   const placeholderRegex = new RegExp(composePlaceholder("(\\d+)"), "g");
   let topLevelCount = 0;
-  const contentDoc = mapDoc$2(stripTrailingHardline$1(textToDoc(text, {
+  const contentDoc = mapDoc$1(stripTrailingHardline$1(textToDoc(text, {
     parser,
 
     __onHtmlRoot(root) {
@@ -36146,7 +37116,7 @@ var build = createCommonjsModule(function (module, exports) {
   exports.print = print;
 
   function _os() {
-    const data = os;
+    const data = os$1;
 
     _os = function () {
       return data;
@@ -36506,8 +37476,10 @@ function isTypeAnnotationAFunction(node, options) {
   return (node.type === "TypeAnnotation" || node.type === "TSTypeAnnotation") && node.typeAnnotation.type === "FunctionTypeAnnotation" && !node.static && !sameLocStart(node, node.typeAnnotation, options);
 }
 
+const binaryishNodeTypes = new Set(["BinaryExpression", "LogicalExpression", "NGPipeExpression"]);
+
 function isBinaryish(node) {
-  return node.type === "BinaryExpression" || node.type === "LogicalExpression" || node.type === "NGPipeExpression";
+  return binaryishNodeTypes.has(node.type);
 }
 
 function isMemberish(node) {
@@ -37060,7 +38032,7 @@ function isSimpleCallArgument(node, depth) {
   }
 
   if (node.type === "ArrayExpression") {
-    return node.elements.every(isChildSimple);
+    return node.elements.every(x => x == null || isChildSimple(x));
   }
 
   if (node.type === "CallExpression" || node.type === "OptionalCallExpression" || node.type === "NewExpression") {
@@ -37403,7 +38375,7 @@ function needsParens(path, options) {
             }
 
             if (pp === np && name === "right") {
-              assert.strictEqual(parent.right, node);
+              assert$1.strictEqual(parent.right, node);
               return true;
             }
 
@@ -37734,7 +38706,7 @@ function needsParens(path, options) {
 }
 
 function isStatement(node) {
-  return node.type === "BlockStatement" || node.type === "BreakStatement" || node.type === "ClassBody" || node.type === "ClassDeclaration" || node.type === "ClassMethod" || node.type === "ClassProperty" || node.type === "ClassPrivateProperty" || node.type === "ContinueStatement" || node.type === "DebuggerStatement" || node.type === "DeclareClass" || node.type === "DeclareExportAllDeclaration" || node.type === "DeclareExportDeclaration" || node.type === "DeclareFunction" || node.type === "DeclareInterface" || node.type === "DeclareModule" || node.type === "DeclareModuleExports" || node.type === "DeclareVariable" || node.type === "DoWhileStatement" || node.type === "EnumDeclaration" || node.type === "ExportAllDeclaration" || node.type === "ExportDefaultDeclaration" || node.type === "ExportNamedDeclaration" || node.type === "ExpressionStatement" || node.type === "ForAwaitStatement" || node.type === "ForInStatement" || node.type === "ForOfStatement" || node.type === "ForStatement" || node.type === "FunctionDeclaration" || node.type === "IfStatement" || node.type === "ImportDeclaration" || node.type === "InterfaceDeclaration" || node.type === "LabeledStatement" || node.type === "MethodDefinition" || node.type === "ReturnStatement" || node.type === "SwitchStatement" || node.type === "ThrowStatement" || node.type === "TryStatement" || node.type === "TSDeclareFunction" || node.type === "TSEnumDeclaration" || node.type === "TSImportEqualsDeclaration" || node.type === "TSInterfaceDeclaration" || node.type === "TSModuleDeclaration" || node.type === "TSNamespaceExportDeclaration" || node.type === "TypeAlias" || node.type === "VariableDeclaration" || node.type === "WhileStatement" || node.type === "WithStatement";
+  return node.type === "BlockStatement" || node.type === "BreakStatement" || node.type === "ClassBody" || node.type === "ClassDeclaration" || node.type === "ClassMethod" || node.type === "ClassProperty" || node.type === "ClassPrivateProperty" || node.type === "ContinueStatement" || node.type === "DebuggerStatement" || node.type === "DeclareClass" || node.type === "DeclareExportAllDeclaration" || node.type === "DeclareExportDeclaration" || node.type === "DeclareFunction" || node.type === "DeclareInterface" || node.type === "DeclareModule" || node.type === "DeclareModuleExports" || node.type === "DeclareVariable" || node.type === "DoWhileStatement" || node.type === "EnumDeclaration" || node.type === "ExportAllDeclaration" || node.type === "ExportDefaultDeclaration" || node.type === "ExportNamedDeclaration" || node.type === "ExpressionStatement" || node.type === "ForInStatement" || node.type === "ForOfStatement" || node.type === "ForStatement" || node.type === "FunctionDeclaration" || node.type === "IfStatement" || node.type === "ImportDeclaration" || node.type === "InterfaceDeclaration" || node.type === "LabeledStatement" || node.type === "MethodDefinition" || node.type === "ReturnStatement" || node.type === "SwitchStatement" || node.type === "ThrowStatement" || node.type === "TryStatement" || node.type === "TSDeclareFunction" || node.type === "TSEnumDeclaration" || node.type === "TSImportEqualsDeclaration" || node.type === "TSInterfaceDeclaration" || node.type === "TSModuleDeclaration" || node.type === "TSNamespaceExportDeclaration" || node.type === "TypeAlias" || node.type === "VariableDeclaration" || node.type === "WhileStatement" || node.type === "WithStatement";
 }
 
 function includesFunctionTypeInObjectType(node) {
@@ -38273,7 +39245,9 @@ function printPathNoParens(path, options, print, args) {
       /* sameIndent */
       true)); // Only force a trailing newline if there were any contents.
 
-      if (n.body.length || n.comments) {
+      if (!n.body.every(({
+        type
+      }) => type === "EmptyStatement") || n.comments) {
         parts.push(hardline$4);
       }
 
@@ -38448,7 +39422,6 @@ function printPathNoParens(path, options, print, args) {
 
     case "SpreadElement":
     case "SpreadElementPattern":
-    case "RestProperty":
     case "SpreadProperty":
     case "SpreadPropertyPattern":
     case "RestElement":
@@ -38815,11 +39788,23 @@ function printPathNoParens(path, options, print, args) {
         });
 
         if (n.inexact) {
-          props.push(concat$6(separatorParts.concat(group$2("..."))));
+          let printed;
+
+          if (hasDanglingComments$1(n)) {
+            const hasLineComments = !n.comments.every(comments$1.isBlockComment);
+            const printedDanglingComments = comments.printDanglingComments(path, options,
+            /* sameIndent */
+            true);
+            printed = concat$6([printedDanglingComments, hasLineComments || hasNewline$4(options.originalText, options.locEnd(n.comments[n.comments.length - 1])) ? hardline$4 : line$4, "..."]);
+          } else {
+            printed = "...";
+          }
+
+          props.push(concat$6(separatorParts.concat(printed)));
         }
 
         const lastElem = getLast$2(n[propertiesField]);
-        const canHaveTrailingSeparator = !(lastElem && (lastElem.type === "RestProperty" || lastElem.type === "RestElement" || hasNodeIgnoreComment$2(lastElem) || n.inexact));
+        const canHaveTrailingSeparator = !(n.inexact || lastElem && (lastElem.type === "RestElement" || hasNodeIgnoreComment$2(lastElem)));
         let content;
 
         if (props.length === 0) {
@@ -39058,7 +40043,7 @@ function printPathNoParens(path, options, print, args) {
         // semicolon, except when they in the () part of for loops.
 
         const parentNode = path.getParentNode();
-        const isParentForLoop = parentNode.type === "ForStatement" || parentNode.type === "ForInStatement" || parentNode.type === "ForOfStatement" || parentNode.type === "ForAwaitStatement";
+        const isParentForLoop = parentNode.type === "ForStatement" || parentNode.type === "ForInStatement" || parentNode.type === "ForOfStatement";
         const hasValue = n.declarations.some(decl => decl.init);
         let firstVariable;
 
@@ -39142,14 +40127,7 @@ function printPathNoParens(path, options, print, args) {
       return group$2(concat$6([n.each ? "for each (" : "for (", path.call(print, "left"), " in ", path.call(print, "right"), ")", adjustClause(n.body, path.call(print, "body"))]));
 
     case "ForOfStatement":
-    case "ForAwaitStatement":
-      {
-        // Babel 7 removed ForAwaitStatement in favor of ForOfStatement
-        // with `"await": true`:
-        // https://github.com/estree/estree/pull/138
-        const isAwait = n.type === "ForAwaitStatement" || n.await;
-        return group$2(concat$6(["for", isAwait ? " await" : "", " (", path.call(print, "left"), " of ", path.call(print, "right"), ")", adjustClause(n.body, path.call(print, "body"))]));
-      }
+      return group$2(concat$6(["for", n.await ? " await" : "", " (", path.call(print, "left"), " of ", path.call(print, "right"), ")", adjustClause(n.body, path.call(print, "body"))]));
 
     case "DoWhileStatement":
       {
@@ -39299,8 +40277,8 @@ function printPathNoParens(path, options, print, args) {
     case "JSXExpressionContainer":
       {
         const parent = path.getParentNode(0);
-        const preventInline = parent.type === "JSXAttribute" && n.expression.comments && n.expression.comments.length > 0;
-        const shouldInline = !preventInline && (n.expression.type === "ArrayExpression" || n.expression.type === "ObjectExpression" || n.expression.type === "ArrowFunctionExpression" || n.expression.type === "CallExpression" || n.expression.type === "OptionalCallExpression" || n.expression.type === "FunctionExpression" || n.expression.type === "JSXEmptyExpression" || n.expression.type === "TemplateLiteral" || n.expression.type === "TaggedTemplateExpression" || n.expression.type === "DoExpression" || isJSXNode$1(parent) && (n.expression.type === "ConditionalExpression" || isBinaryish$1(n.expression)));
+        const hasComments = n.expression.comments && n.expression.comments.length > 0;
+        const shouldInline = n.expression.type === "JSXEmptyExpression" || !hasComments && (n.expression.type === "ArrayExpression" || n.expression.type === "ObjectExpression" || n.expression.type === "ArrowFunctionExpression" || n.expression.type === "CallExpression" || n.expression.type === "OptionalCallExpression" || n.expression.type === "FunctionExpression" || n.expression.type === "TemplateLiteral" || n.expression.type === "TaggedTemplateExpression" || n.expression.type === "DoExpression" || isJSXNode$1(parent) && (n.expression.type === "ConditionalExpression" || isBinaryish$1(n.expression)));
 
         if (shouldInline) {
           return group$2(concat$6(["{", path.call(print, "expression"), lineSuffixBoundary$1, "}"]));
@@ -39506,7 +40484,7 @@ function printPathNoParens(path, options, print, args) {
             if (!isSimple) {
               // Breaks at the template element boundaries (${ and }) are preferred to breaking
               // in the middle of a MemberExpression
-              if (n.expressions[i].comments && n.expressions[i].comments.length || n.expressions[i].type === "MemberExpression" || n.expressions[i].type === "OptionalMemberExpression" || n.expressions[i].type === "ConditionalExpression" || n.expressions[i].type === "LogicalExpression" || n.expressions[i].type === "BinaryExpression" || n.expressions[i].type === "SequenceExpression" || n.expressions[i].type === "TSAsExpression") {
+              if (n.expressions[i].comments && n.expressions[i].comments.length || n.expressions[i].type === "MemberExpression" || n.expressions[i].type === "OptionalMemberExpression" || n.expressions[i].type === "ConditionalExpression" || n.expressions[i].type === "SequenceExpression" || n.expressions[i].type === "TSAsExpression" || isBinaryish$1(n.expressions[i])) {
                 printed = concat$6([indent$3(concat$6([softline$2, printed])), softline$2]);
               }
             }
@@ -39897,7 +40875,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);
@@ -40139,8 +41117,13 @@ function printPathNoParens(path, options, print, args) {
 
     case "TSIndexSignature":
       {
-        const parent = path.getParentNode();
-        const parametersGroup = group$2(concat$6([indent$3(concat$6([softline$2, join$4(concat$6([", ", softline$2]), path.map(print, "parameters"))])), ifBreak$1(shouldPrintComma(options) ? "," : ""), softline$2]));
+        const parent = path.getParentNode(); // The typescript parser accepts multiple parameters here. If you're
+        // using them, it makes sense to have a trailing comma. But if you
+        // aren't, this is more like a computed property name than an array.
+        // So we leave off the trailing comma when there's just one parameter.
+
+        const trailingComma = n.parameters.length > 1 ? ifBreak$1(shouldPrintComma(options) ? "," : "") : "";
+        const parametersGroup = group$2(concat$6([indent$3(concat$6([softline$2, join$4(concat$6([", ", softline$2]), path.map(print, "parameters"))])), trailingComma, softline$2]));
         return concat$6([n.export ? "export " : "", n.accessibility ? concat$6([n.accessibility, " "]) : "", n.static ? "static " : "", n.readonly ? "readonly " : "", "[", n.parameters ? parametersGroup : "", n.typeAnnotation ? "]: " : "]", n.typeAnnotation ? path.call(print, "typeAnnotation") : "", parent.type === "ClassBody" ? semi : ""]);
       }
 
@@ -40347,7 +41330,7 @@ function printPathNoParens(path, options, print, args) {
       return "";
 
     case "NGQuotedExpression":
-      return concat$6([n.prefix, ":", n.value]);
+      return concat$6([n.prefix, ": ", n.value.trim()]);
 
     case "NGMicrosyntax":
       return concat$6(path.map((childPath, index) => concat$6([index === 0 ? "" : isNgForOf$1(childPath.getValue(), index, n) ? " " : concat$6([";", line$4]), print(childPath)]), "body"));
@@ -40509,7 +41492,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, " ");
   }
 
@@ -40992,7 +41975,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
@@ -41904,7 +42887,7 @@ function printReturnAndThrowArgument(path, options, print) {
   if (node.argument) {
     if (returnArgumentHasLeadingComment$1(options, node.argument)) {
       parts.push(concat$6([" (", indent$3(concat$6([hardline$4, path.call(print, "argument")])), hardline$4, ")"]));
-    } else if (node.argument.type === "LogicalExpression" || node.argument.type === "BinaryExpression" || node.argument.type === "SequenceExpression") {
+    } else if (isBinaryish$1(node.argument) || node.argument.type === "SequenceExpression") {
       parts.push(group$2(concat$6([ifBreak$1(" (", " "), indent$3(concat$6([softline$2, path.call(print, "argument")])), softline$2, ifBreak$1(")")])));
     } else {
       parts.push(" ", path.call(print, "argument"));
@@ -41936,7 +42919,7 @@ function willPrintOwnComments(path
 ) {
   const node = path.getValue();
   const parent = path.getParentNode();
-  return (node && (isJSXNode$1(node) || hasFlowShorthandAnnotationComment$2(node) || parent && (parent.type === "CallExpression" || parent.type === "OptionalCallExpression") && (hasFlowAnnotationComment$1(node.leadingComments) || hasFlowAnnotationComment$1(node.trailingComments))) || parent && (parent.type === "JSXSpreadAttribute" || parent.type === "JSXSpreadChild" || parent.type === "UnionTypeAnnotation" || parent.type === "TSUnionType" || (parent.type === "ClassDeclaration" || parent.type === "ClassExpression") && parent.superClass === node)) && !hasIgnoreComment$2(path);
+  return (node && (isJSXNode$1(node) || hasFlowShorthandAnnotationComment$2(node) || parent && (parent.type === "CallExpression" || parent.type === "OptionalCallExpression") && (hasFlowAnnotationComment$1(node.leadingComments) || hasFlowAnnotationComment$1(node.trailingComments))) || parent && (parent.type === "JSXSpreadAttribute" || parent.type === "JSXSpreadChild" || parent.type === "UnionTypeAnnotation" || parent.type === "TSUnionType" || (parent.type === "ClassDeclaration" || parent.type === "ClassExpression") && parent.superClass === node)) && (!hasIgnoreComment$2(path) || parent.type === "UnionTypeAnnotation" || parent.type === "TSUnionType");
 }
 
 function canAttachComment(node) {
@@ -42516,6 +43499,7 @@ var aliases$2 = [
 	"jsonc"
 ];
 var extensions$5 = [
+	".jsonc",
 	".sublime-build",
 	".sublime-commands",
 	".sublime-completions",
@@ -42797,7 +43781,7 @@ const {
     markAsRoot: markAsRoot$1
   },
   utils: {
-    mapDoc: mapDoc$3
+    mapDoc: mapDoc$2
   }
 } = document;
 
@@ -42815,7 +43799,7 @@ function embed$1(path, print, textToDoc
   return null;
 
   function replaceNewlinesWithLiterallines(doc) {
-    return mapDoc$3(doc, currentDoc => typeof currentDoc === "string" && currentDoc.includes("\n") ? concat$8(currentDoc.split(/(\n)/g).map((v, i) => i % 2 === 0 ? v : literalline$3)) : currentDoc);
+    return mapDoc$2(doc, currentDoc => typeof currentDoc === "string" && currentDoc.includes("\n") ? concat$8(currentDoc.split(/(\n)/g).map((v, i) => i % 2 === 0 ? v : literalline$3)) : currentDoc);
   }
 }
 
@@ -42826,7 +43810,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|$)`));
@@ -42849,7 +43833,7 @@ function parse$4(text) {
   };
 }
 
-var frontMatter = parse$4;
+var frontMatter = parse$5;
 
 function hasPragma$1(text) {
   return pragma.hasPragma(frontMatter(text).content);
@@ -43100,7 +44084,7 @@ function getPropOfDeclNode(path) {
 
 function isSCSS(parser, text) {
   const hasExplicitParserChoice = parser === "less" || parser === "scss";
-  const IS_POSSIBLY_SCSS = /(\w\s*: [^}:]+|#){|@import[^\n]+(url|,)/;
+  const IS_POSSIBLY_SCSS = /(\w\s*:\s*[^}:]+|#){|@import[^\n]+(?:url|,)/;
   return hasExplicitParserChoice ? parser === "scss" : IS_POSSIBLY_SCSS.test(text);
 }
 
@@ -43544,7 +44528,7 @@ function genericPrint$2(path, options, print) {
         return concat$9(["@", // If a Less file ends up being parsed with the SCSS parser, Less
         // variable declarations will be parsed as at-rules with names ending
         // with a colon, so keep the original case then.
-        isDetachedRulesetCallNode$1(node) || node.name.endsWith(":") ? node.name : maybeToLowerCase$1(node.name), node.params ? concat$9([isDetachedRulesetCallNode$1(node) ? "" : isTemplatePlaceholderNode$1(node) && /^\s*\n/.test(node.raws.afterName) ? /^\s*\n\s*\n/.test(node.raws.afterName) ? concat$9([hardline$7, hardline$7]) : hardline$7 : " ", path.call(print, "params")]) : "", node.selector ? indent$5(concat$9([" ", path.call(print, "selector")])) : "", node.value ? group$6(concat$9([" ", path.call(print, "value"), isSCSSControlDirectiveNode$1(node) ? hasParensAroundNode$1(node) ? " " : line$5 : ""])) : node.name === "else" ? " " : "", node.nodes ? concat$9([isSCSSControlDirectiveNode$1(node) ? "" : " ", "{", indent$5(concat$9([node.nodes.length > 0 ? softline$3 : "", printNodeSequence(path, options, print)])), softline$3, "}"]) : isTemplatePlaceholderNodeWithoutSemiColon ? "" : ";"]);
+        isDetachedRulesetCallNode$1(node) || node.name.endsWith(":") ? node.name : maybeToLowerCase$1(node.name), node.params ? concat$9([isDetachedRulesetCallNode$1(node) ? "" : isTemplatePlaceholderNode$1(node) ? node.raws.afterName === "" ? "" : node.name.endsWith(":") ? " " : /^\s*\n\s*\n/.test(node.raws.afterName) ? concat$9([hardline$7, hardline$7]) : /^\s*\n/.test(node.raws.afterName) ? hardline$7 : " " : " ", path.call(print, "params")]) : "", node.selector ? indent$5(concat$9([" ", path.call(print, "selector")])) : "", node.value ? group$6(concat$9([" ", path.call(print, "value"), isSCSSControlDirectiveNode$1(node) ? hasParensAroundNode$1(node) ? " " : line$5 : ""])) : node.name === "else" ? " " : "", node.nodes ? concat$9([isSCSSControlDirectiveNode$1(node) ? "" : " ", "{", indent$5(concat$9([node.nodes.length > 0 ? softline$3 : "", printNodeSequence(path, options, print)])), softline$3, "}"]) : isTemplatePlaceholderNodeWithoutSemiColon ? "" : ";"]);
       }
     // postcss-media-query-parser
 
@@ -43750,6 +44734,11 @@ function genericPrint$2(path, options, print) {
 
           if (!iNextNode) {
             continue;
+          } // styled.div` background: var(--${one}); `
+
+
+          if (!iPrevNode && iNode.value === "--" && iNextNode.type === "value-atword") {
+            continue;
           } // Ignore spaces before/after string interpolation (i.e. `"#{my-fn("_")}"`)
 
 
@@ -45395,7 +46384,7 @@ const {
     markAsRoot: markAsRoot$2
   },
   utils: {
-    mapDoc: mapDoc$4
+    mapDoc: mapDoc$3
   }
 } = document;
 const {
@@ -45457,7 +46446,7 @@ function embed$2(path, print, textToDoc, options) {
   }
 
   function replaceNewlinesWithLiterallines(doc) {
-    return mapDoc$4(doc, currentDoc => typeof currentDoc === "string" && currentDoc.includes("\n") ? concat$c(currentDoc.split(/(\n)/g).map((v, i) => i % 2 === 0 ? v : literalline$4)) : currentDoc);
+    return mapDoc$3(doc, currentDoc => typeof currentDoc === "string" && currentDoc.includes("\n") ? concat$c(currentDoc.split(/(\n)/g).map((v, i) => i % 2 === 0 ? v : literalline$4)) : currentDoc);
   }
 }
 
@@ -45762,7 +46751,7 @@ const {
     group: group$d
   },
   utils: {
-    mapDoc: mapDoc$5
+    mapDoc: mapDoc$4
   },
   printer: {
     printDocToString: printDocToString$3
@@ -46079,19 +47068,6 @@ function getAncestorNode$2(path, typeOrTypes) {
 }
 
 function printLine(path, value, options) {
-  const greatGrandParentNode = path.getParentNode(2);
-
-  if (greatGrandParentNode && greatGrandParentNode.type === "listItem") {
-    const parentNode = path.getParentNode();
-    const grandParentNode = path.getParentNode(1);
-    const index = grandParentNode.children.indexOf(parentNode);
-    const prevGrandParentNode = grandParentNode.children[index - 1];
-
-    if (prevGrandParentNode && prevGrandParentNode.type === "break") {
-      return "";
-    }
-  }
-
   if (options.proseWrap === "preserve" && value === "\n") {
     return hardline$b;
   }
@@ -46343,7 +47319,7 @@ function shouldRemainTheSameContent(path) {
 }
 
 function normalizeDoc(doc) {
-  return mapDoc$5(doc, currentDoc => {
+  return mapDoc$4(doc, currentDoc => {
     if (!currentDoc.parts) {
       return currentDoc;
     }
@@ -46939,7 +47915,7 @@ var colgroup = [
 	"valign",
 	"width"
 ];
-var data = [
+var data$1 = [
 	"value"
 ];
 var del$1 = [
@@ -47432,7 +48408,7 @@ var index$1 = {
 	caption: caption,
 	col: col,
 	colgroup: colgroup,
-	data: data,
+	data: data$1,
 	del: del$1,
 	details: details,
 	dfn: dfn,
@@ -47515,7 +48491,7 @@ var htmlElementAttributes = /*#__PURE__*/Object.freeze({
   caption: caption,
   col: col,
   colgroup: colgroup,
-  data: data,
+  data: data$1,
   del: del$1,
   details: details,
   dfn: dfn,
@@ -47692,7 +48668,7 @@ function isTextLikeNode(node) {
 }
 
 function isScriptLikeTag(node) {
-  return node.type === "element" && (node.fullName === "script" || node.fullName === "style" || node.fullName === "svg:style");
+  return node.type === "element" && (node.fullName === "script" || node.fullName === "style" || node.fullName === "svg:style" || isUnknownNamespace(node) && (node.name === "script" || node.name === "style"));
 }
 
 function isFrontMatterNode(node) {
@@ -48575,7 +49551,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) => {
@@ -48628,7 +49604,7 @@ var stringify$2 = array => {
 };
 
 var srcset = {
-  parse: parse$5,
+  parse: parse$6,
   stringify: stringify$2
 };
 
@@ -48693,7 +49669,7 @@ const {
   builders,
   utils: {
     stripTrailingHardline: stripTrailingHardline$2,
-    mapDoc: mapDoc$6
+    mapDoc: mapDoc$5
   }
 } = document;
 const {
@@ -48807,7 +49783,7 @@ function embed$4(path, print, textToDoc, options) {
         }, opts)), options);
 
         if (embeddedAttributeValueDoc) {
-          return concat$g([node.rawName, '="', group$f(mapDoc$6(embeddedAttributeValueDoc, doc => typeof doc === "string" ? doc.replace(/"/g, "&quot;") : doc)), '"']);
+          return concat$g([node.rawName, '="', group$f(mapDoc$5(embeddedAttributeValueDoc, doc => typeof doc === "string" ? doc.replace(/"/g, "&quot;") : doc)), '"']);
         }
 
         break;
@@ -49015,7 +49991,7 @@ function printChildren$2(path, options, print) {
   }
 
   function printBetweenLine(prevNode, nextNode) {
-    return isTextLikeNode$1(prevNode) && isTextLikeNode$1(nextNode) ? prevNode.isTrailingSpaceSensitive ? prevNode.hasTrailingSpaces ? preferHardlineAsLeadingSpaces$1(nextNode) ? hardline$c : line$a : "" : preferHardlineAsLeadingSpaces$1(nextNode) ? hardline$c : softline$7 : needsToBorrowNextOpeningTagStartMarker(prevNode) && (
+    return isTextLikeNode$1(prevNode) && isTextLikeNode$1(nextNode) ? prevNode.isTrailingSpaceSensitive ? prevNode.hasTrailingSpaces ? preferHardlineAsLeadingSpaces$1(nextNode) ? hardline$c : line$a : "" : preferHardlineAsLeadingSpaces$1(nextNode) ? hardline$c : softline$7 : needsToBorrowNextOpeningTagStartMarker(prevNode) && (hasPrettierIgnore$6(nextNode) ||
     /**
      *     123<a
      *          ~
@@ -49203,7 +50179,7 @@ function printOpeningTagStartMarker(node) {
 }
 
 function printOpeningTagEndMarker(node) {
-  assert(!node.isSelfClosing);
+  assert$1(!node.isSelfClosing);
 
   switch (node.type) {
     case "ieConditionalComment":
@@ -49222,7 +50198,7 @@ function printOpeningTagEndMarker(node) {
 }
 
 function printClosingTagStartMarker(node, options) {
-  assert(!node.isSelfClosing);
+  assert$1(!node.isSelfClosing);
 
   if (shouldNotPrintClosingTag$1(node, options)) {
     return "";
@@ -50326,7 +51302,8 @@ var filenames$4 = [
 	".clang-format",
 	".clang-tidy",
 	".gemrc",
-	"glide.lock"
+	"glide.lock",
+	"yarn.lock"
 ];
 var aceMode$g = "yaml";
 var codemirrorMode$c = "yaml";
@@ -50362,10 +51339,12 @@ var YAML$1 = /*#__PURE__*/Object.freeze({
 
 var require$$0$7 = getCjsExportFromNamespace(YAML$1);
 
-const languages$6 = [createLanguage(require$$0$7, () => ({
+const languages$6 = [createLanguage(require$$0$7, data => ({
   since: "1.14.0",
   parsers: ["yaml"],
-  vscodeLanguageIds: ["yaml"]
+  vscodeLanguageIds: ["yaml"],
+  // yarn.lock is not YAML: https://github.com/yarnpkg/yarn/issues/5629
+  filenames: data.filenames.filter(filename => filename !== "yarn.lock")
 }))];
 var languageYaml = {
   languages: languages$6,
@@ -50460,11 +51439,11 @@ languageCss, {
     },
 
     get less() {
-      return require("./parser-postcss").parsers.css;
+      return require("./parser-postcss").parsers.less;
     },
 
     get scss() {
-      return require("./parser-postcss").parsers.css;
+      return require("./parser-postcss").parsers.scss;
     }
 
   }
@@ -50567,10 +51546,10 @@ function load(plugins, pluginSearchDirs) {
 
     try {
       // try local files
-      requirePath = require.resolve(path$1.resolve(process.cwd(), pluginName));
+      requirePath = resolve_1(path$2.resolve(process.cwd(), pluginName));
     } catch (_) {
       // try node modules
-      requirePath = require.resolve(pluginName, {
+      requirePath = resolve_1(pluginName, {
         paths: [process.cwd()]
       });
     }
@@ -50581,8 +51560,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.
 
@@ -50592,7 +51571,7 @@ function load(plugins, pluginSearchDirs) {
 
     return memoizedSearch(nodeModulesDir).map(pluginName => ({
       name: pluginName,
-      requirePath: require.resolve(pluginName, {
+      requirePath: resolve_1(pluginName, {
         paths: [resolvedPluginSearchDir]
       })
     }));
@@ -50608,12 +51587,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;
   }