typescript-language-server 4.1.3 → 4.2.0

package/lib/cli.mjs

@@ -11990,7 +11990,7 @@ var legacy = legacyStreams;
 
 var clone = clone_1;
 
-var util$1 = require$$0$2;
+var util = require$$0$2;
 
 var gracefulQueue;
 
@@ -12016,8 +12016,8 @@ function publishQueue(context, queue) {
 
 var debug$2 = noop;
 
-if (util$1.debuglog) debug$2 = util$1.debuglog('gfs4'); else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) debug$2 = function() {
-  var m = util$1.format.apply(util$1, arguments);
+if (util.debuglog) debug$2 = util.debuglog('gfs4'); else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) debug$2 = function() {
+  var m = util.format.apply(util, arguments);
   m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ');
   console.error(m);
 };
@@ -12435,11 +12435,11 @@ makeDir$1.makeDirSync = (dir, options) => {
   });
 };
 
-const u$a = universalify$1.fromPromise;
+const u$e = universalify$1.fromPromise;
 
 const {makeDir: _makeDir, makeDirSync: makeDirSync} = makeDir$1;
 
-const makeDir = u$a(_makeDir);
+const makeDir = u$e(_makeDir);
 
 var mkdirs$2 = {
   mkdirs: makeDir,
@@ -12450,7 +12450,7 @@ var mkdirs$2 = {
   ensureDirSync: makeDirSync
 };
 
-const u$9 = universalify$1.fromPromise;
+const u$d = universalify$1.fromPromise;
 
 const fs$f = fs$i;
 
@@ -12459,21 +12459,29 @@ function pathExists$6(path) {
 }
 
 var pathExists_1 = {
-  pathExists: u$9(pathExists$6),
+  pathExists: u$d(pathExists$6),
   pathExistsSync: fs$f.existsSync
 };
 
-const fs$e = gracefulFs;
+const fs$e = fs$i;
 
-function utimesMillis$1(path, atime, mtime, callback) {
-  fs$e.open(path, 'r+', ((err, fd) => {
-    if (err) return callback(err);
-    fs$e.futimes(fd, atime, mtime, (futimesErr => {
-      fs$e.close(fd, (closeErr => {
-        if (callback) callback(futimesErr || closeErr);
-      }));
-    }));
-  }));
+const u$c = universalify$1.fromPromise;
+
+async function utimesMillis$1(path, atime, mtime) {
+  const fd = await fs$e.open(path, 'r+');
+  let closeErr = null;
+  try {
+    await fs$e.futimes(fd, atime, mtime);
+  } finally {
+    try {
+      await fs$e.close(fd);
+    } catch (e) {
+      closeErr = e;
+    }
+  }
+  if (closeErr) {
+    throw closeErr;
+  }
 }
 
 function utimesMillisSync$1(path, atime, mtime) {
@@ -12483,7 +12491,7 @@ function utimesMillisSync$1(path, atime, mtime) {
 }
 
 var utimes = {
-  utimesMillis: utimesMillis$1,
+  utimesMillis: u$c(utimesMillis$1),
   utimesMillisSync: utimesMillisSync$1
 };
 
@@ -12491,9 +12499,9 @@ const fs$d = fs$i;
 
 const path$a = require$$1$1;
 
-const util = require$$0$2;
+const u$b = universalify$1.fromPromise;
 
-function getStats$2(src, dest, opts) {
+function getStats$1(src, dest, opts) {
   const statFunc = opts.dereference ? file => fs$d.stat(file, {
     bigint: true
   }) : file => fs$d.lstat(file, {
@@ -12531,38 +12539,35 @@ function getStatsSync(src, dest, opts) {
   };
 }
 
-function checkPaths(src, dest, funcName, opts, cb) {
-  util.callbackify(getStats$2)(src, dest, opts, ((err, stats) => {
-    if (err) return cb(err);
-    const {srcStat: srcStat, destStat: destStat} = stats;
-    if (destStat) {
-      if (areIdentical$2(srcStat, destStat)) {
-        const srcBaseName = path$a.basename(src);
-        const destBaseName = path$a.basename(dest);
-        if (funcName === 'move' && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
-          return cb(null, {
-            srcStat: srcStat,
-            destStat: destStat,
-            isChangingCase: true
-          });
-        }
-        return cb(new Error('Source and destination must not be the same.'));
-      }
-      if (srcStat.isDirectory() && !destStat.isDirectory()) {
-        return cb(new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`));
-      }
-      if (!srcStat.isDirectory() && destStat.isDirectory()) {
-        return cb(new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`));
+async function checkPaths(src, dest, funcName, opts) {
+  const {srcStat: srcStat, destStat: destStat} = await getStats$1(src, dest, opts);
+  if (destStat) {
+    if (areIdentical$2(srcStat, destStat)) {
+      const srcBaseName = path$a.basename(src);
+      const destBaseName = path$a.basename(dest);
+      if (funcName === 'move' && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+        return {
+          srcStat: srcStat,
+          destStat: destStat,
+          isChangingCase: true
+        };
       }
+      throw new Error('Source and destination must not be the same.');
     }
-    if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
-      return cb(new Error(errMsg(src, dest, funcName)));
+    if (srcStat.isDirectory() && !destStat.isDirectory()) {
+      throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
     }
-    return cb(null, {
-      srcStat: srcStat,
-      destStat: destStat
-    });
-  }));
+    if (!srcStat.isDirectory() && destStat.isDirectory()) {
+      throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
+    }
+  }
+  if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+    throw new Error(errMsg(src, dest, funcName));
+  }
+  return {
+    srcStat: srcStat,
+    destStat: destStat
+  };
 }
 
 function checkPathsSync(src, dest, funcName, opts) {
@@ -12596,22 +12601,23 @@ function checkPathsSync(src, dest, funcName, opts) {
   };
 }
 
-function checkParentPaths(src, srcStat, dest, funcName, cb) {
+async function checkParentPaths(src, srcStat, dest, funcName) {
   const srcParent = path$a.resolve(path$a.dirname(src));
   const destParent = path$a.resolve(path$a.dirname(dest));
-  if (destParent === srcParent || destParent === path$a.parse(destParent).root) return cb();
-  fs$d.stat(destParent, {
-    bigint: true
-  }, ((err, destStat) => {
-    if (err) {
-      if (err.code === 'ENOENT') return cb();
-      return cb(err);
-    }
-    if (areIdentical$2(srcStat, destStat)) {
-      return cb(new Error(errMsg(src, dest, funcName)));
-    }
-    return checkParentPaths(src, srcStat, destParent, funcName, cb);
-  }));
+  if (destParent === srcParent || destParent === path$a.parse(destParent).root) return;
+  let destStat;
+  try {
+    destStat = await fs$d.stat(destParent, {
+      bigint: true
+    });
+  } catch (err) {
+    if (err.code === 'ENOENT') return;
+    throw err;
+  }
+  if (areIdentical$2(srcStat, destStat)) {
+    throw new Error(errMsg(src, dest, funcName));
+  }
+  return checkParentPaths(src, srcStat, destParent, funcName);
 }
 
 function checkParentPathsSync(src, srcStat, dest, funcName) {
@@ -12640,7 +12646,7 @@ function areIdentical$2(srcStat, destStat) {
 function isSrcSubdir(src, dest) {
   const srcArr = path$a.resolve(src).split(path$a.sep).filter((i => i));
   const destArr = path$a.resolve(dest).split(path$a.sep).filter((i => i));
-  return srcArr.reduce(((acc, cur, i) => acc && destArr[i] === cur), true);
+  return srcArr.every(((cur, i) => destArr[i] === cur));
 }
 
 function errMsg(src, dest, funcName) {
@@ -12648,221 +12654,140 @@ function errMsg(src, dest, funcName) {
 }
 
 var stat$4 = {
-  checkPaths: checkPaths,
+  checkPaths: u$b(checkPaths),
   checkPathsSync: checkPathsSync,
-  checkParentPaths: checkParentPaths,
+  checkParentPaths: u$b(checkParentPaths),
   checkParentPathsSync: checkParentPathsSync,
   isSrcSubdir: isSrcSubdir,
   areIdentical: areIdentical$2
 };
 
-const fs$c = gracefulFs;
+const fs$c = fs$i;
 
 const path$9 = require$$1$1;
 
-const mkdirs$1 = mkdirs$2.mkdirs;
+const {mkdirs: mkdirs$1} = mkdirs$2;
 
-const pathExists$5 = pathExists_1.pathExists;
+const {pathExists: pathExists$5} = pathExists_1;
 
-const utimesMillis = utimes.utimesMillis;
+const {utimesMillis: utimesMillis} = utimes;
 
 const stat$3 = stat$4;
 
-function copy$2(src, dest, opts, cb) {
-  if (typeof opts === 'function' && !cb) {
-    cb = opts;
-    opts = {};
-  } else if (typeof opts === 'function') {
+async function copy$2(src, dest, opts = {}) {
+  if (typeof opts === 'function') {
     opts = {
       filter: opts
     };
   }
-  cb = cb || function() {};
-  opts = opts || {};
   opts.clobber = 'clobber' in opts ? !!opts.clobber : true;
   opts.overwrite = 'overwrite' in opts ? !!opts.overwrite : opts.clobber;
   if (opts.preserveTimestamps && process.arch === 'ia32') {
     process.emitWarning('Using the preserveTimestamps option in 32-bit node is not recommended;\n\n' + '\tsee https://github.com/jprichardson/node-fs-extra/issues/269', 'Warning', 'fs-extra-WARN0001');
   }
-  stat$3.checkPaths(src, dest, 'copy', opts, ((err, stats) => {
-    if (err) return cb(err);
-    const {srcStat: srcStat, destStat: destStat} = stats;
-    stat$3.checkParentPaths(src, srcStat, dest, 'copy', (err => {
-      if (err) return cb(err);
-      runFilter(src, dest, opts, ((err, include) => {
-        if (err) return cb(err);
-        if (!include) return cb();
-        checkParentDir(destStat, src, dest, opts, cb);
-      }));
-    }));
-  }));
-}
-
-function checkParentDir(destStat, src, dest, opts, cb) {
+  const {srcStat: srcStat, destStat: destStat} = await stat$3.checkPaths(src, dest, 'copy', opts);
+  await stat$3.checkParentPaths(src, srcStat, dest, 'copy');
+  const include = await runFilter(src, dest, opts);
+  if (!include) return;
   const destParent = path$9.dirname(dest);
-  pathExists$5(destParent, ((err, dirExists) => {
-    if (err) return cb(err);
-    if (dirExists) return getStats$1(destStat, src, dest, opts, cb);
-    mkdirs$1(destParent, (err => {
-      if (err) return cb(err);
-      return getStats$1(destStat, src, dest, opts, cb);
-    }));
-  }));
-}
-
-function runFilter(src, dest, opts, cb) {
-  if (!opts.filter) return cb(null, true);
-  Promise.resolve(opts.filter(src, dest)).then((include => cb(null, include)), (error => cb(error)));
+  const dirExists = await pathExists$5(destParent);
+  if (!dirExists) {
+    await mkdirs$1(destParent);
+  }
+  await getStatsAndPerformCopy(destStat, src, dest, opts);
 }
 
-function getStats$1(destStat, src, dest, opts, cb) {
-  const stat = opts.dereference ? fs$c.stat : fs$c.lstat;
-  stat(src, ((err, srcStat) => {
-    if (err) return cb(err);
-    if (srcStat.isDirectory()) return onDir$1(srcStat, destStat, src, dest, opts, cb); else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile$1(srcStat, destStat, src, dest, opts, cb); else if (srcStat.isSymbolicLink()) return onLink$1(destStat, src, dest, opts, cb); else if (srcStat.isSocket()) return cb(new Error(`Cannot copy a socket file: ${src}`)); else if (srcStat.isFIFO()) return cb(new Error(`Cannot copy a FIFO pipe: ${src}`));
-    return cb(new Error(`Unknown file: ${src}`));
-  }));
+async function runFilter(src, dest, opts) {
+  if (!opts.filter) return true;
+  return opts.filter(src, dest);
 }
 
-function onFile$1(srcStat, destStat, src, dest, opts, cb) {
-  if (!destStat) return copyFile$1(srcStat, src, dest, opts, cb);
-  return mayCopyFile$1(srcStat, src, dest, opts, cb);
+async function getStatsAndPerformCopy(destStat, src, dest, opts) {
+  const statFn = opts.dereference ? fs$c.stat : fs$c.lstat;
+  const srcStat = await statFn(src);
+  if (srcStat.isDirectory()) return onDir$1(srcStat, destStat, src, dest, opts);
+  if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile$1(srcStat, destStat, src, dest, opts);
+  if (srcStat.isSymbolicLink()) return onLink$1(destStat, src, dest, opts);
+  if (srcStat.isSocket()) throw new Error(`Cannot copy a socket file: ${src}`);
+  if (srcStat.isFIFO()) throw new Error(`Cannot copy a FIFO pipe: ${src}`);
+  throw new Error(`Unknown file: ${src}`);
 }
 
-function mayCopyFile$1(srcStat, src, dest, opts, cb) {
+async function onFile$1(srcStat, destStat, src, dest, opts) {
+  if (!destStat) return copyFile$1(srcStat, src, dest, opts);
   if (opts.overwrite) {
-    fs$c.unlink(dest, (err => {
-      if (err) return cb(err);
-      return copyFile$1(srcStat, src, dest, opts, cb);
-    }));
-  } else if (opts.errorOnExist) {
-    return cb(new Error(`'${dest}' already exists`));
-  } else return cb();
-}
-
-function copyFile$1(srcStat, src, dest, opts, cb) {
-  fs$c.copyFile(src, dest, (err => {
-    if (err) return cb(err);
-    if (opts.preserveTimestamps) return handleTimestampsAndMode(srcStat.mode, src, dest, cb);
-    return setDestMode$1(dest, srcStat.mode, cb);
-  }));
+    await fs$c.unlink(dest);
+    return copyFile$1(srcStat, src, dest, opts);
+  }
+  if (opts.errorOnExist) {
+    throw new Error(`'${dest}' already exists`);
+  }
 }
 
-function handleTimestampsAndMode(srcMode, src, dest, cb) {
-  if (fileIsNotWritable$1(srcMode)) {
-    return makeFileWritable$1(dest, srcMode, (err => {
-      if (err) return cb(err);
-      return setDestTimestampsAndMode(srcMode, src, dest, cb);
-    }));
+async function copyFile$1(srcStat, src, dest, opts) {
+  await fs$c.copyFile(src, dest);
+  if (opts.preserveTimestamps) {
+    if (fileIsNotWritable$1(srcStat.mode)) {
+      await makeFileWritable$1(dest, srcStat.mode);
+    }
+    const updatedSrcStat = await fs$c.stat(src);
+    await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
   }
-  return setDestTimestampsAndMode(srcMode, src, dest, cb);
+  return fs$c.chmod(dest, srcStat.mode);
 }
 
 function fileIsNotWritable$1(srcMode) {
   return (srcMode & 128) === 0;
 }
 
-function makeFileWritable$1(dest, srcMode, cb) {
-  return setDestMode$1(dest, srcMode | 128, cb);
-}
-
-function setDestTimestampsAndMode(srcMode, src, dest, cb) {
-  setDestTimestamps$1(src, dest, (err => {
-    if (err) return cb(err);
-    return setDestMode$1(dest, srcMode, cb);
-  }));
-}
-
-function setDestMode$1(dest, srcMode, cb) {
-  return fs$c.chmod(dest, srcMode, cb);
-}
-
-function setDestTimestamps$1(src, dest, cb) {
-  fs$c.stat(src, ((err, updatedSrcStat) => {
-    if (err) return cb(err);
-    return utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime, cb);
-  }));
-}
-
-function onDir$1(srcStat, destStat, src, dest, opts, cb) {
-  if (!destStat) return mkDirAndCopy$1(srcStat.mode, src, dest, opts, cb);
-  return copyDir$1(src, dest, opts, cb);
-}
-
-function mkDirAndCopy$1(srcMode, src, dest, opts, cb) {
-  fs$c.mkdir(dest, (err => {
-    if (err) return cb(err);
-    copyDir$1(src, dest, opts, (err => {
-      if (err) return cb(err);
-      return setDestMode$1(dest, srcMode, cb);
-    }));
-  }));
-}
-
-function copyDir$1(src, dest, opts, cb) {
-  fs$c.readdir(src, ((err, items) => {
-    if (err) return cb(err);
-    return copyDirItems(items, src, dest, opts, cb);
-  }));
-}
-
-function copyDirItems(items, src, dest, opts, cb) {
-  const item = items.pop();
-  if (!item) return cb();
-  return copyDirItem$1(items, item, src, dest, opts, cb);
-}
-
-function copyDirItem$1(items, item, src, dest, opts, cb) {
-  const srcItem = path$9.join(src, item);
-  const destItem = path$9.join(dest, item);
-  runFilter(srcItem, destItem, opts, ((err, include) => {
-    if (err) return cb(err);
-    if (!include) return copyDirItems(items, src, dest, opts, cb);
-    stat$3.checkPaths(srcItem, destItem, 'copy', opts, ((err, stats) => {
-      if (err) return cb(err);
-      const {destStat: destStat} = stats;
-      getStats$1(destStat, srcItem, destItem, opts, (err => {
-        if (err) return cb(err);
-        return copyDirItems(items, src, dest, opts, cb);
-      }));
-    }));
-  }));
+function makeFileWritable$1(dest, srcMode) {
+  return fs$c.chmod(dest, srcMode | 128);
 }
 
-function onLink$1(destStat, src, dest, opts, cb) {
-  fs$c.readlink(src, ((err, resolvedSrc) => {
-    if (err) return cb(err);
-    if (opts.dereference) {
-      resolvedSrc = path$9.resolve(process.cwd(), resolvedSrc);
-    }
-    if (!destStat) {
-      return fs$c.symlink(resolvedSrc, dest, cb);
-    } else {
-      fs$c.readlink(dest, ((err, resolvedDest) => {
-        if (err) {
-          if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs$c.symlink(resolvedSrc, dest, cb);
-          return cb(err);
-        }
-        if (opts.dereference) {
-          resolvedDest = path$9.resolve(process.cwd(), resolvedDest);
-        }
-        if (stat$3.isSrcSubdir(resolvedSrc, resolvedDest)) {
-          return cb(new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`));
-        }
-        if (stat$3.isSrcSubdir(resolvedDest, resolvedSrc)) {
-          return cb(new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`));
-        }
-        return copyLink$1(resolvedSrc, dest, cb);
-      }));
-    }
-  }));
+async function onDir$1(srcStat, destStat, src, dest, opts) {
+  if (!destStat) {
+    await fs$c.mkdir(dest);
+  }
+  const items = await fs$c.readdir(src);
+  await Promise.all(items.map((async item => {
+    const srcItem = path$9.join(src, item);
+    const destItem = path$9.join(dest, item);
+    const include = await runFilter(srcItem, destItem, opts);
+    if (!include) return;
+    const {destStat: destStat} = await stat$3.checkPaths(srcItem, destItem, 'copy', opts);
+    return getStatsAndPerformCopy(destStat, srcItem, destItem, opts);
+  })));
+  if (!destStat) {
+    await fs$c.chmod(dest, srcStat.mode);
+  }
 }
 
-function copyLink$1(resolvedSrc, dest, cb) {
-  fs$c.unlink(dest, (err => {
-    if (err) return cb(err);
-    return fs$c.symlink(resolvedSrc, dest, cb);
-  }));
+async function onLink$1(destStat, src, dest, opts) {
+  let resolvedSrc = await fs$c.readlink(src);
+  if (opts.dereference) {
+    resolvedSrc = path$9.resolve(process.cwd(), resolvedSrc);
+  }
+  if (!destStat) {
+    return fs$c.symlink(resolvedSrc, dest);
+  }
+  let resolvedDest = null;
+  try {
+    resolvedDest = await fs$c.readlink(dest);
+  } catch (e) {
+    if (e.code === 'EINVAL' || e.code === 'UNKNOWN') return fs$c.symlink(resolvedSrc, dest);
+    throw e;
+  }
+  if (opts.dereference) {
+    resolvedDest = path$9.resolve(process.cwd(), resolvedDest);
+  }
+  if (stat$3.isSrcSubdir(resolvedSrc, resolvedDest)) {
+    throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+  }
+  if (stat$3.isSrcSubdir(resolvedDest, resolvedSrc)) {
+    throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+  }
+  await fs$c.unlink(dest);
+  return fs$c.symlink(resolvedSrc, dest);
 }
 
 var copy_1 = copy$2;
@@ -13004,16 +12929,16 @@ function copyLink(resolvedSrc, dest) {
 
 var copySync_1 = copySync$1;
 
-const u$8 = universalify$1.fromCallback;
+const u$a = universalify$1.fromPromise;
 
 var copy$1 = {
-  copy: u$8(copy_1),
+  copy: u$a(copy_1),
   copySync: copySync_1
 };
 
 const fs$a = gracefulFs;
 
-const u$7 = universalify$1.fromCallback;
+const u$9 = universalify$1.fromCallback;
 
 function remove$2(path, callback) {
   fs$a.rm(path, {
@@ -13030,11 +12955,11 @@ function removeSync$1(path) {
 }
 
 var remove_1 = {
-  remove: u$7(remove$2),
+  remove: u$9(remove$2),
   removeSync: removeSync$1
 };
 
-const u$6 = universalify$1.fromPromise;
+const u$8 = universalify$1.fromPromise;
 
 const fs$9 = fs$i;
 
@@ -13044,7 +12969,7 @@ const mkdir$3 = mkdirs$2;
 
 const remove$1 = remove_1;
 
-const emptyDir = u$6((async function emptyDir(dir) {
+const emptyDir = u$8((async function emptyDir(dir) {
   let items;
   try {
     items = await fs$9.readdir(dir);
@@ -13074,41 +12999,38 @@ var empty = {
   emptydir: emptyDir
 };
 
-const u$5 = universalify$1.fromCallback;
+const u$7 = universalify$1.fromPromise;
 
 const path$6 = require$$1$1;
 
-const fs$8 = gracefulFs;
+const fs$8 = fs$i;
 
 const mkdir$2 = mkdirs$2;
 
-function createFile$1(file, callback) {
-  function makeFile() {
-    fs$8.writeFile(file, '', (err => {
-      if (err) return callback(err);
-      callback();
-    }));
+async function createFile$1(file) {
+  let stats;
+  try {
+    stats = await fs$8.stat(file);
+  } catch {}
+  if (stats && stats.isFile()) return;
+  const dir = path$6.dirname(file);
+  let dirStats = null;
+  try {
+    dirStats = await fs$8.stat(dir);
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      await mkdir$2.mkdirs(dir);
+      await fs$8.writeFile(file, '');
+      return;
+    } else {
+      throw err;
+    }
+  }
+  if (dirStats.isDirectory()) {
+    await fs$8.writeFile(file, '');
+  } else {
+    await fs$8.readdir(dir);
   }
-  fs$8.stat(file, ((err, stats) => {
-    if (!err && stats.isFile()) return callback();
-    const dir = path$6.dirname(file);
-    fs$8.stat(dir, ((err, stats) => {
-      if (err) {
-        if (err.code === 'ENOENT') {
-          return mkdir$2.mkdirs(dir, (err => {
-            if (err) return callback(err);
-            makeFile();
-          }));
-        }
-        return callback(err);
-      }
-      if (stats.isDirectory()) makeFile(); else {
-        fs$8.readdir(dir, (err => {
-          if (err) return callback(err);
-        }));
-      }
-    }));
-  }));
 }
 
 function createFileSync$1(file) {
@@ -13129,47 +13051,41 @@ function createFileSync$1(file) {
 }
 
 var file$1 = {
-  createFile: u$5(createFile$1),
+  createFile: u$7(createFile$1),
   createFileSync: createFileSync$1
 };
 
-const u$4 = universalify$1.fromCallback;
+const u$6 = universalify$1.fromPromise;
 
 const path$5 = require$$1$1;
 
-const fs$7 = gracefulFs;
+const fs$7 = fs$i;
 
 const mkdir$1 = mkdirs$2;
 
-const pathExists$4 = pathExists_1.pathExists;
+const {pathExists: pathExists$4} = pathExists_1;
 
 const {areIdentical: areIdentical$1} = stat$4;
 
-function createLink$1(srcpath, dstpath, callback) {
-  function makeLink(srcpath, dstpath) {
-    fs$7.link(srcpath, dstpath, (err => {
-      if (err) return callback(err);
-      callback(null);
-    }));
+async function createLink$1(srcpath, dstpath) {
+  let dstStat;
+  try {
+    dstStat = await fs$7.lstat(dstpath);
+  } catch {}
+  let srcStat;
+  try {
+    srcStat = await fs$7.lstat(srcpath);
+  } catch (err) {
+    err.message = err.message.replace('lstat', 'ensureLink');
+    throw err;
   }
-  fs$7.lstat(dstpath, ((_, dstStat) => {
-    fs$7.lstat(srcpath, ((err, srcStat) => {
-      if (err) {
-        err.message = err.message.replace('lstat', 'ensureLink');
-        return callback(err);
-      }
-      if (dstStat && areIdentical$1(srcStat, dstStat)) return callback(null);
-      const dir = path$5.dirname(dstpath);
-      pathExists$4(dir, ((err, dirExists) => {
-        if (err) return callback(err);
-        if (dirExists) return makeLink(srcpath, dstpath);
-        mkdir$1.mkdirs(dir, (err => {
-          if (err) return callback(err);
-          makeLink(srcpath, dstpath);
-        }));
-      }));
-    }));
-  }));
+  if (dstStat && areIdentical$1(srcStat, dstStat)) return;
+  const dir = path$5.dirname(dstpath);
+  const dirExists = await pathExists$4(dir);
+  if (!dirExists) {
+    await mkdir$1.mkdirs(dir);
+  }
+  await fs$7.link(srcpath, dstpath);
 }
 
 function createLinkSync$1(srcpath, dstpath) {
@@ -13192,104 +13108,101 @@ function createLinkSync$1(srcpath, dstpath) {
 }
 
 var link = {
-  createLink: u$4(createLink$1),
+  createLink: u$6(createLink$1),
   createLinkSync: createLinkSync$1
 };
 
 const path$4 = require$$1$1;
 
-const fs$6 = gracefulFs;
+const fs$6 = fs$i;
 
-const pathExists$3 = pathExists_1.pathExists;
+const {pathExists: pathExists$3} = pathExists_1;
 
-function symlinkPaths$1(srcpath, dstpath, callback) {
+const u$5 = universalify$1.fromPromise;
+
+async function symlinkPaths$1(srcpath, dstpath) {
   if (path$4.isAbsolute(srcpath)) {
-    return fs$6.lstat(srcpath, (err => {
-      if (err) {
-        err.message = err.message.replace('lstat', 'ensureSymlink');
-        return callback(err);
-      }
-      return callback(null, {
-        toCwd: srcpath,
-        toDst: srcpath
-      });
-    }));
-  } else {
-    const dstdir = path$4.dirname(dstpath);
-    const relativeToDst = path$4.join(dstdir, srcpath);
-    return pathExists$3(relativeToDst, ((err, exists) => {
-      if (err) return callback(err);
-      if (exists) {
-        return callback(null, {
-          toCwd: relativeToDst,
-          toDst: srcpath
-        });
-      } else {
-        return fs$6.lstat(srcpath, (err => {
-          if (err) {
-            err.message = err.message.replace('lstat', 'ensureSymlink');
-            return callback(err);
-          }
-          return callback(null, {
-            toCwd: srcpath,
-            toDst: path$4.relative(dstdir, srcpath)
-          });
-        }));
-      }
-    }));
+    try {
+      await fs$6.lstat(srcpath);
+    } catch (err) {
+      err.message = err.message.replace('lstat', 'ensureSymlink');
+      throw err;
+    }
+    return {
+      toCwd: srcpath,
+      toDst: srcpath
+    };
+  }
+  const dstdir = path$4.dirname(dstpath);
+  const relativeToDst = path$4.join(dstdir, srcpath);
+  const exists = await pathExists$3(relativeToDst);
+  if (exists) {
+    return {
+      toCwd: relativeToDst,
+      toDst: srcpath
+    };
+  }
+  try {
+    await fs$6.lstat(srcpath);
+  } catch (err) {
+    err.message = err.message.replace('lstat', 'ensureSymlink');
+    throw err;
   }
+  return {
+    toCwd: srcpath,
+    toDst: path$4.relative(dstdir, srcpath)
+  };
 }
 
 function symlinkPathsSync$1(srcpath, dstpath) {
-  let exists;
   if (path$4.isAbsolute(srcpath)) {
-    exists = fs$6.existsSync(srcpath);
+    const exists = fs$6.existsSync(srcpath);
     if (!exists) throw new Error('absolute srcpath does not exist');
     return {
       toCwd: srcpath,
       toDst: srcpath
     };
-  } else {
-    const dstdir = path$4.dirname(dstpath);
-    const relativeToDst = path$4.join(dstdir, srcpath);
-    exists = fs$6.existsSync(relativeToDst);
-    if (exists) {
-      return {
-        toCwd: relativeToDst,
-        toDst: srcpath
-      };
-    } else {
-      exists = fs$6.existsSync(srcpath);
-      if (!exists) throw new Error('relative srcpath does not exist');
-      return {
-        toCwd: srcpath,
-        toDst: path$4.relative(dstdir, srcpath)
-      };
-    }
   }
+  const dstdir = path$4.dirname(dstpath);
+  const relativeToDst = path$4.join(dstdir, srcpath);
+  const exists = fs$6.existsSync(relativeToDst);
+  if (exists) {
+    return {
+      toCwd: relativeToDst,
+      toDst: srcpath
+    };
+  }
+  const srcExists = fs$6.existsSync(srcpath);
+  if (!srcExists) throw new Error('relative srcpath does not exist');
+  return {
+    toCwd: srcpath,
+    toDst: path$4.relative(dstdir, srcpath)
+  };
 }
 
 var symlinkPaths_1 = {
-  symlinkPaths: symlinkPaths$1,
+  symlinkPaths: u$5(symlinkPaths$1),
   symlinkPathsSync: symlinkPathsSync$1
 };
 
-const fs$5 = gracefulFs;
+const fs$5 = fs$i;
 
-function symlinkType$1(srcpath, type, callback) {
-  callback = typeof type === 'function' ? type : callback;
-  type = typeof type === 'function' ? false : type;
-  if (type) return callback(null, type);
-  fs$5.lstat(srcpath, ((err, stats) => {
-    if (err) return callback(null, 'file');
-    type = stats && stats.isDirectory() ? 'dir' : 'file';
-    callback(null, type);
-  }));
+const u$4 = universalify$1.fromPromise;
+
+async function symlinkType$1(srcpath, type) {
+  if (type) return type;
+  let stats;
+  try {
+    stats = await fs$5.lstat(srcpath);
+  } catch {
+    return 'file';
+  }
+  return stats && stats.isDirectory() ? 'dir' : 'file';
 }
 
 function symlinkTypeSync$1(srcpath, type) {
-  let stats;
   if (type) return type;
+  let stats;
   try {
     stats = fs$5.lstatSync(srcpath);
   } catch {
@@ -13299,68 +13212,43 @@ function symlinkTypeSync$1(srcpath, type) {
 }
 
 var symlinkType_1 = {
-  symlinkType: symlinkType$1,
+  symlinkType: u$4(symlinkType$1),
   symlinkTypeSync: symlinkTypeSync$1
 };
 
-const u$3 = universalify$1.fromCallback;
+const u$3 = universalify$1.fromPromise;
 
 const path$3 = require$$1$1;
 
 const fs$4 = fs$i;
 
-const _mkdirs = mkdirs$2;
+const {mkdirs: mkdirs, mkdirsSync: mkdirsSync} = mkdirs$2;
 
-const mkdirs = _mkdirs.mkdirs;
+const {symlinkPaths: symlinkPaths, symlinkPathsSync: symlinkPathsSync} = symlinkPaths_1;
 
-const mkdirsSync = _mkdirs.mkdirsSync;
+const {symlinkType: symlinkType, symlinkTypeSync: symlinkTypeSync} = symlinkType_1;
 
-const _symlinkPaths = symlinkPaths_1;
-
-const symlinkPaths = _symlinkPaths.symlinkPaths;
-
-const symlinkPathsSync = _symlinkPaths.symlinkPathsSync;
-
-const _symlinkType = symlinkType_1;
-
-const symlinkType = _symlinkType.symlinkType;
-
-const symlinkTypeSync = _symlinkType.symlinkTypeSync;
-
-const pathExists$2 = pathExists_1.pathExists;
+const {pathExists: pathExists$2} = pathExists_1;
 
 const {areIdentical: areIdentical} = stat$4;
 
-function createSymlink$1(srcpath, dstpath, type, callback) {
-  callback = typeof type === 'function' ? type : callback;
-  type = typeof type === 'function' ? false : type;
-  fs$4.lstat(dstpath, ((err, stats) => {
-    if (!err && stats.isSymbolicLink()) {
-      Promise.all([ fs$4.stat(srcpath), fs$4.stat(dstpath) ]).then((([srcStat, dstStat]) => {
-        if (areIdentical(srcStat, dstStat)) return callback(null);
-        _createSymlink(srcpath, dstpath, type, callback);
-      }));
-    } else _createSymlink(srcpath, dstpath, type, callback);
-  }));
-}
-
-function _createSymlink(srcpath, dstpath, type, callback) {
-  symlinkPaths(srcpath, dstpath, ((err, relative) => {
-    if (err) return callback(err);
-    srcpath = relative.toDst;
-    symlinkType(relative.toCwd, type, ((err, type) => {
-      if (err) return callback(err);
-      const dir = path$3.dirname(dstpath);
-      pathExists$2(dir, ((err, dirExists) => {
-        if (err) return callback(err);
-        if (dirExists) return fs$4.symlink(srcpath, dstpath, type, callback);
-        mkdirs(dir, (err => {
-          if (err) return callback(err);
-          fs$4.symlink(srcpath, dstpath, type, callback);
-        }));
-      }));
-    }));
-  }));
+async function createSymlink$1(srcpath, dstpath, type) {
+  let stats;
+  try {
+    stats = await fs$4.lstat(dstpath);
+  } catch {}
+  if (stats && stats.isSymbolicLink()) {
+    const [srcStat, dstStat] = await Promise.all([ fs$4.stat(srcpath), fs$4.stat(dstpath) ]);
+    if (areIdentical(srcStat, dstStat)) return;
+  }
+  const relative = await symlinkPaths(srcpath, dstpath);
+  srcpath = relative.toDst;
+  const toType = await symlinkType(relative.toCwd, type);
+  const dir = path$3.dirname(dstpath);
+  if (!await pathExists$2(dir)) {
+    await mkdirs(dir);
+  }
+  return fs$4.symlink(srcpath, dstpath, toType);
 }
 
 function createSymlinkSync$1(srcpath, dstpath, type) {
@@ -13517,9 +13405,9 @@ var jsonfile = {
   writeJsonSync: jsonFile$1.writeFileSync
 };
 
-const u$2 = universalify$1.fromCallback;
+const u$2 = universalify$1.fromPromise;
 
-const fs$3 = gracefulFs;
+const fs$3 = fs$i;
 
 const path$2 = require$$1$1;
 
@@ -13527,28 +13415,19 @@ const mkdir = mkdirs$2;
 
 const pathExists$1 = pathExists_1.pathExists;
 
-function outputFile$1(file, data, encoding, callback) {
-  if (typeof encoding === 'function') {
-    callback = encoding;
-    encoding = 'utf8';
-  }
+async function outputFile$1(file, data, encoding = 'utf-8') {
   const dir = path$2.dirname(file);
-  pathExists$1(dir, ((err, itDoes) => {
-    if (err) return callback(err);
-    if (itDoes) return fs$3.writeFile(file, data, encoding, callback);
-    mkdir.mkdirs(dir, (err => {
-      if (err) return callback(err);
-      fs$3.writeFile(file, data, encoding, callback);
-    }));
-  }));
+  if (!await pathExists$1(dir)) {
+    await mkdir.mkdirs(dir);
+  }
+  return fs$3.writeFile(file, data, encoding);
 }
 
 function outputFileSync$1(file, ...args) {
   const dir = path$2.dirname(file);
-  if (fs$3.existsSync(dir)) {
-    return fs$3.writeFileSync(file, ...args);
+  if (!fs$3.existsSync(dir)) {
+    mkdir.mkdirsSync(dir);
   }
-  mkdir.mkdirsSync(dir);
   fs$3.writeFileSync(file, ...args);
 }
 
@@ -13601,80 +13480,58 @@ jsonFile.readJSONSync = jsonFile.readJsonSync;
 
 var json = jsonFile;
 
-const fs$2 = gracefulFs;
+const fs$2 = fs$i;
 
 const path$1 = require$$1$1;
 
-const copy = copy$1.copy;
+const {copy: copy} = copy$1;
 
-const remove = remove_1.remove;
+const {remove: remove} = remove_1;
 
-const mkdirp = mkdirs$2.mkdirp;
+const {mkdirp: mkdirp} = mkdirs$2;
 
-const pathExists = pathExists_1.pathExists;
+const {pathExists: pathExists} = pathExists_1;
 
 const stat$1 = stat$4;
 
-function move$1(src, dest, opts, cb) {
-  if (typeof opts === 'function') {
-    cb = opts;
-    opts = {};
-  }
-  opts = opts || {};
+async function move$1(src, dest, opts = {}) {
   const overwrite = opts.overwrite || opts.clobber || false;
-  stat$1.checkPaths(src, dest, 'move', opts, ((err, stats) => {
-    if (err) return cb(err);
-    const {srcStat: srcStat, isChangingCase: isChangingCase = false} = stats;
-    stat$1.checkParentPaths(src, srcStat, dest, 'move', (err => {
-      if (err) return cb(err);
-      if (isParentRoot$1(dest)) return doRename$1(src, dest, overwrite, isChangingCase, cb);
-      mkdirp(path$1.dirname(dest), (err => {
-        if (err) return cb(err);
-        return doRename$1(src, dest, overwrite, isChangingCase, cb);
-      }));
-    }));
-  }));
-}
-
-function isParentRoot$1(dest) {
-  const parent = path$1.dirname(dest);
-  const parsedPath = path$1.parse(parent);
-  return parsedPath.root === parent;
-}
-
-function doRename$1(src, dest, overwrite, isChangingCase, cb) {
-  if (isChangingCase) return rename$1(src, dest, overwrite, cb);
-  if (overwrite) {
-    return remove(dest, (err => {
-      if (err) return cb(err);
-      return rename$1(src, dest, overwrite, cb);
-    }));
+  const {srcStat: srcStat, isChangingCase: isChangingCase = false} = await stat$1.checkPaths(src, dest, 'move', opts);
+  await stat$1.checkParentPaths(src, srcStat, dest, 'move');
+  const destParent = path$1.dirname(dest);
+  const parsedParentPath = path$1.parse(destParent);
+  if (parsedParentPath.root !== destParent) {
+    await mkdirp(destParent);
   }
-  pathExists(dest, ((err, destExists) => {
-    if (err) return cb(err);
-    if (destExists) return cb(new Error('dest already exists.'));
-    return rename$1(src, dest, overwrite, cb);
-  }));
+  return doRename$1(src, dest, overwrite, isChangingCase);
 }
 
-function rename$1(src, dest, overwrite, cb) {
-  fs$2.rename(src, dest, (err => {
-    if (!err) return cb();
-    if (err.code !== 'EXDEV') return cb(err);
-    return moveAcrossDevice$1(src, dest, overwrite, cb);
-  }));
+async function doRename$1(src, dest, overwrite, isChangingCase) {
+  if (!isChangingCase) {
+    if (overwrite) {
+      await remove(dest);
+    } else if (await pathExists(dest)) {
+      throw new Error('dest already exists.');
+    }
+  }
+  try {
+    await fs$2.rename(src, dest);
+  } catch (err) {
+    if (err.code !== 'EXDEV') {
+      throw err;
+    }
+    await moveAcrossDevice$1(src, dest, overwrite);
+  }
 }
 
-function moveAcrossDevice$1(src, dest, overwrite, cb) {
+async function moveAcrossDevice$1(src, dest, overwrite) {
   const opts = {
     overwrite: overwrite,
     errorOnExist: true,
     preserveTimestamps: true
   };
-  copy(src, dest, opts, (err => {
-    if (err) return cb(err);
-    return remove(src, cb);
-  }));
+  await copy(src, dest, opts);
+  return remove(src);
 }
 
 var move_1 = move$1;
@@ -13737,7 +13594,7 @@ function moveAcrossDevice(src, dest, overwrite) {
 
 var moveSync_1 = moveSync;
 
-const u = universalify$1.fromCallback;
+const u = universalify$1.fromPromise;
 
 var move = {
   move: u(move_1),
@@ -22448,7 +22305,7 @@ class LspServer {
       globalPlugins.push(plugin.name);
       pluginProbeLocations.push(plugin.location);
     }
-    const typescriptVersion = this.findTypescriptVersion(tsserver?.path);
+    const typescriptVersion = this.findTypescriptVersion(tsserver?.path, tsserver?.fallbackPath);
     if (typescriptVersion) {
       this.options.lspClient.logMessage({
         type: main$3.MessageType.Info,
@@ -22607,7 +22464,7 @@ class LspServer {
       source: typescriptVersionSource
     });
   }
-  findTypescriptVersion(userTsserverPath) {
+  findTypescriptVersion(userTsserverPath, fallbackTsserverPath) {
     const typescriptVersionProvider = new TypeScriptVersionProvider(userTsserverPath, this.logger);
     const userSettingVersion = typescriptVersionProvider.getUserSettingVersion();
     if (userSettingVersion) {
@@ -22622,6 +22479,14 @@ class LspServer {
         return workspaceVersion;
       }
     }
+    const fallbackVersionProvider = new TypeScriptVersionProvider(fallbackTsserverPath, this.logger);
+    const fallbackSettingVersion = fallbackVersionProvider.getUserSettingVersion();
+    if (fallbackSettingVersion) {
+      if (fallbackSettingVersion.isValid) {
+        return fallbackSettingVersion;
+      }
+      this.logger.logIgnoringVerbosity(LogLevel.Warning, `Typescript specified through fallback setting ignored due to invalid path "${fallbackSettingVersion.path}"`);
+    }
     const bundledVersion = typescriptVersionProvider.bundledVersion();
     if (bundledVersion?.isValid) {
       return bundledVersion;