coc-git 2.7.7 → 2.7.8

package/lib/index.js

@@ -29,230 +29,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// node_modules/isexe/windows.js
-var require_windows = __commonJS({
-  "node_modules/isexe/windows.js"(exports2, module2) {
-    module2.exports = isexe;
-    isexe.sync = sync;
-    var fs4 = require("fs");
-    function checkPathExt(path8, options) {
-      var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
-      if (!pathext) {
-        return true;
-      }
-      pathext = pathext.split(";");
-      if (pathext.indexOf("") !== -1) {
-        return true;
-      }
-      for (var i = 0; i < pathext.length; i++) {
-        var p = pathext[i].toLowerCase();
-        if (p && path8.substr(-p.length).toLowerCase() === p) {
-          return true;
-        }
-      }
-      return false;
-    }
-    function checkStat(stat, path8, options) {
-      if (!stat.isSymbolicLink() && !stat.isFile()) {
-        return false;
-      }
-      return checkPathExt(path8, options);
-    }
-    function isexe(path8, options, cb) {
-      fs4.stat(path8, function(er, stat) {
-        cb(er, er ? false : checkStat(stat, path8, options));
-      });
-    }
-    function sync(path8, options) {
-      return checkStat(fs4.statSync(path8), path8, options);
-    }
-  }
-});
-
-// node_modules/isexe/mode.js
-var require_mode = __commonJS({
-  "node_modules/isexe/mode.js"(exports2, module2) {
-    module2.exports = isexe;
-    isexe.sync = sync;
-    var fs4 = require("fs");
-    function isexe(path8, options, cb) {
-      fs4.stat(path8, function(er, stat) {
-        cb(er, er ? false : checkStat(stat, options));
-      });
-    }
-    function sync(path8, options) {
-      return checkStat(fs4.statSync(path8), options);
-    }
-    function checkStat(stat, options) {
-      return stat.isFile() && checkMode(stat, options);
-    }
-    function checkMode(stat, options) {
-      var mod = stat.mode;
-      var uid = stat.uid;
-      var gid = stat.gid;
-      var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
-      var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
-      var u = parseInt("100", 8);
-      var g = parseInt("010", 8);
-      var o = parseInt("001", 8);
-      var ug = u | g;
-      var ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
-      return ret;
-    }
-  }
-});
-
-// node_modules/isexe/index.js
-var require_isexe = __commonJS({
-  "node_modules/isexe/index.js"(exports2, module2) {
-    var fs4 = require("fs");
-    var core;
-    if (process.platform === "win32" || global.TESTING_WINDOWS) {
-      core = require_windows();
-    } else {
-      core = require_mode();
-    }
-    module2.exports = isexe;
-    isexe.sync = sync;
-    function isexe(path8, options, cb) {
-      if (typeof options === "function") {
-        cb = options;
-        options = {};
-      }
-      if (!cb) {
-        if (typeof Promise !== "function") {
-          throw new TypeError("callback not provided");
-        }
-        return new Promise(function(resolve, reject) {
-          isexe(path8, options || {}, function(er, is) {
-            if (er) {
-              reject(er);
-            } else {
-              resolve(is);
-            }
-          });
-        });
-      }
-      core(path8, options || {}, function(er, is) {
-        if (er) {
-          if (er.code === "EACCES" || options && options.ignoreErrors) {
-            er = null;
-            is = false;
-          }
-        }
-        cb(er, is);
-      });
-    }
-    function sync(path8, options) {
-      try {
-        return core.sync(path8, options || {});
-      } catch (er) {
-        if (options && options.ignoreErrors || er.code === "EACCES") {
-          return false;
-        } else {
-          throw er;
-        }
-      }
-    }
-  }
-});
-
-// node_modules/which/which.js
-var require_which = __commonJS({
-  "node_modules/which/which.js"(exports2, module2) {
-    var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-    var path8 = require("path");
-    var COLON = isWindows ? ";" : ":";
-    var isexe = require_isexe();
-    var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
-    var getPathInfo = (cmd, opt) => {
-      const colon = opt.colon || COLON;
-      const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
-        // windows always checks the cwd first
-        ...isWindows ? [process.cwd()] : [],
-        ...(opt.path || process.env.PATH || /* istanbul ignore next: very unusual */
-        "").split(colon)
-      ];
-      const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
-      const pathExt = isWindows ? pathExtExe.split(colon) : [""];
-      if (isWindows) {
-        if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
-          pathExt.unshift("");
-      }
-      return {
-        pathEnv,
-        pathExt,
-        pathExtExe
-      };
-    };
-    var which2 = (cmd, opt, cb) => {
-      if (typeof opt === "function") {
-        cb = opt;
-        opt = {};
-      }
-      if (!opt)
-        opt = {};
-      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
-      const found = [];
-      const step = (i) => new Promise((resolve, reject) => {
-        if (i === pathEnv.length)
-          return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
-        const ppRaw = pathEnv[i];
-        const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path8.join(pathPart, cmd);
-        const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-        resolve(subStep(p, i, 0));
-      });
-      const subStep = (p, i, ii) => new Promise((resolve, reject) => {
-        if (ii === pathExt.length)
-          return resolve(step(i + 1));
-        const ext = pathExt[ii];
-        isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
-          if (!er && is) {
-            if (opt.all)
-              found.push(p + ext);
-            else
-              return resolve(p + ext);
-          }
-          return resolve(subStep(p, i, ii + 1));
-        });
-      });
-      return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
-    };
-    var whichSync = (cmd, opt) => {
-      opt = opt || {};
-      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
-      const found = [];
-      for (let i = 0; i < pathEnv.length; i++) {
-        const ppRaw = pathEnv[i];
-        const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path8.join(pathPart, cmd);
-        const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-        for (let j = 0; j < pathExt.length; j++) {
-          const cur = p + pathExt[j];
-          try {
-            const is = isexe.sync(cur, { pathExt: pathExtExe });
-            if (is) {
-              if (opt.all)
-                found.push(cur);
-              else
-                return cur;
-            }
-          } catch (ex) {
-          }
-        }
-      }
-      if (opt.all && found.length)
-        return found;
-      if (opt.nothrow)
-        return null;
-      throw getNotFoundError(cmd);
-    };
-    module2.exports = which2;
-    which2.sync = whichSync;
-  }
-});
-
 // node_modules/colors/lib/styles.js
 var require_styles = __commonJS({
   "node_modules/colors/lib/styles.js"(exports2, module2) {
@@ -914,31 +690,255 @@ var require_safe = __commonJS({
   }
 });
 
-// node_modules/debounce/index.js
-var require_debounce = __commonJS({
-  "node_modules/debounce/index.js"(exports2, module2) {
-    function debounce3(func, wait2, immediate) {
-      var timeout, args, context, timestamp, result;
-      if (null == wait2) wait2 = 100;
-      function later() {
-        var last = Date.now() - timestamp;
-        if (last < wait2 && last >= 0) {
-          timeout = setTimeout(later, wait2 - last);
-        } else {
-          timeout = null;
-          if (!immediate) {
-            result = func.apply(context, args);
-            context = args = null;
-          }
+// node_modules/isexe/windows.js
+var require_windows = __commonJS({
+  "node_modules/isexe/windows.js"(exports2, module2) {
+    module2.exports = isexe;
+    isexe.sync = sync;
+    var fs4 = require("fs");
+    function checkPathExt(path8, options) {
+      var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
+      if (!pathext) {
+        return true;
+      }
+      pathext = pathext.split(";");
+      if (pathext.indexOf("") !== -1) {
+        return true;
+      }
+      for (var i = 0; i < pathext.length; i++) {
+        var p = pathext[i].toLowerCase();
+        if (p && path8.substr(-p.length).toLowerCase() === p) {
+          return true;
         }
       }
-      ;
+      return false;
+    }
+    function checkStat(stat, path8, options) {
+      if (!stat.isSymbolicLink() && !stat.isFile()) {
+        return false;
+      }
+      return checkPathExt(path8, options);
+    }
+    function isexe(path8, options, cb) {
+      fs4.stat(path8, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, path8, options));
+      });
+    }
+    function sync(path8, options) {
+      return checkStat(fs4.statSync(path8), path8, options);
+    }
+  }
+});
+
+// node_modules/isexe/mode.js
+var require_mode = __commonJS({
+  "node_modules/isexe/mode.js"(exports2, module2) {
+    module2.exports = isexe;
+    isexe.sync = sync;
+    var fs4 = require("fs");
+    function isexe(path8, options, cb) {
+      fs4.stat(path8, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, options));
+      });
+    }
+    function sync(path8, options) {
+      return checkStat(fs4.statSync(path8), options);
+    }
+    function checkStat(stat, options) {
+      return stat.isFile() && checkMode(stat, options);
+    }
+    function checkMode(stat, options) {
+      var mod = stat.mode;
+      var uid = stat.uid;
+      var gid = stat.gid;
+      var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
+      var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
+      var u = parseInt("100", 8);
+      var g = parseInt("010", 8);
+      var o = parseInt("001", 8);
+      var ug = u | g;
+      var ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+      return ret;
+    }
+  }
+});
+
+// node_modules/isexe/index.js
+var require_isexe = __commonJS({
+  "node_modules/isexe/index.js"(exports2, module2) {
+    var fs4 = require("fs");
+    var core;
+    if (process.platform === "win32" || global.TESTING_WINDOWS) {
+      core = require_windows();
+    } else {
+      core = require_mode();
+    }
+    module2.exports = isexe;
+    isexe.sync = sync;
+    function isexe(path8, options, cb) {
+      if (typeof options === "function") {
+        cb = options;
+        options = {};
+      }
+      if (!cb) {
+        if (typeof Promise !== "function") {
+          throw new TypeError("callback not provided");
+        }
+        return new Promise(function(resolve, reject) {
+          isexe(path8, options || {}, function(er, is) {
+            if (er) {
+              reject(er);
+            } else {
+              resolve(is);
+            }
+          });
+        });
+      }
+      core(path8, options || {}, function(er, is) {
+        if (er) {
+          if (er.code === "EACCES" || options && options.ignoreErrors) {
+            er = null;
+            is = false;
+          }
+        }
+        cb(er, is);
+      });
+    }
+    function sync(path8, options) {
+      try {
+        return core.sync(path8, options || {});
+      } catch (er) {
+        if (options && options.ignoreErrors || er.code === "EACCES") {
+          return false;
+        } else {
+          throw er;
+        }
+      }
+    }
+  }
+});
+
+// node_modules/which/which.js
+var require_which = __commonJS({
+  "node_modules/which/which.js"(exports2, module2) {
+    var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+    var path8 = require("path");
+    var COLON = isWindows ? ";" : ":";
+    var isexe = require_isexe();
+    var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+    var getPathInfo = (cmd, opt) => {
+      const colon = opt.colon || COLON;
+      const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
+        // windows always checks the cwd first
+        ...isWindows ? [process.cwd()] : [],
+        ...(opt.path || process.env.PATH || /* istanbul ignore next: very unusual */
+        "").split(colon)
+      ];
+      const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+      const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+      if (isWindows) {
+        if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
+          pathExt.unshift("");
+      }
+      return {
+        pathEnv,
+        pathExt,
+        pathExtExe
+      };
+    };
+    var which2 = (cmd, opt, cb) => {
+      if (typeof opt === "function") {
+        cb = opt;
+        opt = {};
+      }
+      if (!opt)
+        opt = {};
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      const step = (i) => new Promise((resolve, reject) => {
+        if (i === pathEnv.length)
+          return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+        const ppRaw = pathEnv[i];
+        const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+        const pCmd = path8.join(pathPart, cmd);
+        const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+        resolve(subStep(p, i, 0));
+      });
+      const subStep = (p, i, ii) => new Promise((resolve, reject) => {
+        if (ii === pathExt.length)
+          return resolve(step(i + 1));
+        const ext = pathExt[ii];
+        isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+          if (!er && is) {
+            if (opt.all)
+              found.push(p + ext);
+            else
+              return resolve(p + ext);
+          }
+          return resolve(subStep(p, i, ii + 1));
+        });
+      });
+      return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+    };
+    var whichSync = (cmd, opt) => {
+      opt = opt || {};
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (let i = 0; i < pathEnv.length; i++) {
+        const ppRaw = pathEnv[i];
+        const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+        const pCmd = path8.join(pathPart, cmd);
+        const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+        for (let j = 0; j < pathExt.length; j++) {
+          const cur = p + pathExt[j];
+          try {
+            const is = isexe.sync(cur, { pathExt: pathExtExe });
+            if (is) {
+              if (opt.all)
+                found.push(cur);
+              else
+                return cur;
+            }
+          } catch (ex) {
+          }
+        }
+      }
+      if (opt.all && found.length)
+        return found;
+      if (opt.nothrow)
+        return null;
+      throw getNotFoundError(cmd);
+    };
+    module2.exports = which2;
+    which2.sync = whichSync;
+  }
+});
+
+// node_modules/debounce/index.js
+var require_debounce = __commonJS({
+  "node_modules/debounce/index.js"(exports2, module2) {
+    function debounce3(func, wait, immediate) {
+      var timeout, args, context, timestamp, result;
+      if (null == wait) wait = 100;
+      function later() {
+        var last = Date.now() - timestamp;
+        if (last < wait && last >= 0) {
+          timeout = setTimeout(later, wait - last);
+        } else {
+          timeout = null;
+          if (!immediate) {
+            result = func.apply(context, args);
+            context = args = null;
+          }
+        }
+      }
+      ;
       var debounced = function() {
         context = this;
         args = arguments;
         timestamp = Date.now();
         var callNow = immediate && !timeout;
-        if (!timeout) timeout = setTimeout(later, wait2);
+        if (!timeout) timeout = setTimeout(later, wait);
         if (callNow) {
           result = func.apply(context, args);
           context = args = null;
@@ -4533,7 +4533,8 @@ var require_lib = __commonJS({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  activate: () => activate
+  activate: () => activate,
+  formatBlameText: () => formatBlameText
 });
 module.exports = __toCommonJS(index_exports);
 var import_coc16 = require("coc.nvim");
@@ -4583,290 +4584,17 @@ var DEFAULT_TYPES = [
 ];
 
 // src/lists/bcommits.ts
-var import_child_process2 = require("child_process");
-var import_coc2 = require("coc.nvim");
+var import_coc = require("coc.nvim");
 var import_events = require("events");
 var import_readline = __toESM(require("readline"));
-
-// src/util.ts
-var import_child_process = require("child_process");
-var import_coc = require("coc.nvim");
-var import_path = __toESM(require("path"));
-var import_which = __toESM(require_which());
-function reverseLine(line) {
-  if (line.startsWith("-")) return "+" + line.slice(1);
-  if (line.startsWith("+")) return "-" + line.slice(1);
-  return line;
-}
-function createUnstagePatch(relpath, chunk) {
-  if (chunk.remove.count == 0 && chunk.add.count == 0) return "";
-  let head = `@@ -${chunk.add.lnum},${chunk.add.count} +${chunk.add.lnum + 1 - chunk.add.count},${chunk.remove.count} @@`;
-  if (!head) return "";
-  const lines = [
-    `diff --git a/${relpath} b/${relpath}`,
-    `index 000000..000000 100644`,
-    `--- a/${relpath}`,
-    `+++ b/${relpath}`,
-    head
-  ];
-  lines.push(...chunk.lines.map((s) => reverseLine(s)));
-  lines.push("");
-  return lines.join("\n");
-}
-function wait(ms) {
-  return new Promise((resolve) => {
-    setTimeout(() => {
-      resolve(void 0);
-    }, ms);
-  });
-}
-function shellescape(s) {
-  if (process.platform == "win32") {
-    return `"${s.replace(/"/g, '\\"')}"`;
-  }
-  if (/[^A-Za-z0-9_\/:=-]/.test(s)) {
-    s = "'" + s.replace(/'/g, "'\\''") + "'";
-    s = s.replace(/^(?:'')+/g, "").replace(/\\'''/g, "\\'");
-    return s;
+var CommitsTask = class extends import_events.EventEmitter {
+  constructor(root, file) {
+    super();
+    this.root = root;
+    this.file = file;
   }
-  return s;
-}
-function toUnixSlash(fsPath) {
-  if (process.platform == "win32") {
-    return fsPath.replace(/\\/g, "/");
-  }
-  return fsPath;
-}
-async function safeRun(cmd, opts = {}) {
-  try {
-    return await runCommand(cmd, opts, 5e3);
-  } catch (e) {
-    console.error(e.message);
-    return null;
-  }
-}
-function spawnCommand(cmd, args, cwd) {
-  const cp2 = (0, import_child_process.spawn)(cmd, args, { cwd });
-  let res = "";
-  return new Promise((resolve, reject) => {
-    cp2.stdout.on("data", (data) => {
-      res += data.toString();
-    });
-    cp2.stderr.on("data", (data) => {
-      import_coc.window.showErrorMessage(`"${cmd} ${args.join(" ")}" error: ${data.toString()}`);
-    });
-    cp2.on("close", (code) => {
-      if (code != 0) {
-        return reject(new Error(`${cmd} exited with code ${code}`));
-      }
-      resolve(res);
-    });
-  });
-}
-function runCommand(cmd, opts = {}, timeout) {
-  opts.maxBuffer = 5 * 1024 * 1024;
-  return new Promise((resolve, reject) => {
-    let timer;
-    if (timeout) {
-      timer = setTimeout(() => {
-        reject(new Error(`timeout after ${timeout}s`));
-      }, timeout * 1e3);
-    }
-    (0, import_child_process.exec)(cmd, opts, (err, stdout, stderr) => {
-      if (timer) clearTimeout(timer);
-      if (err) {
-        reject(new Error(`exited with ${err.code}
-${stderr}`));
-        return;
-      }
-      resolve(stdout);
-    });
-  });
-}
-function getStdout(cmd, opts = {}, timeout) {
-  return new Promise((resolve, reject) => {
-    let timer;
-    if (timeout) {
-      timer = setTimeout(() => {
-        reject(new Error(`timeout after ${timeout}s`));
-      }, timeout * 1e3);
-    }
-    opts.maxBuffer = 5 * 1024 * 1024;
-    (0, import_child_process.exec)(cmd, opts, (_err, stdout) => {
-      if (timer) clearTimeout(timer);
-      if (stdout) {
-        resolve(stdout);
-        return;
-      }
-      resolve(void 0);
-    });
-  });
-}
-function equals(one, other) {
-  if (one === other) {
-    return true;
-  }
-  if (one === null || one === void 0 || other === null || other === void 0) {
-    return false;
-  }
-  if (typeof one !== typeof other) {
-    return false;
-  }
-  if (typeof one !== "object") {
-    return false;
-  }
-  if (Array.isArray(one) !== Array.isArray(other)) {
-    return false;
-  }
-  let i;
-  let key;
-  if (Array.isArray(one)) {
-    if (one.length !== other.length) {
-      return false;
-    }
-    for (i = 0; i < one.length; i++) {
-      if (!equals(one[i], other[i])) {
-        return false;
-      }
-    }
-  } else {
-    const oneKeys = [];
-    for (key in one) {
-      oneKeys.push(key);
-    }
-    oneKeys.sort();
-    const otherKeys = [];
-    for (key in other) {
-      otherKeys.push(key);
-    }
-    otherKeys.sort();
-    if (!equals(oneKeys, otherKeys)) {
-      return false;
-    }
-    for (i = 0; i < oneKeys.length; i++) {
-      if (!equals(one[oneKeys[i]], other[oneKeys[i]])) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-function getRepoUrl(remote) {
-  if (import_path.default.isAbsolute(remote)) return null;
-  let url = remote.replace(/\s+$/, "").replace(/\.git$/, "");
-  if (url.startsWith("git@")) {
-    let str = url.slice(4);
-    let parts = str.split(":", 2);
-    url = `https://${parts[0]}/${parts[1]}`;
-  }
-  return url;
-}
-function getUrl(fix, repoURL, name, filepath, lines) {
-  let anchor = "";
-  if (lines && Array.isArray(lines)) {
-    anchor = lines ? lines.map((l) => `L${l}`).join("-") : "";
-  } else if (typeof lines == "string") {
-    anchor = lines;
-  }
-  let url = repoURL + "/blob/" + name + "/" + filepath + (anchor ? "#" + anchor : "");
-  let parts = fix.split("|");
-  let match = RegExp(parts[0]), result = parts[1];
-  return url.replace(match, result);
-}
-function parseVersion(raw) {
-  return raw.replace(/^git version /, "");
-}
-function findSystemGitWin32(base, onLookup) {
-  if (!base) {
-    return Promise.reject("Not found");
-  }
-  return findSpecificGit(import_path.default.join(base, "Git", "cmd", "git.exe"), onLookup);
-}
-function findGitWin32InPath(onLookup) {
-  const whichPromise = new Promise((c, e) => (0, import_which.default)("git.exe", (err, path8) => err ? e(err) : c(path8)));
-  return whichPromise.then((path8) => findSpecificGit(path8, onLookup));
-}
-function findGitWin32(onLookup) {
-  return findSystemGitWin32(process.env["ProgramW6432"], onLookup).then(void 0, () => findSystemGitWin32(process.env["ProgramFiles(x86)"], onLookup)).then(void 0, () => findSystemGitWin32(process.env["ProgramFiles"], onLookup)).then(void 0, () => findSystemGitWin32(import_path.default.join(process.env["LocalAppData"], "Programs"), onLookup)).then(void 0, () => findGitWin32InPath(onLookup));
-}
-function findSpecificGit(path8, onLookup) {
-  return new Promise((c, e) => {
-    onLookup(path8);
-    const buffers = [];
-    const child = (0, import_child_process.spawn)(path8, ["--version"]);
-    child.stdout.on("data", (b) => buffers.push(b));
-    child.on("error", cpErrorHandler(e));
-    child.on("exit", (code) => code ? e(new Error("Not found")) : c({ path: path8, version: parseVersion(Buffer.concat(buffers).toString("utf8").trim()) }));
-  });
-}
-function cpErrorHandler(cb) {
-  return (err) => {
-    if (/ENOENT/.test(err.message)) {
-      err = new Error("Failed to execute git (ENOENT)");
-    }
-    cb(err);
-  };
-}
-function findGitDarwin(onLookup) {
-  return new Promise((c, e) => {
-    (0, import_child_process.exec)("which git", (err, gitPathBuffer) => {
-      if (err) {
-        return e("git not found");
-      }
-      const path8 = gitPathBuffer.toString().replace(/^\s+|\s+$/g, "");
-      function getVersion(path9) {
-        onLookup(path9);
-        (0, import_child_process.exec)("git --version", (err2, stdout) => {
-          if (err2) {
-            return e("git not found");
-          }
-          return c({ path: path9, version: parseVersion(stdout.trim()) });
-        });
-      }
-      if (path8 !== "/usr/bin/git") {
-        return getVersion(path8);
-      }
-      getVersion(path8);
-      (0, import_child_process.exec)("xcode-select -p", (err2) => {
-        if (err2 && err2.code === 2) {
-          return e("git not found");
-        }
-      });
-    });
-  });
-}
-function findGit(hint, onLookup) {
-  const first = hint ? findSpecificGit(hint, onLookup) : Promise.reject(null);
-  return first.then(void 0, () => {
-    switch (process.platform) {
-      case "darwin":
-        return findGitDarwin(onLookup);
-      case "win32":
-        return findGitWin32(onLookup);
-      default:
-        return findSpecificGit("git", onLookup);
-    }
-  }).then(null, () => Promise.reject(new Error("Git installation not found.")));
-}
-function onceEvent(event) {
-  return (listener, thisArgs = null, disposables) => {
-    const result = event((e) => {
-      result.dispose();
-      return listener.call(thisArgs, e);
-    }, null, disposables);
-    return result;
-  };
-}
-
-// src/lists/bcommits.ts
-var CommitsTask = class extends import_events.EventEmitter {
-  constructor(root, file) {
-    super();
-    this.root = root;
-    this.file = file;
-  }
-  start(cmd, args, cwd) {
-    this.process = (0, import_child_process2.spawn)(cmd, args, { cwd });
+  start(process2) {
+    this.process = process2;
     this.process.on("error", (e) => {
       this.emit("error", e.message);
     });
@@ -4876,7 +4604,7 @@ var CommitsTask = class extends import_events.EventEmitter {
     const rl = import_readline.default.createInterface(this.process.stdout);
     rl.on("line", (line) => {
       if (!line.length) return;
-      let res = (0, import_coc2.ansiparse)(line);
+      let res = (0, import_coc.ansiparse)(line);
       let idx = res.findIndex((o) => o.foreground == "yellow");
       let message = idx == -1 ? null : res[idx + 1].text;
       let item = res.find((o) => o.foreground == "red" && o.text.length > 4);
@@ -4901,7 +4629,7 @@ var CommitsTask = class extends import_events.EventEmitter {
     }
   }
 };
-var Bcommits = class extends import_coc2.BasicList {
+var Bcommits = class extends import_coc.BasicList {
   constructor(nvim, manager) {
     super();
     this.manager = manager;
@@ -4912,7 +4640,7 @@ var Bcommits = class extends import_coc2.BasicList {
       let { commit, root } = item.data;
       let lines = [];
       if (commit) {
-        let content = await (0, import_coc2.runCommand)(`git --no-pager show ${commit}`, { cwd: root });
+        let content = (await this.manager.git.exec(root, ["--no-pager", "show", commit])).stdout;
         lines = content.trim().split("\n");
       }
       await this.preview({
@@ -4931,7 +4659,7 @@ var Bcommits = class extends import_coc2.BasicList {
         await nvim.command(`${cmd} ${commit}`);
       } else {
         let cmd = ctx.options.position === "tab" ? "tabe" : "edit";
-        let content = await (0, import_coc2.runCommand)(`git --no-pager show ${commit}`, { cwd: root });
+        let content = (await this.manager.git.exec(root, ["--no-pager", "show", commit])).stdout;
         let lines = content.trim().split("\n");
         nvim.pauseNotification();
         nvim.command(`${cmd} +setl\\ buftype=nofile [commit ${commit}]`, true);
@@ -4946,11 +4674,12 @@ var Bcommits = class extends import_coc2.BasicList {
     this.addAction("view", async (item, context) => {
       let { commit, root, file } = item.data;
       let { window: window10 } = context;
-      let content = await (0, import_coc2.runCommand)(`git show ${commit}:${shellescape(file)}`, { cwd: root });
+      let content = (await this.manager.git.exec(root, ["show", `${commit}:${file}`])).stdout;
       let lines = content.replace(/\n$/, "").split("\n");
+      let name = await nvim.call("fnameescape", [`(${commit}) ${file}`]);
       nvim.pauseNotification();
       nvim.call("win_gotoid", [window10.id], true);
-      nvim.command(`exe "tabe ".fnameescape('(${commit}) ${file}')`, true);
+      nvim.command(`tabe ${name}`, true);
       nvim.call("append", [0, lines], true);
       nvim.command("normal! Gdd", true);
       nvim.command(`exe 1`, true);
@@ -4963,7 +4692,7 @@ var Bcommits = class extends import_coc2.BasicList {
       let filetype = await buffer.getOption("filetype");
       let { root, commit, file } = item.data;
       if (!commit) return;
-      let content = await (0, import_coc2.runCommand)(`git --no-pager show --no-color ${commit}:${file}`, { cwd: root });
+      let content = (await this.manager.git.exec(root, ["--no-pager", "show", "--no-color", `${commit}:${file}`])).stdout;
       if (!content) return;
       let lines = content.replace(/\n$/, "").split(/\r?\n/);
       nvim.pauseNotification();
@@ -4980,7 +4709,7 @@ var Bcommits = class extends import_coc2.BasicList {
       nvim.command(`call setpos('.', [bufnr('%'), 0, 0, 0])`, true);
       await nvim.resumeNotification();
     });
-    import_coc2.events.on("BufEnter", async (bufnr) => {
+    import_coc.events.on("BufEnter", async (bufnr) => {
       if (!this.bufnr || bufnr != this.bufnr) return;
       let diff = await nvim.eval("&diff");
       if (!diff) return;
@@ -5015,13 +4744,13 @@ var Bcommits = class extends import_coc2.BasicList {
       relpath
     ];
     let task = new CommitsTask(root, relpath);
-    task.start("git", args, root);
+    task.start(this.manager.git.stream(root, args));
     return task;
   }
 };
 
 // src/lists/branches.ts
-var import_coc3 = require("coc.nvim");
+var import_coc2 = require("coc.nvim");
 var import_safe = __toESM(require_safe());
 var Branches = class {
   constructor(nvim, manager) {
@@ -5034,7 +4763,7 @@ var Branches = class {
       name: "checkout",
       execute: async (item) => {
         let { root, branch } = item.data;
-        await safeRun(`git checkout ${branch}`, { cwd: root });
+        await this.manager.git.exec(root, ["checkout", branch]);
         nvim.command("bufdo e", true);
       }
     });
@@ -5043,22 +4772,23 @@ var Branches = class {
       persist: true,
       reload: true,
       execute: async (item) => {
-        let cmd;
         let { root, branch, remote } = item.data;
         if (remote) {
-          let res = await import_coc3.window.showPrompt(`Delete remote branch ${branch}?`);
+          let res = await import_coc2.window.showPrompt(`Delete remote branch ${branch}?`);
           if (!res) return;
-          let parts = branch.split("/", 2);
-          cmd = `git push ${parts[0]} --delete ${parts[1]}`;
-          await safeRun(cmd, { cwd: root });
-          await safeRun(`git fetch -p ${parts[0]}`);
+          let separator = branch.indexOf("/");
+          if (separator === -1) throw new Error(`Invalid remote branch: ${branch}`);
+          let remoteName = branch.slice(0, separator);
+          let remoteBranch = branch.slice(separator + 1);
+          await this.manager.git.exec(root, ["push", remoteName, "--delete", remoteBranch]);
+          await this.manager.git.exec(root, ["fetch", "-p", remoteName]);
         } else {
-          cmd = `git branch -d ${branch}`;
-          let res = await safeRun(cmd, { cwd: root });
-          if (res == null) {
-            let res2 = await import_coc3.window.showPrompt(`Delete failed, force delete ${branch}?`);
-            if (!res2) return;
-            await safeRun(`git branch -D ${branch}`, { cwd: root });
+          try {
+            await this.manager.git.exec(root, ["branch", "-d", branch]);
+          } catch (_e) {
+            let res = await import_coc2.window.showPrompt(`Delete failed, force delete ${branch}?`);
+            if (!res) return;
+            await this.manager.git.exec(root, ["branch", "-D", branch]);
           }
         }
       }
@@ -5067,8 +4797,7 @@ var Branches = class {
       name: "merge",
       execute: async (item) => {
         let { root, branch } = item.data;
-        let cmd = `git merge ${branch}`;
-        await safeRun(cmd, { cwd: root });
+        await this.manager.git.exec(root, ["merge", branch]);
         nvim.command("bufdo e", true);
       }
     });
@@ -5076,8 +4805,7 @@ var Branches = class {
       name: "rebase",
       execute: async (item) => {
         let { root, branch } = item.data;
-        let cmd = `git rebase ${branch}`;
-        await safeRun(cmd, { cwd: root });
+        await this.manager.git.exec(root, ["rebase", branch]);
         nvim.command("bufdo e", true);
       }
     });
@@ -5112,8 +4840,7 @@ var Branches = class {
 };
 
 // src/lists/commits.ts
-var import_child_process3 = require("child_process");
-var import_coc4 = require("coc.nvim");
+var import_coc3 = require("coc.nvim");
 var import_events2 = require("events");
 var import_readline2 = __toESM(require("readline"));
 var CommitsTask2 = class extends import_events2.EventEmitter {
@@ -5121,8 +4848,8 @@ var CommitsTask2 = class extends import_events2.EventEmitter {
     super();
     this.root = root;
   }
-  start(cmd, args, cwd) {
-    this.process = (0, import_child_process3.spawn)(cmd, args, { cwd });
+  start(process2) {
+    this.process = process2;
     this.process.on("error", (e) => {
       this.emit("error", e.message);
     });
@@ -5132,7 +4859,7 @@ var CommitsTask2 = class extends import_events2.EventEmitter {
     const rl = import_readline2.default.createInterface(this.process.stdout);
     rl.on("line", (line) => {
       if (!line.length) return;
-      let res = (0, import_coc4.ansiparse)(line);
+      let res = (0, import_coc3.ansiparse)(line);
       let idx = res.findIndex((o) => o.foreground == "yellow");
       let message = idx == -1 ? null : res[idx + 1].text;
       let item = res.find((o) => o.foreground == "red" && o.text.length > 4);
@@ -5156,7 +4883,7 @@ var CommitsTask2 = class extends import_events2.EventEmitter {
     }
   }
 };
-var Commits = class extends import_coc4.BasicList {
+var Commits = class extends import_coc3.BasicList {
   constructor(nvim, manager) {
     super();
     this.manager = manager;
@@ -5168,12 +4895,11 @@ var Commits = class extends import_coc4.BasicList {
       let { commit, root } = item.data;
       let lines = [];
       if (commit) {
-        lines = this.cachedCommits.get(commit);
+        lines = this.getCached(root, commit);
         if (!lines) {
-          let content = await safeRun(`git --no-pager show ${commit}`, { cwd: root });
-          if (content == null) return;
+          let content = (await this.manager.git.exec(root, ["--no-pager", "show", commit])).stdout;
           lines = content.replace(/\n$/, "").split(/\r?\n/);
-          this.cachedCommits.set(commit, lines);
+          this.setCached(root, commit, lines);
         }
       }
       await this.preview({
@@ -5191,12 +4917,11 @@ var Commits = class extends import_coc4.BasicList {
         let cmd = ctx.options.position === "tab" ? "Gtabedit" : "Gedit";
         await nvim.command(`${cmd} ${commit}`);
       } else {
-        let lines = this.cachedCommits.get(commit);
+        let lines = this.getCached(root, commit);
         if (!lines) {
-          let content = await safeRun(`git --no-pager show ${commit}`, { cwd: root });
-          if (content == null) return;
+          let content = (await this.manager.git.exec(root, ["--no-pager", "show", commit])).stdout;
           lines = content.replace(/\n$/, "").split(/\r?\n/);
-          this.cachedCommits.set(commit, lines);
+          this.setCached(root, commit, lines);
         }
         let cmd = ctx.options.position === "tab" ? "tabe" : "edit";
         nvim.pauseNotification();
@@ -5227,20 +4952,18 @@ var Commits = class extends import_coc4.BasicList {
           opt = "--hard";
           break;
       }
-      await runCommand(`git reset ${opt} ${commit}`, { cwd: root });
-      this.nvim.command("checktime", true);
-      await wait(100);
+      await this.manager.git.exec(root, ["reset", opt, commit]);
+      await this.nvim.command("checktime");
     });
     this.addAction("checkout", async (item) => {
       let { root, commit } = item.data;
       if (!commit) return;
-      await runCommand(`git checkout ${commit}`, { cwd: root });
+      await this.manager.git.exec(root, ["checkout", commit]);
     });
     this.addMultipleAction("revert", async (items) => {
       let list = items.filter((item) => item.data.commit != null);
       if (!list.length) return;
-      let arg = list.map((o) => o.data.commit).join(" ");
-      await runCommand(`git revert ${arg}`, { cwd: list[0].data.root });
+      await this.manager.git.exec(list[0].data.root, ["revert", ...list.map((o) => o.data.commit)]);
     });
     this.addMultipleAction("tabdiff", async (items) => {
       let list = items.filter((item) => item.data.commit != null);
@@ -5251,7 +4974,7 @@ var Commits = class extends import_coc4.BasicList {
       } else {
         arg = `${list[1].data.commit} ${list[0].data.commit}`;
       }
-      let content = await runCommand(`git --no-pager diff --no-ext-diff ${this.manager.diffOptions.join(" ")} ${arg}`, { cwd: list[0].data.root });
+      let content = (await this.manager.git.exec(list[0].data.root, ["--no-pager", "diff", "--no-ext-diff", ...this.manager.diffOptions, ...arg.split(" ")])).stdout;
       let lines = content.replace(/\n$/, "").split("\n");
       nvim.pauseNotification();
       nvim.command(`tabe [diff ${arg}]`, true);
@@ -5275,7 +4998,7 @@ var Commits = class extends import_coc4.BasicList {
       } else {
         arg = `${list[1].data.commit} ${list[0].data.commit}`;
       }
-      let content = await runCommand(`git --no-pager diff ${this.manager.diffOptions.join(" ")} --no-ext-diff ${arg}`, { cwd: list[0].data.root });
+      let content = (await this.manager.git.exec(list[0].data.root, ["--no-pager", "diff", ...this.manager.diffOptions, "--no-ext-diff", ...arg.split(" ")])).stdout;
       let lines = content.replace(/\n$/, "").split("\n");
       let winid = context.listWindow.id;
       let mod = context.options.position == "tab" ? "below" : "above";
@@ -5302,6 +5025,20 @@ var Commits = class extends import_coc4.BasicList {
       nvim.command(`CocList gfiles ${commit}`, true);
     });
   }
+  cacheKey(root, commit) {
+    return `${root}\0${commit}`;
+  }
+  getCached(root, commit) {
+    return this.cachedCommits.get(this.cacheKey(root, commit));
+  }
+  setCached(root, commit, lines) {
+    const key = this.cacheKey(root, commit);
+    this.cachedCommits.delete(key);
+    this.cachedCommits.set(key, lines);
+    if (this.cachedCommits.size > 100) {
+      this.cachedCommits.delete(this.cachedCommits.keys().next().value);
+    }
+  }
   async loadItems(context) {
     let buf = await context.window.buffer;
     let root = await this.manager.resolveGitRootFromBufferOrCwd(buf.id);
@@ -5320,15 +5057,23 @@ var Commits = class extends import_coc4.BasicList {
       ...context.args
     ];
     let task = new CommitsTask2(root);
-    task.start("git", args, root);
+    task.start(this.manager.git.stream(root, args));
     return task;
   }
 };
 
 // src/lists/gfiles.ts
-var import_coc5 = require("coc.nvim");
-var import_path2 = __toESM(require("path"));
-var Gfiles = class extends import_coc5.BasicList {
+var import_coc4 = require("coc.nvim");
+var import_path = __toESM(require("path"));
+function parseTreeEntry(entry) {
+  const separator = entry.indexOf("	");
+  if (separator === -1) return void 0;
+  const head = entry.slice(0, separator);
+  const filepath = entry.slice(separator + 1);
+  const sha = head.split(/\s+/)[2];
+  return sha ? { sha, filepath } : void 0;
+}
+var Gfiles = class extends import_coc4.BasicList {
   constructor(nvim, manager) {
     super();
     this.manager = manager;
@@ -5337,7 +5082,7 @@ var Gfiles = class extends import_coc5.BasicList {
     this.detail = "Pass git sha as first command argument, when empty, HEAD is used.\nExample: :CocList gfiles 7b5c5cb";
     this.defaultAction = "edit";
     this.actions = [];
-    const preferences = import_coc5.workspace.getConfiguration("coc.preferences");
+    const preferences = import_coc4.workspace.getConfiguration("coc.preferences");
     let jumpCommand = preferences.get("jumpCommand", "edit");
     for (let name of ["edit", "tabe", "vsplit", "split"]) {
       this.addAction(name, async (item, ctx) => {
@@ -5346,15 +5091,16 @@ var Gfiles = class extends import_coc5.BasicList {
         if (branch == "HEAD") {
           let cmd2 = name == "edit" ? jumpCommand : name;
           if (ctx.options.position === "tab") cmd2 = "tabe";
-          let fullpath = import_path2.default.join(root, filepath);
-          await import_coc5.workspace.jumpTo(import_coc5.Uri.file(fullpath).toString(), null, cmd2);
+          let fullpath = import_path.default.join(root, filepath);
+          await import_coc4.workspace.jumpTo(import_coc4.Uri.file(fullpath).toString(), null, cmd2);
           return;
         }
-        let content = await runCommand(`git cat-file -p ${sha}`, { cwd: root });
+        let content = (await this.manager.git.exec(root, ["cat-file", "-p", sha])).stdout;
         let lines = content.replace(/\n$/, "").split("\n");
         let cmd = name == "edit" ? jumpCommand : name;
+        let bufferName = await nvim.call("fnameescape", [`(${branch}) ${filepath}`]);
         nvim.pauseNotification();
-        nvim.command(`exe "${cmd} ".fnameescape('(${branch}) ${filepath}')`, true);
+        nvim.command(`${cmd} ${bufferName}`, true);
         nvim.call("append", [0, lines], true);
         nvim.command("normal! Gdd", true);
         nvim.command(`exe 1`, true);
@@ -5363,54 +5109,291 @@ var Gfiles = class extends import_coc5.BasicList {
         await nvim.resumeNotification();
       }, { tabPersist: name === "edit" });
     }
-    this.addAction("preview", async (item, context) => {
-      let { root, sha, filepath, branch } = item.data;
-      if (!sha) return;
-      let content = await runCommand(`git --no-pager diff ${this.manager.diffOptions.join(" ")} --no-ext-diff ${branch} -- ${shellescape(filepath)}`, { cwd: root });
-      let lines = content.replace(/\n$/, "").split("\n");
-      await this.preview({
-        lines,
-        filetype: "diff",
-        sketch: true,
-        bufname: `(diff ${branch}) ${import_path2.default.basename(filepath)}`
-      }, context);
-    });
+    this.addAction("preview", async (item, context) => {
+      let { root, sha, filepath, branch } = item.data;
+      if (!sha) return;
+      let content = (await this.manager.git.exec(root, ["--no-pager", "diff", ...this.manager.diffOptions, "--no-ext-diff", branch, "--", filepath])).stdout;
+      let lines = content.replace(/\n$/, "").split("\n");
+      await this.preview({
+        lines,
+        filetype: "diff",
+        sketch: true,
+        bufname: `(diff ${branch}) ${import_path.default.basename(filepath)}`
+      }, context);
+    });
+  }
+  async loadItems(context) {
+    let buf = await context.window.buffer;
+    let root = await this.manager.resolveGitRootFromBufferOrCwd(buf.id);
+    if (!root) {
+      throw new Error(`Can't resolve git root.`);
+      return;
+    }
+    const { args } = context;
+    let revisions = args.length ? args : ["HEAD"];
+    const output = (await this.manager.git.exec(root, ["-c", "core.quotepath=false", "ls-tree", "-r", "-z", ...revisions])).stdout;
+    if (!output) return [];
+    let res = [];
+    for (let line of output.split("\0")) {
+      if (!line) continue;
+      const entry = parseTreeEntry(line);
+      if (!entry) continue;
+      const { sha, filepath } = entry;
+      res.push({
+        label: filepath,
+        data: {
+          branch: args[0] || "HEAD",
+          filepath,
+          root,
+          sha
+        }
+      });
+    }
+    return res;
+  }
+};
+
+// src/lists/gstatus.ts
+var import_coc6 = require("coc.nvim");
+var import_safe2 = __toESM(require_safe());
+var import_fs = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+
+// src/util.ts
+var import_child_process = require("child_process");
+var import_coc5 = require("coc.nvim");
+var import_path2 = __toESM(require("path"));
+var import_which = __toESM(require_which());
+function reverseLine(line) {
+  if (line.startsWith("-")) return "+" + line.slice(1);
+  if (line.startsWith("+")) return "-" + line.slice(1);
+  return line;
+}
+function quoteGitPath(filepath) {
+  if (!/[\s"\\\x00-\x1f\x7f]/.test(filepath)) return filepath;
+  return `"${filepath.replace(/["\\\x00-\x1f\x7f]/g, (character) => {
+    switch (character) {
+      case '"':
+        return '\\"';
+      case "\\":
+        return "\\\\";
+      case "	":
+        return "\\t";
+      case "\n":
+        return "\\n";
+      case "\r":
+        return "\\r";
+      default:
+        return `\\${character.charCodeAt(0).toString(8).padStart(3, "0")}`;
+    }
+  })}"`;
+}
+function createUnstagePatch(relpath, chunk) {
+  if (chunk.remove.count == 0 && chunk.add.count == 0) return "";
+  let head = `@@ -${chunk.add.lnum},${chunk.add.count} +${chunk.add.lnum + 1 - chunk.add.count},${chunk.remove.count} @@`;
+  if (!head) return "";
+  const from = quoteGitPath(`a/${relpath}`);
+  const to = quoteGitPath(`b/${relpath}`);
+  const lines = [
+    `diff --git ${from} ${to}`,
+    `index 000000..000000 100644`,
+    `--- ${from}`,
+    `+++ ${to}`,
+    head
+  ];
+  lines.push(...chunk.lines.map((s) => reverseLine(s)));
+  lines.push("");
+  return lines.join("\n");
+}
+function formatBlameText(info, format2 = "(%a %t) %s") {
+  let { author = "", time = "", summary = "", sha = "" } = info;
+  return format2.replace(/%%/g, "\0").replace(/%a/g, author).replace(/%t/g, time).replace(/%s/g, summary).replace(/%S/g, sha.substring(0, 7)).replace(/\u0000/g, "%");
+}
+function toUnixSlash(fsPath) {
+  if (process.platform == "win32") {
+    return fsPath.replace(/\\/g, "/");
+  }
+  return fsPath;
+}
+function spawnCommand(cmd, args, cwd) {
+  const cp2 = (0, import_child_process.spawn)(cmd, args, { cwd });
+  let res = "";
+  return new Promise((resolve, reject) => {
+    cp2.on("error", reject);
+    cp2.stdout.on("data", (data) => {
+      res += data.toString();
+    });
+    cp2.stderr.on("data", (data) => {
+      import_coc5.window.showErrorMessage(`"${cmd} ${args.join(" ")}" error: ${data.toString()}`);
+    });
+    cp2.on("close", (code) => {
+      if (code != 0) {
+        return reject(new Error(`${cmd} exited with code ${code}`));
+      }
+      resolve(res);
+    });
+  });
+}
+function equals(one, other) {
+  if (one === other) {
+    return true;
+  }
+  if (one === null || one === void 0 || other === null || other === void 0) {
+    return false;
+  }
+  if (typeof one !== typeof other) {
+    return false;
+  }
+  if (typeof one !== "object") {
+    return false;
+  }
+  if (Array.isArray(one) !== Array.isArray(other)) {
+    return false;
+  }
+  let i;
+  let key;
+  if (Array.isArray(one)) {
+    if (one.length !== other.length) {
+      return false;
+    }
+    for (i = 0; i < one.length; i++) {
+      if (!equals(one[i], other[i])) {
+        return false;
+      }
+    }
+  } else {
+    const oneKeys = [];
+    for (key in one) {
+      oneKeys.push(key);
+    }
+    oneKeys.sort();
+    const otherKeys = [];
+    for (key in other) {
+      otherKeys.push(key);
+    }
+    otherKeys.sort();
+    if (!equals(oneKeys, otherKeys)) {
+      return false;
+    }
+    for (i = 0; i < oneKeys.length; i++) {
+      if (!equals(one[oneKeys[i]], other[oneKeys[i]])) {
+        return false;
+      }
+    }
   }
-  async loadItems(context) {
-    let buf = await context.window.buffer;
-    let root = await this.manager.resolveGitRootFromBufferOrCwd(buf.id);
-    if (!root) {
-      throw new Error(`Can't resolve git root.`);
-      return;
+  return true;
+}
+function getRepoUrl(remote) {
+  if (import_path2.default.isAbsolute(remote)) return null;
+  let url = remote.replace(/\s+$/, "").replace(/\.git$/, "");
+  if (url.startsWith("git@")) {
+    let str = url.slice(4);
+    let parts = str.split(":", 2);
+    url = `https://${parts[0]}/${parts[1]}`;
+  } else if (url.startsWith("ssh://git@")) {
+    url = url.replace(/^ssh:\/\/git@([^/]+)\//, "https://$1/");
+  } else if (url.startsWith("git://")) {
+    url = url.replace(/^git:\/\//, "https://");
+  }
+  return /^https?:\/\//.test(url) ? url : null;
+}
+function getUrl(fix, repoURL, name, filepath, lines) {
+  let anchor = "";
+  if (lines && Array.isArray(lines)) {
+    anchor = lines ? lines.map((l) => `L${l}`).join("-") : "";
+  } else if (typeof lines == "string") {
+    anchor = lines;
+  }
+  const encodePath = (value) => value.split("/").map(encodeURIComponent).join("/");
+  let url = repoURL + "/blob/" + encodePath(name) + "/" + encodePath(filepath) + (anchor ? "#" + encodeURIComponent(anchor) : "");
+  let parts = fix.split("|");
+  if (parts.length < 2) return url;
+  try {
+    let match = RegExp(parts[0]), result = parts[1];
+    return url.replace(match, result);
+  } catch (_e) {
+    return url;
+  }
+}
+function parseVersion(raw) {
+  return raw.replace(/^git version /, "");
+}
+function findSystemGitWin32(base, onLookup) {
+  if (!base) {
+    return Promise.reject("Not found");
+  }
+  return findSpecificGit(import_path2.default.join(base, "Git", "cmd", "git.exe"), onLookup);
+}
+function findGitWin32InPath(onLookup) {
+  const whichPromise = new Promise((c, e) => (0, import_which.default)("git.exe", (err, path8) => err ? e(err) : c(path8)));
+  return whichPromise.then((path8) => findSpecificGit(path8, onLookup));
+}
+function findGitWin32(onLookup) {
+  return findSystemGitWin32(process.env["ProgramW6432"], onLookup).then(void 0, () => findSystemGitWin32(process.env["ProgramFiles(x86)"], onLookup)).then(void 0, () => findSystemGitWin32(process.env["ProgramFiles"], onLookup)).then(void 0, () => findSystemGitWin32(import_path2.default.join(process.env["LocalAppData"], "Programs"), onLookup)).then(void 0, () => findGitWin32InPath(onLookup));
+}
+function findSpecificGit(path8, onLookup) {
+  return new Promise((c, e) => {
+    onLookup(path8);
+    const buffers = [];
+    const child = (0, import_child_process.spawn)(path8, ["--version"]);
+    child.stdout.on("data", (b) => buffers.push(b));
+    child.on("error", cpErrorHandler(e));
+    child.on("exit", (code) => code ? e(new Error("Not found")) : c({ path: path8, version: parseVersion(Buffer.concat(buffers).toString("utf8").trim()) }));
+  });
+}
+function cpErrorHandler(cb) {
+  return (err) => {
+    if (/ENOENT/.test(err.message)) {
+      err = new Error("Failed to execute git (ENOENT)");
     }
-    const { args } = context;
-    let arg = args.length ? args.join(" ") : "HEAD";
-    let output = await runCommand(`git ls-tree -r ${arg}`, { cwd: root });
-    output = output.replace(/\s+$/, "");
-    if (!output) return [];
-    let res = [];
-    for (let line of output.split(/\r?\n/)) {
-      let [head, filepath] = line.split("	", 2);
-      let sha = head.split(" ")[2];
-      res.push({
-        label: filepath,
-        data: {
-          branch: args[0] || "HEAD",
-          filepath,
-          root,
-          sha
+    cb(err);
+  };
+}
+function findGitDarwin(onLookup) {
+  return new Promise((c, e) => {
+    (0, import_child_process.exec)("which git", (err, gitPathBuffer) => {
+      if (err) {
+        return e("git not found");
+      }
+      const path8 = gitPathBuffer.toString().replace(/^\s+|\s+$/g, "");
+      if (path8 !== "/usr/bin/git") {
+        findSpecificGit(path8, onLookup).then(c, e);
+        return;
+      }
+      (0, import_child_process.exec)("xcode-select -p", (err2) => {
+        if (err2 && err2.code === 2) {
+          e("git not found");
+          return;
         }
+        findSpecificGit(path8, onLookup).then(c, e);
       });
+    });
+  });
+}
+function findGit(hint, onLookup) {
+  const first = hint ? findSpecificGit(hint, onLookup) : Promise.reject(null);
+  return first.then(void 0, () => {
+    switch (process.platform) {
+      case "darwin":
+        return findGitDarwin(onLookup);
+      case "win32":
+        return findGitWin32(onLookup);
+      default:
+        return findSpecificGit("git", onLookup);
     }
-    return res;
-  }
-};
+  }).then(null, () => Promise.reject(new Error("Git installation not found.")));
+}
+function onceEvent(event) {
+  return (listener, thisArgs = null, disposables) => {
+    const result = event((e) => {
+      result.dispose();
+      return listener.call(thisArgs, e);
+    }, null, disposables);
+    return result;
+  };
+}
 
 // src/lists/gstatus.ts
-var import_coc6 = require("coc.nvim");
-var import_safe2 = __toESM(require_safe());
-var import_fs = __toESM(require("fs"));
-var import_path3 = __toESM(require("path"));
 var STATUS_MAP = {
   " ": " ",
   M: import_safe2.default.cyan("~"),
@@ -5418,9 +5401,24 @@ var STATUS_MAP = {
   D: import_safe2.default.red("-"),
   R: import_safe2.default.magenta("\u2192"),
   C: import_safe2.default.yellow("C"),
+  T: import_safe2.default.yellow("T"),
   U: import_safe2.default.blue("U"),
-  "?": import_safe2.default.gray("?")
+  "?": import_safe2.default.gray("?"),
+  "!": import_safe2.default.gray("!")
 };
+function parseStatusEntries(output) {
+  let result = [];
+  let entries = output.split("\0");
+  for (let i = 0; i < entries.length; i++) {
+    let line = entries[i];
+    if (!line) continue;
+    result.push({ index: line[0], tree: line[1], relative: line.slice(3) });
+    if (line[0] === "R" || line[0] === "C" || line[1] === "R" || line[1] === "C") {
+      i++;
+    }
+  }
+  return result;
+}
 var GStatus = class extends import_coc6.BasicList {
   constructor(nvim, manager) {
     super();
@@ -5432,12 +5430,12 @@ var GStatus = class extends import_coc6.BasicList {
     this.addMultipleAction("add", async (items) => {
       let { root } = items[0].data;
       let fileArgs = items.map((o) => o.data.relative);
-      await spawnCommand("git", ["add", ...fileArgs], root);
+      await this.manager.git.exec(root, ["add", "--", ...fileArgs]);
     }, { reload: true, persist: true });
     this.addMultipleAction("patch", async (items) => {
       let { root } = items[0].data;
-      let fileArgs = items.map((o) => o.data.relative.replace(/\s/, "\\ "));
-      let cmd = `git add ${fileArgs.join(" ")} --patch`;
+      let fileArgs = items.map((o) => o.data.relative);
+      let cmd = await this.manager.getTerminalGitCommand(["add", "--patch", "--", ...fileArgs]);
       await nvim.call("coc#util#open_terminal", [{
         cmd,
         cwd: root
@@ -5445,10 +5443,11 @@ var GStatus = class extends import_coc6.BasicList {
     });
     this.addMultipleAction("commit", async (items) => {
       let { root } = items[0].data;
-      await nvim.command(`exe "lcd ".fnameescape('${root}')`);
-      let filesArg = await nvim.eval(`join(map([${items.map((s) => "'" + s.data.relative + "'").join(",")}],'fnameescape(v:val)'),' ')`);
+      let escapedRoot = await nvim.call("fnameescape", [root]);
+      await nvim.command(`lcd ${escapedRoot}`);
+      let escapedFiles = await Promise.all(items.map((item) => nvim.call("fnameescape", [item.data.relative])));
       try {
-        await nvim.command(`G commit -v ${filesArg}`);
+        await nvim.command(`G commit -v -- ${escapedFiles.join(" ")}`);
       } catch (e) {
         import_coc6.window.showErrorMessage(`G commit command failed, make sure fugitive installed.`);
       }
@@ -5474,13 +5473,12 @@ var GStatus = class extends import_coc6.BasicList {
         let hasRmtrash = await nvim.call("executable", ["rmtrash"]);
         let fullpath = import_path3.default.join(root, relative);
         if (hasRmtrash) {
-          await runCommand(`rmtrash ${fullpath.replace(/\s/, "\\ ")}`);
+          await spawnCommand("rmtrash", [fullpath], root);
         } else {
-          import_fs.default.unlinkSync(fullpath);
+          await import_fs.default.promises.unlink(fullpath);
         }
       }
-      this.nvim.command("checktime", true);
-      await wait(100);
+      await this.nvim.command("checktime");
     }, { reload: true, persist: true });
     this.addAction("preview", async (item, context) => {
       let { tree_symbol, index_symbol, root, relative } = item.data;
@@ -5498,8 +5496,7 @@ var GStatus = class extends import_coc6.BasicList {
       if (index_symbol == "M" && tree_symbol != "M") {
         args.push("--cached");
       }
-      let cmd = `git ${args.join(" ")} ${relative}`;
-      let content = await runCommand(cmd, { cwd: root });
+      let content = (await this.manager.git.exec(root, [...args, "--", relative])).stdout;
       let lines = content.trim().split("\n");
       await this.preview({
         lines,
@@ -5510,10 +5507,10 @@ var GStatus = class extends import_coc6.BasicList {
     });
   }
   async reset(root, relative) {
-    await spawnCommand("git", ["reset", "HEAD", "--", relative], root);
+    await this.manager.git.exec(root, ["reset", "--", relative]);
   }
   async checkout(root, relative) {
-    await spawnCommand("git", ["checkout", "--", relative], root);
+    await this.manager.git.exec(root, ["checkout", "--", relative]);
   }
   async loadItems(context) {
     let buf = await context.window.buffer;
@@ -5525,24 +5522,24 @@ var GStatus = class extends import_coc6.BasicList {
     if (this.manager.gstatusSaveBeforeOpen) {
       await this.nvim.command(`wa`);
     }
-    let output = await runCommand(`git status --porcelain -uall ${context.args.join(" ")}`, { cwd: root });
-    output = output.replace(/\s+$/, "");
+    let output = (await this.manager.git.exec(root, ["status", "--porcelain=v1", "-z", "-uall", ...context.args])).stdout;
     if (!output) return [];
     let res = [];
-    for (let line of output.split(/\r?\n/)) {
-      let filepath = import_path3.default.join(root, line.slice(3));
-      let index_symbol = STATUS_MAP[line[0]];
-      let tree_symbol = STATUS_MAP[line[1]];
+    for (let entry of parseStatusEntries(output)) {
+      let { index, tree, relative } = entry;
+      let filepath = import_path3.default.join(root, relative);
+      let index_symbol = STATUS_MAP[index];
+      let tree_symbol = STATUS_MAP[tree];
       res.push({
-        label: `${index_symbol}${tree_symbol} ${line.slice(3)}`,
-        filterText: line.slice(3),
+        label: `${index_symbol}${tree_symbol} ${relative}`,
+        filterText: relative,
         data: {
           root,
-          relative: line.slice(3),
-          index_symbol: line[0],
-          tree_symbol: line[1],
-          staged: line[0] != " " && line[0] != "?",
-          tree: line[1] != " " && line[1] != "?"
+          relative,
+          index_symbol: index,
+          tree_symbol: tree,
+          staged: index != " " && index != "?",
+          tree: tree != " " && tree != "?"
         },
         location: import_coc6.Uri.file(filepath).toString()
       });
@@ -5556,7 +5553,7 @@ var import_coc7 = require("coc.nvim");
 var import_safe3 = __toESM(require_safe());
 var GChunks = class extends import_coc7.BasicList {
   constructor(nvim, manager) {
-    super(nvim);
+    super();
     this.manager = manager;
     this.name = "gchunks";
     this.description = "Git changes of current buffer";
@@ -5570,6 +5567,7 @@ var GChunks = class extends import_coc7.BasicList {
     });
   }
   async loadItems(context) {
+    var _a;
     let buf = this.manager.getBuffer(context.buffer.id);
     if (!buf) {
       throw new Error(`Can't resolve git root.`);
@@ -5592,7 +5590,7 @@ var GChunks = class extends import_coc7.BasicList {
     try {
       let { relpath } = buf;
       let stagedDiff = await buf.repo.getStagedChunks(relpath);
-      let chunks = Object.values(stagedDiff)[0];
+      let chunks = (_a = Object.values(stagedDiff)[0]) != null ? _a : [];
       if (chunks.length > 0) {
         for (let diff of chunks) {
           let adjust = 0;
@@ -5609,7 +5607,7 @@ var GChunks = class extends import_coc7.BasicList {
           res.push({
             label: `${stagedSign} Line:${line} ${diff.lines[0]}`,
             data: {
-              line: `${line}`
+              line
             }
           });
         }
@@ -5682,6 +5680,21 @@ var GitStatus = class {
     this.disposables = [];
     this._enabled = false;
     this.mutex = new import_coc9.Mutex();
+    this.disposed = false;
+    this.loadConfiguration();
+    import_coc9.workspace.onDidChangeConfiguration((e) => {
+      if (!e.affectsConfiguration("git")) return;
+      this.loadConfiguration();
+      if (!this._enabled) this.setGitStatus("");
+      this.scheduleRefresh(0);
+    }, null, this.disposables);
+    import_coc9.events.on("BufEnter", this.refresh, this, this.disposables);
+    import_coc9.events.on("FocusGained", this.refresh, this, this.disposables);
+    import_coc9.events.on("BufWritePost", () => this.scheduleRefresh(50), this, this.disposables);
+    this.disposables.push({ dispose: () => this.clearTimer() });
+    this.scheduleRefresh(300);
+  }
+  loadConfiguration() {
     let config = import_coc9.workspace.getConfiguration("git");
     this._enabled = config.get("enableGlobalStatus", true);
     this.branchCharacter = config.get("branchCharacter", "");
@@ -5691,41 +5704,40 @@ var GitStatus = class {
       stagedDecorator: config.get("stagedDecorator"),
       untrackedDecorator: config.get("untrackedDecorator")
     };
-    import_coc9.events.on("BufEnter", this.refresh, this, this.disposables);
-    import_coc9.events.on("FocusGained", this.refresh, this, this.disposables);
-    let timer;
-    import_coc9.events.on("BufWritePost", () => {
-      timer = setTimeout(() => {
-        this.refresh();
-      }, 50);
-    }, this, this.disposables);
-    this.disposables.push({
-      dispose: () => {
-        if (timer) clearTimeout(timer);
-      }
-    });
-    setTimeout(() => {
-      this.refresh().catch((_e) => {
-      });
-    }, 300);
+  }
+  clearTimer() {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = void 0;
+  }
+  scheduleRefresh(delay) {
+    this.clearTimer();
+    this.timer = setTimeout(() => {
+      this.timer = void 0;
+      this.refresh().catch((e) => this.service.log(`[Error] error on refresh: ${e.message}`));
+    }, delay);
   }
   async refresh() {
-    if (!this._enabled) return;
+    if (!this._enabled || this.disposed) return;
     let release = await this.mutex.acquire();
     try {
+      if (this.disposed) return;
       let repo = await this.service.getCurrentRepo();
+      if (this.disposed) return;
       if (repo) {
         let status = await repo.getStatus(this.branchCharacter, this.characters);
+        if (!this._enabled || this.disposed) return;
         this.setGitStatus(status || "");
       } else {
         this.setGitStatus("");
       }
     } catch (e) {
       this.service.log(`[Error] error on refresh: ${e.message}`);
+    } finally {
+      release();
     }
-    release();
   }
   setGitStatus(status) {
+    if (this.disposed) return;
     if (this.gitStatus == status) return;
     this.gitStatus = status;
     let { nvim } = import_coc9.workspace;
@@ -5736,6 +5748,8 @@ var GitStatus = class {
   }
   dispose() {
     (0, import_coc9.disposeAll)(this.disposables);
+    this.setGitStatus("");
+    this.disposed = true;
   }
 };
 
@@ -5752,21 +5766,32 @@ var DocumentManager = class {
     this.loadConfiguration();
     import_coc10.workspace.onDidChangeConfiguration(this.loadConfiguration, this, this.disposables);
     this.gitStatus = new GitStatus(service);
-    import_coc10.workspace.registerBufferSync((doc) => {
+    this.disposables.push(import_coc10.workspace.registerBufferSync((doc) => {
       let disposed = false;
       let gitBuffer;
       let { bufnr, uri } = doc;
       service.createBuffer(doc, this.config).then((buf) => {
-        if (!buf || disposed) return;
+        if (!buf) return;
+        if (disposed) {
+          buf.dispose();
+          return;
+        }
         gitBuffer = buf;
         this.defineSigns().catch((e) => {
           console.error(e.message);
         });
         this.buffers.set(doc.bufnr, buf);
+      }).catch((e) => {
+        service.log(`[Error] unable to create git buffer for ${uri}: ${e.message}`);
       });
       return {
-        onChange: () => {
-          if (gitBuffer) gitBuffer._refresh();
+        onChange: (e) => {
+          if (gitBuffer) {
+            if (e.contentChanges.some((change) => change.text.includes("<<<<<<<"))) {
+              gitBuffer.markConflictCheck();
+            }
+            gitBuffer._refresh().catch((e2) => service.log(`[Error] refresh error: ${e2.message}`));
+          }
         },
         dispose: () => {
           disposed = true;
@@ -5775,28 +5800,44 @@ var DocumentManager = class {
           if (gitBuffer) gitBuffer.dispose();
         }
       };
-    });
-    import_coc10.events.on("CursorMoved", (0, import_debounce.default)(async (bufnr, cursor) => {
+    }));
+    const cursorMoved = (0, import_debounce.default)(async (bufnr, cursor) => {
       let buf = this.buffers.get(bufnr);
-      if (buf) await buf.showBlameInfo(cursor[0]);
-    }, 100), null, this.disposables);
-    import_coc10.workspace.registerAutocmd({
+      if (buf) {
+        try {
+          await buf.showBlameInfo(cursor[0]);
+        } catch (e) {
+          service.log(`[Error] unable to show blame: ${e.message}`);
+        }
+      }
+    }, 100);
+    import_coc10.events.on("CursorMoved", cursorMoved, null, this.disposables);
+    this.disposables.push({ dispose: () => cursorMoved.clear() });
+    this.disposables.push(import_coc10.workspace.registerAutocmd({
       event: "BufWritePost",
       arglist: ["+expand('<abuf>')"],
       callback: (bufnr) => {
         if (!this.enableGutters || this.config.realtimeGutters) return;
         let buf = this.buffers.get(bufnr);
-        if (buf) buf.diffDocument(true);
+        if (buf) {
+          buf.diffDocument(true).catch((e) => service.log(`[Error] refresh error: ${e.message}`));
+        }
       }
-    });
+    }));
     import_coc10.events.on("FocusGained", async () => {
       let bufnr = await nvim.call("bufnr", ["%"]);
       let buf = this.buffers.get(bufnr);
-      if (buf) buf.refresh();
+      if (buf) {
+        buf.markConflictCheck();
+        buf.refresh();
+      }
     }, null, this.disposables);
     import_coc10.events.on("BufEnter", (bufnr) => {
       let buf = this.buffers.get(bufnr);
-      if (buf) buf.refresh();
+      if (buf) {
+        buf.markConflictCheck();
+        buf.refresh();
+      }
     }, null, this.disposables);
   }
   async defineSigns() {
@@ -5816,6 +5857,7 @@ var DocumentManager = class {
     await nvim.resumeNotification();
   }
   loadConfiguration(e) {
+    var _a;
     if (e && !e.affectsConfiguration("git")) return;
     let config = import_coc10.workspace.getConfiguration("git");
     let obj = {
@@ -5825,6 +5867,7 @@ var DocumentManager = class {
       diffOptions: config.get("diffOptions", []),
       issueFormat: config.get("issueFormat", "#%i"),
       virtualTextPrefix: config.get("virtualTextPrefix", "     "),
+      blameFormat: config.get("blameFormat", "(%a %t) %s"),
       addGBlameToVirtualText: config.get("addGBlameToVirtualText", false),
       addGBlameToBufferVar: config.get("addGBlameToBufferVar", false),
       blameUseRealTime: config.get("blameUseRealTime", false),
@@ -5832,7 +5875,7 @@ var DocumentManager = class {
       realtimeGutters: config.get("realtimeGutters", true),
       showCommitInFloating: config.get("showCommitInFloating", false),
       signPriority: config.get("signPriority", 10),
-      pushArguments: config.get("pushArguments", []),
+      pushArguments: (_a = config.get("pushArguments")) != null ? _a : [],
       splitWindowCommand: config.get("splitWindowCommand", "above sp"),
       changedSign: {
         text: config.get("changedSign.text", "~"),
@@ -5868,6 +5911,11 @@ var DocumentManager = class {
       conflictSrcId: this.conflictSrcId
     };
     this.config = Object.assign(this.config || {}, obj);
+    if (e) {
+      this.defined = false;
+      for (let buffer of this.buffers.values()) buffer.markConflictCheck();
+      this.defineSigns().catch((err) => this.service.log(`[Error] define signs: ${err.message}`));
+    }
   }
   get enableGutters() {
     return this.config.enableGutters;
@@ -5881,10 +5929,15 @@ var DocumentManager = class {
   get diffOptions() {
     return this.config.diffOptions;
   }
+  async getTerminalGitCommand(args) {
+    const values = [this.git.path, ...args];
+    const escaped = await Promise.all(values.map((value) => this.nvim.call("shellescape", [value, 1])));
+    return escaped.join(" ");
+  }
   async toggleGutters() {
     let enabled = this.enableGutters;
     let config = import_coc10.workspace.getConfiguration("git");
-    config.update("enableGutters", !enabled, true);
+    await config.update("enableGutters", !enabled, true);
     for (let buf of this.buffers.values()) {
       await buf.toggleGutters(!enabled);
     }
@@ -5916,6 +5969,11 @@ var DocumentManager = class {
     let buf = await this.buffer;
     if (buf) await buf.chunkInfo();
   }
+  async allChunkInfo() {
+    let buf = await this.buffer;
+    if (buf) return buf.allChunkInfo();
+    return [];
+  }
   async nextChunk() {
     let buf = await this.buffer;
     if (buf) await buf.nextChunk();
@@ -5992,7 +6050,7 @@ var DocumentManager = class {
       return;
     }
     if (args && args.length) {
-      await import_coc10.window.runTerminalCommand(`git push ${[...args, ...extra].join(" ")}`, root, true);
+      await import_coc10.window.runTerminalCommand(await this.getTerminalGitCommand(["push", ...args, ...extra]), root, true);
       return;
     }
     let repo = this.service.getRepoFromRoot(root);
@@ -6007,12 +6065,12 @@ var DocumentManager = class {
       import_coc10.window.showWarningMessage(`current branch not found`);
       return;
     }
-    await import_coc10.window.runTerminalCommand(`git push ${remote} ${output}${extra.length ? " " + extra.join(" ") : ""}`, root, true);
+    await import_coc10.window.runTerminalCommand(await this.getTerminalGitCommand(["push", remote, output, ...extra]), root, true);
   }
   get buffer() {
     return import_coc10.workspace.nvim.call("bufnr", "%").then((bufnr) => {
       let buf = this.buffers.get(bufnr);
-      if (!buf) import_coc10.window.showWarningMessage(`Cant't resolve git repository for current buffer.`);
+      if (!buf) import_coc10.window.showWarningMessage(`Can't resolve git repository for current buffer.`);
       return buf;
     });
   }
@@ -6030,13 +6088,13 @@ var DocumentManager = class {
     return repo.getDiffAll(category);
   }
   dispose() {
+    (0, import_coc10.disposeAll)(this.disposables);
     this.gitStatus.dispose();
-    this.service.dispose();
     for (let buf of this.buffers.values()) {
       buf.dispose();
     }
     this.buffers.clear();
-    (0, import_coc10.disposeAll)(this.disposables);
+    this.service.dispose();
   }
 };
 
@@ -6130,6 +6188,13 @@ var startPattern = new RegExp(`^<{7} (${revPattern})(:? .+)?$`);
 var sepPattern = new RegExp(`^={7}$`);
 var endPattern = new RegExp(`^>{7} (${revPattern})(:? .+)?$`);
 var commonPattern = /^\|{7}\smerged\scommon\sancestors/;
+function getPreviousConflict(conflicts, line) {
+  return conflicts.slice().reverse().find((conflict) => conflict.start < line);
+}
+function chunkContainsLine(chunk, line) {
+  const end = chunk.add.count === 0 ? chunk.add.lnum : chunk.add.lnum + chunk.add.count - 1;
+  return chunk.add.lnum <= line && end >= line;
+}
 var GitBuffer = class {
   constructor(doc, config, relpath, repo, git, channel, floatFactory, hasConflicts) {
     this.doc = doc;
@@ -6148,29 +6213,37 @@ var GitBuffer = class {
     this.foldEnabled = false;
     this._disposed = false;
     this.mutex = new import_coc11.Mutex();
+    this.conflictCheckNeeded = hasConflicts;
     this.refresh = (0, import_debounce2.default)(() => {
       this._refresh().catch((e) => {
         channel.append(`[Error] ${e.message}`);
       });
     }, 200);
-    this._refresh();
+    this._refresh().catch((e) => channel.append(`[Error] ${e.message}`));
   }
   get cachedDiffs() {
     return this.diffs;
   }
+  markConflictCheck() {
+    this.conflictCheckNeeded = true;
+  }
   async _refresh() {
     if (this._disposed) return;
     this.refresh.clear();
     let release = await this.mutex.acquire();
-    let result = await Promise.allSettled([
-      this.diffDocument(),
-      this.loadBlames(),
-      this.parseConflicts()
-    ]);
-    result.forEach((res) => {
-      if (res.status === "rejected") this.channel.append(`[Error] refresh error ${res.reason}`);
-    });
-    release();
+    try {
+      if (this._disposed) return;
+      let result = await Promise.all([
+        this.diffDocument(),
+        this.loadBlames(),
+        this.parseConflicts()
+      ].map((promise) => promise.then(() => void 0, (error) => error)));
+      result.forEach((error) => {
+        if (error) this.channel.append(`[Error] refresh error ${error}`);
+      });
+    } finally {
+      release();
+    }
   }
   getChunk(line) {
     if (!this.diffs || this.diffs.length == 0) return void 0;
@@ -6220,11 +6293,13 @@ var GitBuffer = class {
     } else if (diff.changeType === "changed" /* Change */) {
       head = `@@ -${diff.removed.start},${diff.removed.count} +${diff.removed.start},${diff.added.count} @@`;
     }
+    const from = quoteGitPath(`a/${relpath}`);
+    const to = quoteGitPath(`b/${relpath}`);
     const lines = [
-      `diff --git a/${relpath} b/${relpath}`,
+      `diff --git ${from} ${to}`,
       `index 000000..000000 100644`,
-      `--- a/${relpath}`,
-      `+++ b/${relpath}`,
+      `--- ${from}`,
+      `+++ ${to}`,
       head
     ];
     lines.push(...diff.lines);
@@ -6237,6 +6312,7 @@ var GitBuffer = class {
     }
   }
   async chunkUnstage() {
+    var _a;
     let { nvim } = import_coc11.workspace;
     const { diffs } = this;
     let line = await nvim.call("line", ".");
@@ -6256,12 +6332,12 @@ var GitBuffer = class {
     if (invalid) return;
     line = line + adjust;
     let stagedDiff = await this.repo.getStagedChunks(this.relpath);
-    let chunks = Object.values(stagedDiff)[0];
+    let chunks = (_a = Object.values(stagedDiff)[0]) != null ? _a : [];
     if (!chunks.length) {
       import_coc11.window.showErrorMessage(`Staged chunk not found`);
       return;
     }
-    let chunk = chunks.find((o) => o.add.lnum <= line && o.add.lnum + o.add.count >= line);
+    let chunk = chunks.find((o) => chunkContainsLine(o, line));
     if (!chunk) {
       import_coc11.window.showErrorMessage(`Unable to find staged chunk on current line`);
       return;
@@ -6329,7 +6405,7 @@ var GitBuffer = class {
         adjust += diff2.removed.count;
       }
       line = line + adjust;
-      let chunk = chunks.find((o) => o.add.lnum <= line && o.add.lnum + o.add.count >= line);
+      let chunk = chunks.find((o) => chunkContainsLine(o, line));
       if (chunk) {
         let content = "Staged changes\n" + chunk.lines.join("\n");
         await this.showDoc(content, "diff");
@@ -6338,7 +6414,11 @@ var GitBuffer = class {
       }
     }
   }
+  allChunkInfo() {
+    return this.diffs ? this.diffs.slice() : [];
+  }
   async showBlameInfo(lnum) {
+    if (this._disposed) return;
     let { nvim } = import_coc11.workspace;
     let { virtualTextSrcId, addGBlameToBufferVar, addGBlameToVirtualText } = this.config;
     if (!this.showBlame) return;
@@ -6350,7 +6430,7 @@ var GitBuffer = class {
     } else {
       let info = infos.find((o) => lnum >= o.startLnum && lnum <= o.endLnum);
       if (info && info.author && info.author != "Not Committed Yet") {
-        blameText = `(${info.author} ${info.time}) ${info.summary}`;
+        blameText = formatBlameText(info, this.config.blameFormat);
       } else {
         blameText = "Not committed yet";
       }
@@ -6403,7 +6483,7 @@ var GitBuffer = class {
     let eol = this.doc.textDocument["eol"];
     let encoding = await this.doc.buffer.getOption("fileencoding");
     const diffs = await this.repo.getDiff(this.relpath, eol ? content : content + "\n", revision, encoding || "utf8");
-    if (diffs == null) return;
+    if (diffs == null || this._disposed) return;
     if (diffs.length === 0) {
       this.currentSigns = [];
       this.diffs = [];
@@ -6485,6 +6565,7 @@ var GitBuffer = class {
     let result = [];
     let indexed = await this.repo.isIndexed(this.relpath);
     if (indexed) result = await this.getBlameInfo();
+    if (this._disposed) return;
     this.blameInfo = result;
   }
   async getBlameInfo(range) {
@@ -6494,14 +6575,16 @@ var GitBuffer = class {
     const useRealTime = this.config.blameUseRealTime;
     try {
       let currentAuthor = await this.repo.getUsername();
-      const args = ["--no-pager", "blame", "-w", "-b", "-p", "--incremental", "--root", "--date", "relative", "--contents", "-", relpath];
+      const args = ["--no-pager", "blame", "-w", "-b", "-p", "--incremental", "--root", "--date", "relative", "--contents", "-"];
       if (range) args.push("-L", range.join(","));
+      args.push("--", relpath);
       let r = await this.git.exec(root, args, {
         log: false,
         input: this.doc.content
       });
       if (!r.stdout) return res;
       let info;
+      const commits = /* @__PURE__ */ new Map();
       for (let line of r.stdout.trim().split(/\r?\n/)) {
         line = line.trim();
         if (/^(author |committer )?External file \(--contents\)/.test(line)) {
@@ -6512,11 +6595,13 @@ var GitBuffer = class {
           let startLnum = parseInt(ms[3], 10);
           info = { startLnum, sha: ms[1], endLnum: startLnum + parseInt(ms[4], 10) - 1, index: ms[2] };
           if (!/^0+$/.test(ms[1])) {
-            let find = res.find((o) => o.sha == ms[1]);
+            let find = commits.get(ms[1]);
             if (find) {
               info.author = find.author;
               info.time = find.time;
               info.summary = find.summary;
+            } else {
+              commits.set(ms[1], info);
             }
           }
           res.push(info);
@@ -6580,14 +6665,14 @@ var GitBuffer = class {
       return;
     }
     let line = await nvim.call("line", ".");
-    for (let conflict of this.conflicts) {
-      if (conflict.start > line) {
-        await import_coc11.window.moveTo({ line: Math.max(conflict.start - 1, 0), character: 0 });
-        return;
-      }
+    let conflict = getPreviousConflict(this.conflicts, line);
+    if (conflict) {
+      await import_coc11.window.moveTo({ line: Math.max(conflict.start - 1, 0), character: 0 });
+      return;
     }
     if (await nvim.getOption("wrapscan")) {
-      await import_coc11.window.moveTo({ line: Math.max(this.conflicts[0].start - 1, 0), character: 0 });
+      conflict = this.conflicts[this.conflicts.length - 1];
+      await import_coc11.window.moveTo({ line: Math.max(conflict.start - 1, 0), character: 0 });
     }
   }
   async conflictKeepPart(part) {
@@ -6660,21 +6745,26 @@ var GitBuffer = class {
       if (!uri.length) continue;
       let repoURL = getRepoUrl(uri);
       if (!repoURL) continue;
-      let tmp = new import_url.URL(repoURL);
+      let tmp;
+      try {
+        tmp = new import_url.URL(repoURL);
+      } catch (_e) {
+        continue;
+      }
       let hostname = tmp.hostname;
       let fix = "|";
       try {
         fix = config.get("urlFix")[hostname][permalink ? 1 : 0];
       } catch (e) {
       }
-      let url = getUrl(fix, repoURL, permalink ? head : branch, this.relpath.replace(/\\\\/g, "/"), lines);
+      let url = getUrl(fix, repoURL, permalink ? head : branch || head, toUnixSlash(this.relpath), lines);
       if (url) urls.push(url);
     }
     if (urls.length == 1) {
       if (action == "open") {
         await import_coc11.workspace.openResource(urls[0]);
       } else {
-        nvim.command(`let @+ = '${urls[0]}'`, true);
+        nvim.call("setreg", ["+", urls[0]], true);
         import_coc11.window.showInformationMessage("Copied url to clipboard");
       }
     } else if (urls.length > 1) {
@@ -6683,8 +6773,8 @@ var GitBuffer = class {
         if (action == "open") {
           await import_coc11.workspace.openResource(url);
         } else {
-          nvim.command(`let @+ = '${url}'`, true);
-          nvim.command(`let @* = '${url}'`, true);
+          nvim.call("setreg", ["+", url], true);
+          nvim.call("setreg", ["*", url], true);
           import_coc11.window.showInformationMessage("Copied url to clipboard");
         }
       }
@@ -6699,7 +6789,7 @@ var GitBuffer = class {
     }
     let nvim = import_coc11.workspace.nvim;
     let line = await nvim.eval('line(".")');
-    let args = ["--no-pager", "blame", "-w", "-l", "--root", "-t", `-L${line},${line}`, this.relpath];
+    let args = ["--no-pager", "blame", "-w", "-l", "--root", "-t", `-L${line},${line}`, "--", this.relpath];
     let res = await this.repo.exec(args);
     let output = res.stdout.trim();
     if (!output.length) return;
@@ -6745,7 +6835,7 @@ var GitBuffer = class {
       import_coc11.window.showWarningMessage("No changes");
       return;
     }
-    let lnums = infos.map((o) => o.lnum);
+    let changedLines = new Set(infos.map((o) => o.lnum));
     let foldContext = this.config.foldContext;
     let max = this.doc.lineCount;
     let ranges = [];
@@ -6757,7 +6847,7 @@ var GitBuffer = class {
       ranges.push([s, e]);
     };
     for (let i = 1; i <= doc.lineCount; i++) {
-      let fold = lnums.indexOf(i) == -1;
+      let fold = !changedLines.has(i);
       if (fold && start == null) {
         start = i;
         continue;
@@ -6774,10 +6864,10 @@ var GitBuffer = class {
     if (enabled) {
       this.foldEnabled = false;
       let cursor = await nvim.eval('getpos(".")');
-      let lnums2 = ranges.map((o) => o[0]);
+      let lnums = ranges.map((o) => o[0]);
       let settings = this.foldSettings;
       nvim.pauseNotification();
-      for (let lnum of lnums2) {
+      for (let lnum of lnums) {
         nvim.command(`${lnum}normal! zd`, true);
       }
       win.setOption("foldmethod", settings.foldmethod, true);
@@ -6818,7 +6908,22 @@ var GitBuffer = class {
     }
   }
   async parseConflicts() {
-    if (!this.hasConflicts || !this.config.conflict.enabled) return;
+    if (!this.config.conflict.enabled) {
+      if (this.conflicts.length) {
+        this.conflicts = [];
+        await this.highlightConflicts([]);
+      }
+      return;
+    }
+    if (!this.hasConflicts && !this.conflictCheckNeeded) return;
+    this.conflictCheckNeeded = false;
+    this.hasConflicts = await this.repo.hasConflicts(this.relpath);
+    if (this._disposed) return;
+    if (!this.hasConflicts) {
+      this.conflicts = [];
+      await this.highlightConflicts([]);
+      return;
+    }
     const lines = this.doc.textDocument.lines;
     let conflicts = [];
     let conflict = null;
@@ -6884,12 +6989,13 @@ var GitBuffer = class {
       }
     });
     this.conflicts = conflicts;
-    this.highlightConflicts(conflicts);
+    await this.highlightConflicts(conflicts);
     if (conflicts.length == 0) {
       this.hasConflicts = false;
     }
   }
   async highlightConflicts(conflicts) {
+    if (this._disposed) return;
     let buffer = this.doc.buffer;
     let currentHlGroup = this.config.conflict.currentHlGroup;
     let incomingHlGroup = this.config.conflict.incomingHlGroup;
@@ -6917,7 +7023,7 @@ var GitBuffer = class {
       await this.floatFactory.show(docs, this.config.floatConfig);
     } else {
       const lines = content.split("\n");
-      import_coc11.workspace.nvim.call("coc#ui#preview_info", [lines, "diff"], true);
+      import_coc11.workspace.nvim.call("coc#ui#preview_info", [lines, filetype], true);
     }
   }
   setBufferStatus(status) {
@@ -6950,9 +7056,12 @@ var GitBuffer = class {
     return this.config.addGBlameToVirtualText || this.config.addGBlameToBufferVar;
   }
   dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
     let { nvim } = import_coc11.workspace;
     let { bufnr } = this.doc;
     let buffer = nvim.createBuffer(bufnr);
+    nvim.pauseNotification();
     buffer.setVar("coc_git_status", "", true);
     buffer.clearNamespace(this.config.conflictSrcId, 0, -1);
     nvim.call("sign_unplace", [signGroup, { buffer: bufnr }], true);
@@ -6964,12 +7073,7 @@ var GitBuffer = class {
       buffer.clearNamespace(this.config.virtualTextSrcId);
     }
     nvim.resumeNotification(false, true);
-    this._disposed = true;
     this.foldEnabled = false;
-    this.blameInfo = void 0;
-    this.diffs = void 0;
-    this.conflicts = void 0;
-    this.currentSigns = void 0;
   }
 };
 function plus(val, count, max) {
@@ -6993,6 +7097,9 @@ var Git = class {
     this.gitInfo = gitInfo;
     this.channel = channel;
   }
+  get path() {
+    return this.gitInfo.path;
+  }
   async getRepositoryRoot(repositoryPath) {
     const result = await this.exec(repositoryPath, ["rev-parse", "--show-toplevel"]);
     let repoRootPath = import_path5.default.normalize(result.stdout.trim());
@@ -7010,9 +7117,15 @@ var Git = class {
     return this.spawn(args, options);
   }
   async _exec(args, options = {}) {
+    var _a, _b, _c, _d;
+    if ((_a = options.cancellationToken) == null ? void 0 : _a.isCancellationRequested) {
+      throw new Error("Cancelled");
+    }
     const child = this.spawn(args, options);
-    if (options.input) {
-      child.stdin.end(options.input, "utf8");
+    if (options.input !== void 0) {
+      (_b = child.stdin) == null ? void 0 : _b.on("error", () => {
+      });
+      (_c = child.stdin) == null ? void 0 : _c.end(options.input, "utf8");
     }
     const bufferResult = await exec2(child, options.cancellationToken);
     if (options.log !== false && bufferResult.stderr.length > 0) {
@@ -7026,7 +7139,7 @@ var Git = class {
       stdout: import_iconv_lite.default.decode(bufferResult.stdout, encoding),
       stderr: bufferResult.stderr
     };
-    if (bufferResult.exitCode) {
+    if (bufferResult.exitCode && !((_d = options.allowedExitCodes) == null ? void 0 : _d.includes(bufferResult.exitCode))) {
       this.channel.appendLine(`Error ${result.exitCode} on: 'git ${args.join(" ")}' in ${options.cwd}`);
       this.channel.append(result.stderr);
       this.channel.append(result.stdout);
@@ -7035,29 +7148,25 @@ var Git = class {
     return result;
   }
   spawn(args, options = {}) {
-    if (!options) {
-      options = {};
+    const { input, encoding: _encoding, log: _log, cancellationToken: _cancellationToken, allowedExitCodes: _allowedExitCodes, ...spawnOptions } = options;
+    if (!spawnOptions.stdio && input === void 0) {
+      spawnOptions.stdio = ["ignore", null, null];
     }
-    if (!options.stdio && !options.input) {
-      options.stdio = ["ignore", null, null];
-    }
-    options.env = Object.assign({}, process.env, options.env || {}, {
+    spawnOptions.env = Object.assign({}, process.env, spawnOptions.env || {}, {
       LC_ALL: "en_US.UTF-8",
       LANG: "en_US.UTF-8"
     });
-    if (process.platform === "win32") {
-      options.shell = true;
-    }
     if (options.log !== false) {
       this.log(`> git ${args.join(" ")}
 `);
     }
-    return cp.spawn(this.gitInfo.path, args, options);
+    return cp.spawn(this.gitInfo.path, args, spawnOptions);
   }
   log(output) {
     this.channel.append(output);
   }
 };
+var git_default = Git;
 async function exec2(child, cancellationToken) {
   if (!child.stdout || !child.stderr) {
     throw new Error("Failed to get stdout or stderr from git process.");
@@ -7077,7 +7186,7 @@ async function exec2(child, cancellationToken) {
   let result = Promise.all([
     new Promise((c, e) => {
       once(child, "error", cpErrorHandler(e));
-      once(child, "exit", c);
+      once(child, "exit", (code) => c(code != null ? code : -1));
     }),
     new Promise((c) => {
       const buffers = [];
@@ -7092,13 +7201,14 @@ async function exec2(child, cancellationToken) {
   ]);
   if (cancellationToken) {
     const cancellationPromise = new Promise((_, e) => {
-      onceEvent(cancellationToken.onCancellationRequested)(() => {
+      const disposable = onceEvent(cancellationToken.onCancellationRequested)(() => {
         try {
           child.kill();
         } catch (err) {
         }
         e(new Error("Cancelled"));
       });
+      disposables.push(disposable);
     });
     result = Promise.race([result, cancellationPromise]);
   }
@@ -7114,44 +7224,57 @@ async function exec2(child, cancellationToken) {
 var import_fs2 = __toESM(require("fs"));
 var import_os = __toESM(require("os"));
 var import_path6 = __toESM(require("path"));
-var import_util8 = __toESM(require("util"));
-
-// node_modules/uuid/dist/esm-node/rng.js
-var import_crypto = __toESM(require("crypto"));
-function rng() {
-  return import_crypto.default.randomBytes(16);
-}
+var import_util5 = __toESM(require("util"));
 
-// node_modules/uuid/dist/esm-node/bytesToUuid.js
+// node_modules/uuid/dist/esm/stringify.js
 var byteToHex = [];
-for (i = 0; i < 256; ++i) {
-  byteToHex[i] = (i + 256).toString(16).substr(1);
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
 }
-var i;
-function bytesToUuid(buf, offset) {
-  var i = offset || 0;
-  var bth = byteToHex;
-  return [bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], "-", bth[buf[i++]], bth[buf[i++]], "-", bth[buf[i++]], bth[buf[i++]], "-", bth[buf[i++]], bth[buf[i++]], "-", bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], bth[buf[i++]]].join("");
+
+// node_modules/uuid/dist/esm/rng.js
+var import_crypto = require("crypto");
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    (0, import_crypto.randomFillSync)(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
 }
-var bytesToUuid_default = bytesToUuid;
 
-// node_modules/uuid/dist/esm-node/v4.js
+// node_modules/uuid/dist/esm/native.js
+var import_crypto2 = require("crypto");
+var native_default = { randomUUID: import_crypto2.randomUUID };
+
+// node_modules/uuid/dist/esm/v4.js
 function v4(options, buf, offset) {
-  var i = buf && offset || 0;
-  if (typeof options == "string") {
-    buf = options === "binary" ? new Array(16) : null;
-    options = null;
+  var _a, _b, _c;
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
   }
   options = options || {};
-  var rnds = options.random || (options.rng || rng)();
+  const rnds = (_c = (_b = options.random) != null ? _b : (_a = options.rng) == null ? void 0 : _a.call(options)) != null ? _c : rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
   rnds[6] = rnds[6] & 15 | 64;
   rnds[8] = rnds[8] & 63 | 128;
   if (buf) {
-    for (var ii = 0; ii < 16; ++ii) {
-      buf[i + ii] = rnds[ii];
+    offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
     }
+    return buf;
   }
-  return buf || bytesToUuid_default(rnds);
+  return unsafeStringify(rnds);
 }
 var v4_default = v4;
 
@@ -7166,11 +7289,11 @@ var Repo = class {
    * Get staged info
    */
   async getStagedChunks(relpath) {
-    let args = ["--no-pager", "diff", "--no-ext-diff", "-p", "-U0", "--no-color", "--staged"];
-    if (relpath) args.push(toUnixSlash(relpath));
+    let args = ["-c", "core.quotepath=false", "--no-pager", "diff", "--no-ext-diff", "--no-renames", "-p", "-U0", "--no-color", "--staged"];
+    if (relpath) args.push("--", toUnixSlash(relpath));
     const result = await this.exec(args);
     if (!result.stdout) {
-      throw new Error(`No staged result.`);
+      return {};
     }
     let res = {};
     let idx = 0;
@@ -7194,9 +7317,9 @@ var Repo = class {
       } else if (curr && /^[+\-]/.test(line)) {
         curr.lines.push(line);
       } else if (line.startsWith("diff --git")) {
-        let ms = line.match(/diff\s--git\sa\/(.*)\sb\//);
-        if (ms) {
-          fsPath = ms[1];
+        const parsedPath = parseDiffPath(line);
+        if (relpath || parsedPath) {
+          fsPath = relpath ? toUnixSlash(relpath) : parsedPath;
           curr = void 0;
           idx += 4;
           continue;
@@ -7223,9 +7346,7 @@ var Repo = class {
   }
   async hasChanged() {
     let result = await this.exec(["diff", "--name-status"]);
-    if (!result.stdout) return false;
-    let lines = result.stdout.split(/\r?\n/);
-    return lines.some((l) => l.startsWith("M"));
+    return result.stdout.trim().length > 0;
   }
   async getStaged() {
     let result = await this.exec(["diff", "--staged", "--name-status"]);
@@ -7244,23 +7365,23 @@ var Repo = class {
     return [conflicted, staged];
   }
   async hasUntracked() {
-    let cp2 = this.git.stream(this.root, ["ls-files", "--others", "--exclude-standard"]);
+    let cp2 = this.git.stream(this.root, ["ls-files", "--others", "--exclude-standard", "--directory"]);
     return new Promise((resolve) => {
-      let hasData = false;
-      let timer = setTimeout(() => {
-        if (cp2.killed) return;
-        cp2.kill("SIGKILL");
-        resolve(false);
-      }, 100);
+      let settled = false;
+      const finish = (value) => {
+        if (settled) return;
+        settled = true;
+        resolve(value);
+      };
       cp2.stdout.on("data", () => {
-        clearTimeout(timer);
-        hasData = true;
         cp2.kill("SIGKILL");
-        resolve(hasData);
+        finish(true);
       });
       cp2.on("exit", () => {
-        clearTimeout(timer);
-        resolve(hasData);
+        finish(false);
+      });
+      cp2.on("error", () => {
+        finish(false);
       });
     });
   }
@@ -7284,14 +7405,11 @@ var Repo = class {
   }
   async getDiff(relFilepath, content, revision = "", encoding = "utf8") {
     if (relFilepath.startsWith(`.git${import_path6.default.sep}`)) return;
-    let fullpath = import_path6.default.join(this.root, relFilepath);
-    if (!import_fs2.default.existsSync(fullpath)) return;
     let staged;
     try {
       let indexed = await this.isIndexed(relFilepath);
       if (!indexed) return;
       let res = await this.exec(["--no-pager", "show", `${revision}:${toUnixSlash(relFilepath)}`], { encoding });
-      if (!res.stdout) return;
       staged = res.stdout.replace(/\r?\n$/, "").split(/\r?\n/).join("\n");
     } catch (e) {
       this.channel.append(e.stack);
@@ -7299,39 +7417,55 @@ var Repo = class {
     }
     const stagedFile = import_path6.default.join(import_os.default.tmpdir(), `coc-${v4_default()}`);
     const currentFile = import_path6.default.join(import_os.default.tmpdir(), `coc-${v4_default()}`);
-    await import_util8.default.promisify(import_fs2.default.writeFile)(stagedFile, staged + "\n", "utf8");
-    await import_util8.default.promisify(import_fs2.default.writeFile)(currentFile, content, "utf8");
-    let output = await getStdout(`git --no-pager diff --no-ext-diff -p -U0 --no-color ${shellescape(stagedFile)} ${shellescape(currentFile)}`);
-    await import_util8.default.promisify(import_fs2.default.unlink)(stagedFile);
-    await import_util8.default.promisify(import_fs2.default.unlink)(currentFile);
+    let output;
+    try {
+      await import_util5.default.promisify(import_fs2.default.writeFile)(stagedFile, staged + "\n", "utf8");
+      await import_util5.default.promisify(import_fs2.default.writeFile)(currentFile, content, "utf8");
+      const result = await this.exec([
+        "--no-pager",
+        "diff",
+        "--no-index",
+        "--no-ext-diff",
+        "-p",
+        "-U0",
+        "--no-color",
+        stagedFile,
+        currentFile
+      ], { allowedExitCodes: [1] });
+      output = result.stdout;
+    } finally {
+      await Promise.all([
+        import_util5.default.promisify(import_fs2.default.unlink)(stagedFile).catch(() => void 0),
+        import_util5.default.promisify(import_fs2.default.unlink)(currentFile).catch(() => void 0)
+      ]);
+    }
     if (!output) return [];
     this.channel.appendLine(`> git diff ${relFilepath}`);
-    const lines = output.trim().split("\n");
+    const lines = output.replace(/\r?\n$/, "").split(/\r?\n/);
     return parseDiff(lines);
   }
   async getDiffAll(category) {
     let diffGroups = /* @__PURE__ */ new Map();
-    let args = "";
+    let args = ["-c", "core.quotepath=false", "--no-pager", "diff", "--no-ext-diff", "--no-renames", "-p", "-U0", "--no-color"];
     if (category === 0 /* All */) {
-      args = "HEAD";
+      const head = await this.safeRun(["rev-parse", "--verify", "HEAD"]);
+      if (head) {
+        args.push("HEAD");
+      } else {
+        const emptyTree = await this.exec(["hash-object", "-t", "tree", "--stdin"], { input: "", log: false });
+        args.push(emptyTree.stdout.trim());
+      }
     } else if (category === 1 /* Staged */) {
-      args = "--cached";
-    } else {
-      args = "";
+      args.push("--cached");
     }
-    let output = await getStdout(`git --no-pager diff --no-ext-diff -p -U0 --no-color ${args}`);
+    let output = (await this.exec(args)).stdout;
     if (!output) return diffGroups;
-    const lines = output.trim().split("\n");
+    const lines = output.replace(/\r?\n$/, "").split(/\r?\n/);
     let lineGroups = /* @__PURE__ */ new Map();
     let file = null;
     for (const line of lines) {
       if (line.startsWith("diff --git")) {
-        let ms = line.match(/diff\s--git\sa\/(.*)\sb\//);
-        if (ms) {
-          file = ms[1];
-        } else {
-          file = null;
-        }
+        file = parseDiffPath(line) || null;
       }
       if (file) {
         if (!lineGroups.has(file)) {
@@ -7349,8 +7483,8 @@ var Repo = class {
     return diffGroups;
   }
   async isIgnored(relativePath) {
-    let res = await this.safeRun(["check-ignore", "--", relativePath]);
-    return res.trim() == relativePath;
+    let res = await this.exec(["check-ignore", "-q", "--", relativePath], { allowedExitCodes: [1] });
+    return res.exitCode === 0;
   }
   async hasConflicts(relativePath) {
     let indexed = await this.isIndexed(relativePath);
@@ -7393,6 +7527,67 @@ var Repo = class {
     }
   }
 };
+function readQuotedGitPath(input, start) {
+  if (input[start] !== '"') return void 0;
+  let value = "";
+  for (let index = start + 1; index < input.length; index++) {
+    const character = input[index];
+    if (character === '"') return { value, end: index + 1 };
+    if (character !== "\\") {
+      value += character;
+      continue;
+    }
+    const escaped = input[++index];
+    if (escaped == null) return void 0;
+    const escapes = {
+      a: "\x07",
+      b: "\b",
+      t: "	",
+      n: "\n",
+      v: "\v",
+      f: "\f",
+      r: "\r",
+      '"': '"',
+      "\\": "\\"
+    };
+    if (escapes[escaped] != null) {
+      value += escapes[escaped];
+      continue;
+    }
+    if (/[0-7]/.test(escaped)) {
+      let octal = escaped;
+      while (octal.length < 3 && /[0-7]/.test(input[index + 1] || "")) octal += input[++index];
+      value += String.fromCharCode(parseInt(octal, 8));
+      continue;
+    }
+    value += escaped;
+  }
+  return void 0;
+}
+function parseDiffPath(line) {
+  const prefix = "diff --git ";
+  if (!line.startsWith(prefix)) return void 0;
+  const value = line.slice(prefix.length);
+  if (value.startsWith('"')) {
+    const first = readQuotedGitPath(value, 0);
+    if (!first) return void 0;
+    const secondStart = value.indexOf('"', first.end);
+    const second = secondStart === -1 ? void 0 : readQuotedGitPath(value, secondStart);
+    if (!second || !first.value.startsWith("a/") || !second.value.startsWith("b/")) return void 0;
+    const firstPath = first.value.slice(2);
+    return firstPath === second.value.slice(2) ? firstPath : void 0;
+  }
+  if (!value.startsWith("a/")) return void 0;
+  const paths = value.slice(2);
+  let separator = paths.indexOf(" b/");
+  while (separator !== -1) {
+    const firstPath = paths.slice(0, separator);
+    if (firstPath === paths.slice(separator + 3)) return firstPath;
+    separator = paths.indexOf(" b/", separator + 1);
+  }
+  return void 0;
+}
+var repo_default = Repo;
 function parseDiff(diffLines) {
   const allLines = diffLines.slice(4);
   const diffs = [];
@@ -7456,11 +7651,11 @@ function parseDiff(diffLines) {
 var import_coc13 = require("coc.nvim");
 var import_fs3 = __toESM(require("fs"));
 var import_path7 = __toESM(require("path"));
-var import_util10 = require("util");
+var import_util7 = require("util");
 async function getRealPath(fullpath) {
   let resolved;
   try {
-    resolved = await (0, import_util10.promisify)(import_fs3.default.realpath)(fullpath, "utf8");
+    resolved = await (0, import_util7.promisify)(import_fs3.default.realpath)(fullpath, "utf8");
   } catch (e) {
     if (e.message.includes("ENOENT")) {
       try {
@@ -7515,7 +7710,7 @@ var Resolver = class {
         this.resolvedRoots.set(uri, root);
       } else {
         try {
-          let stat = import_fs3.default.statSync(fullpath);
+          let stat = await (0, import_util7.promisify)(import_fs3.default.stat)(fullpath);
           let dir = stat.isDirectory() ? fullpath : import_path7.default.dirname(fullpath);
           root = await this.git.getRepositoryRoot(dir);
           if (import_path7.default.isAbsolute(root)) {
@@ -7550,12 +7745,11 @@ var Resolver = class {
 };
 
 // src/model/service.ts
-var uriToRoot = /* @__PURE__ */ new Map();
 var GitService = class {
   constructor(gitInfo) {
     this.repos = /* @__PURE__ */ new Map();
     const outputChannel = this.outputChannel = import_coc14.window.createOutputChannel("git");
-    this._git = new Git(gitInfo, outputChannel);
+    this._git = new git_default(gitInfo, outputChannel);
     this._resolver = new Resolver(this._git, outputChannel);
     if (typeof import_coc14.window.createFloatFactory === "function") {
       this.floatFactory = import_coc14.window.createFloatFactory({ modes: ["n"] });
@@ -7566,7 +7760,7 @@ var GitService = class {
     if (this.repos.has(root)) {
       return this.repos.get(root);
     }
-    let gitRepo = new Repo(this._git, this.outputChannel, root);
+    let gitRepo = new repo_default(this._git, this.outputChannel, root);
     this.repos.set(root, gitRepo);
     return gitRepo;
   }
@@ -7579,19 +7773,15 @@ var GitService = class {
     if (!relpath) return void 0;
     let ignored = await repo.isIgnored(relpath);
     if (ignored) return void 0;
-    uriToRoot.set(doc.uri, root);
     let hasConflicts = await repo.hasConflicts(relpath);
+    if (!doc.attached) return void 0;
     return new GitBuffer(doc, config, relpath, repo, this.git, this.outputChannel, this.floatFactory, hasConflicts);
   }
   async getCurrentRepo() {
     let editor = import_coc14.window.activeTextEditor;
     let root;
     if (editor) {
-      let { uri } = editor.document;
-      root = uriToRoot.get(uri);
-      if (!root) {
-        root = await this.resolver.resolveGitRoot(editor.document);
-      }
+      root = await this.resolver.resolveGitRoot(editor.document);
     } else {
       let cwd = import_coc14.workspace.cwd;
       root = await this.resolver.resolveGitRoot({ uri: import_coc14.Uri.file(cwd).toString(), schema: "file", buftype: "" });
@@ -7620,13 +7810,15 @@ var GitService = class {
 // src/source.ts
 var import_coc15 = require("coc.nvim");
 var import_safe5 = __toESM(require_safe());
+var import_url2 = require("url");
 function byteSlice(content, start, end) {
   let buf = Buffer.from(content, "utf8");
   return buf.slice(start, end).toString("utf8");
 }
 var issuesMap = /* @__PURE__ */ new Map();
 function issuesFiletypes() {
-  return import_coc15.workspace.getConfiguration().get("coc.source.issues.filetypes");
+  var _a;
+  return (_a = import_coc15.workspace.getConfiguration().get("coc.source.issues.filetypes")) != null ? _a : [];
 }
 function getOrganizationNameAndRepoNameFromGitHubRemoteUrl(remoteUrl) {
   try {
@@ -7663,9 +7855,11 @@ function renderWord(issue, issueFormat) {
     }
   }).join("");
 }
-function addSource(context, resolver) {
+function addSource(context, service) {
   let { subscriptions, logger } = context;
+  const { resolver } = service;
   let statusItem = import_coc15.window.createStatusBarItem(0, { progress: true });
+  subscriptions.push(statusItem, { dispose: () => issuesMap.clear() });
   statusItem.text = "loading issues";
   let statusItemCounter = 0;
   function onStartLoading() {
@@ -7675,7 +7869,7 @@ function addSource(context, resolver) {
     }
   }
   function onEndLoading() {
-    statusItemCounter--;
+    statusItemCounter = Math.max(0, statusItemCounter - 1);
     if (statusItemCounter === 0) {
       statusItem.hide();
     }
@@ -7687,12 +7881,15 @@ function addSource(context, resolver) {
     const token = process.env["GITLAB_PRIVATE_TOKEN"];
     if (!token) return [];
     let repo;
-    if (res.startsWith("https")) {
-      const re = new RegExp(`^https:\\/\\/${host}\\/(.*)`);
-      let ms = res.match(re);
-      repo = ms ? ms[1].replace(/\.git$/, "") : null;
-    } else if (res.startsWith("git")) {
-      const re = new RegExp(`git@${host}:(.*)`);
+    const escapedHost = host.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    if (res.startsWith("http")) {
+      try {
+        const url = new import_url2.URL(res);
+        if (url.hostname === host) repo = url.pathname.replace(/^\//, "").replace(/\.git$/, "");
+      } catch (_e) {
+      }
+    } else {
+      const re = new RegExp(`^(?:git@${escapedHost}:|ssh:\\/\\/git@${escapedHost}\\/)(.*)`);
       let ms = res.match(re);
       repo = ms ? ms[1].replace(/\.git$/, "") : null;
     }
@@ -7703,10 +7900,10 @@ function addSource(context, resolver) {
     onStartLoading();
     let issues = [];
     let pageIndex = 1;
-    while (true) {
-      const pageUri = `${uri}&page=${pageIndex}`;
-      pageIndex++;
-      try {
+    try {
+      while (true) {
+        const pageUri = `${uri}&page=${pageIndex}`;
+        pageIndex++;
         let info = await (0, import_coc15.fetch)(pageUri, { headers: { "Private-Token": token } });
         if (!info.length) {
           break;
@@ -7717,16 +7914,17 @@ function addSource(context, resolver) {
             title: info[i].title,
             createAt: new Date(info[i].created_at),
             creator: info[i].author.username,
-            body: info[i].description,
+            body: info[i].description || "",
             repo,
             url: `https://${host}/${repo}/issues/${info[i].iid}`
           });
         }
-      } catch (e) {
-        logger.error(`Request GitLab ${host} issues error:`, e);
       }
+    } catch (e) {
+      logger.error(`Request GitLab ${host} issues error:`, e);
+    } finally {
+      onEndLoading();
     }
-    onEndLoading();
     return issues;
   }
   async function loadGitHubIssues(organizationName, repoName, shouldIncludeOrganizationNameAndRepoNameInAbbr = false) {
@@ -7753,7 +7951,7 @@ function addSource(context, resolver) {
             title: info[i].title,
             createAt: new Date(info[i].created_at),
             creator: info[i].user.login,
-            body: info[i].body,
+            body: info[i].body || "",
             repo,
             url: `https://github.com/${repo}/issues/${info[i].number}`,
             shouldIncludeOrganizationNameAndRepoNameInAbbr
@@ -7769,7 +7967,8 @@ function addSource(context, resolver) {
   }
   async function loadIssues(root) {
     let config = import_coc15.workspace.getConfiguration("git", root);
-    const issueSources = (await safeRun(`git config --get coc-git.issuesources`, { cwd: root }) || "").trim();
+    const repo = service.getRepoFromRoot(root);
+    const issueSources = (await repo.safeRun(["config", "--get", "coc-git.issuesources"]) || "").trim();
     if (issueSources) {
       return Array.prototype.concat.apply(
         [],
@@ -7785,7 +7984,7 @@ function addSource(context, resolver) {
       );
     }
     let remoteName = config.get("remoteName", "origin");
-    let res = await safeRun(`git config --get remote.${remoteName}.url`, { cwd: root });
+    let res = await repo.safeRun(["config", "--get", `remote.${remoteName}.url`]);
     res = res.trim();
     if (res.indexOf("github.com") > 0) {
       const organizationNameAndRepoName = getOrganizationNameAndRepoNameFromGitHubRemoteUrl(res);
@@ -7808,9 +8007,12 @@ function addSource(context, resolver) {
   }
   const loadIssuesFromDocument = (doc) => {
     resolver.resolveGitRoot(doc).then(async (root) => {
+      var _a;
       if (root) {
         let issues = await loadIssues(root);
-        issuesMap.set(doc.bufnr, issues);
+        if (((_a = import_coc15.workspace.getDocument(doc.bufnr)) == null ? void 0 : _a.uri) === doc.uri) {
+          issuesMap.set(doc.bufnr, issues);
+        }
       }
     }).catch(onError);
   };
@@ -7825,6 +8027,13 @@ function addSource(context, resolver) {
       loadIssuesFromDocument(doc);
     }
   }, null, subscriptions);
+  subscriptions.push(import_coc15.workspace.registerAutocmd({
+    event: "BufUnload",
+    arglist: ["+expand('<abuf>')"],
+    callback: (bufnr) => {
+      issuesMap.delete(bufnr);
+    }
+  }));
   let source = {
     name: "issues",
     async doComplete(opt) {
@@ -7870,7 +8079,7 @@ function addSource(context, resolver) {
       execute: async (item, context2) => {
         let winid = context2.listWindow.id;
         let { body, id } = item.data;
-        let lines = body.split(/\r?\n/);
+        let lines = (body || "").split(/\r?\n/);
         let mod = context2.options.position == "top" ? "below" : "above";
         let { nvim } = import_coc15.workspace;
         nvim.pauseNotification();
@@ -7907,6 +8116,7 @@ function addSource(context, resolver) {
 
 // src/index.ts
 async function activate(context) {
+  var _a;
   const config = import_coc16.workspace.getConfiguration("git");
   const { subscriptions } = context;
   let gitInfo;
@@ -7923,7 +8133,7 @@ async function activate(context) {
   const service = new GitService(gitInfo);
   const manager = new DocumentManager(nvim, service, virtualTextSrcId, conflictSrcId);
   subscriptions.push(manager);
-  addSource(context, service.resolver);
+  addSource(context, service);
   subscriptions.push(import_coc16.commands.registerCommand("git.refresh", () => {
     manager.refresh();
   }));
@@ -7975,6 +8185,9 @@ async function activate(context) {
   subscriptions.push(import_coc16.commands.registerCommand("git.chunkInfo", async () => {
     await manager.chunkInfo();
   }));
+  subscriptions.push(import_coc16.commands.registerCommand("git.allChunkInfo", async () => {
+    return await manager.allChunkInfo();
+  }));
   subscriptions.push(import_coc16.commands.registerCommand("git.chunkStage", async () => {
     await manager.chunkStage();
   }));
@@ -8018,7 +8231,7 @@ async function activate(context) {
   subscriptions.push(import_coc16.listManager.registerList(new Gfiles(nvim, manager)));
   subscriptions.push(import_coc16.listManager.registerList(new GChunks(nvim, manager)));
   subscriptions.push(import_coc16.listManager.registerList(new GChanges(nvim, manager)));
-  subscriptions.push(import_coc16.languages.registerCompletionItemProvider("semantic-commit", "Commit", config.get("semanticCommit.filetypes"), {
+  subscriptions.push(import_coc16.languages.registerCompletionItemProvider("semantic-commit", "Commit", (_a = config.get("semanticCommit.filetypes")) != null ? _a : [], {
     provideCompletionItems: async (document, position) => {
       if (position.line !== 0) {
         return [];
@@ -8068,6 +8281,7 @@ async function activate(context) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  activate
+  activate,
+  formatBlameText
 });
 //# sourceMappingURL=index.js.map