coc-git 2.7.5 → 2.7.7

package/lib/index.js

@@ -35,7 +35,7 @@ var require_windows = __commonJS({
     module2.exports = isexe;
     isexe.sync = sync;
     var fs4 = require("fs");
-    function checkPathExt(path9, options) {
+    function checkPathExt(path8, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
         return true;
@@ -46,25 +46,25 @@ var require_windows = __commonJS({
       }
       for (var i = 0; i < pathext.length; i++) {
         var p = pathext[i].toLowerCase();
-        if (p && path9.substr(-p.length).toLowerCase() === p) {
+        if (p && path8.substr(-p.length).toLowerCase() === p) {
           return true;
         }
       }
       return false;
     }
-    function checkStat(stat, path9, options) {
+    function checkStat(stat, path8, options) {
       if (!stat.isSymbolicLink() && !stat.isFile()) {
         return false;
       }
-      return checkPathExt(path9, options);
+      return checkPathExt(path8, options);
     }
-    function isexe(path9, options, cb) {
-      fs4.stat(path9, function(er, stat) {
-        cb(er, er ? false : checkStat(stat, path9, options));
+    function isexe(path8, options, cb) {
+      fs4.stat(path8, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, path8, options));
       });
     }
-    function sync(path9, options) {
-      return checkStat(fs4.statSync(path9), path9, options);
+    function sync(path8, options) {
+      return checkStat(fs4.statSync(path8), path8, options);
     }
   }
 });
@@ -75,13 +75,13 @@ var require_mode = __commonJS({
     module2.exports = isexe;
     isexe.sync = sync;
     var fs4 = require("fs");
-    function isexe(path9, options, cb) {
-      fs4.stat(path9, function(er, stat) {
+    function isexe(path8, options, cb) {
+      fs4.stat(path8, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
-    function sync(path9, options) {
-      return checkStat(fs4.statSync(path9), options);
+    function sync(path8, options) {
+      return checkStat(fs4.statSync(path8), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -114,7 +114,7 @@ var require_isexe = __commonJS({
     }
     module2.exports = isexe;
     isexe.sync = sync;
-    function isexe(path9, options, cb) {
+    function isexe(path8, options, cb) {
       if (typeof options === "function") {
         cb = options;
         options = {};
@@ -124,7 +124,7 @@ var require_isexe = __commonJS({
           throw new TypeError("callback not provided");
         }
         return new Promise(function(resolve, reject) {
-          isexe(path9, options || {}, function(er, is) {
+          isexe(path8, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
@@ -133,7 +133,7 @@ var require_isexe = __commonJS({
           });
         });
       }
-      core(path9, options || {}, function(er, is) {
+      core(path8, options || {}, function(er, is) {
         if (er) {
           if (er.code === "EACCES" || options && options.ignoreErrors) {
             er = null;
@@ -143,9 +143,9 @@ var require_isexe = __commonJS({
         cb(er, is);
       });
     }
-    function sync(path9, options) {
+    function sync(path8, options) {
       try {
-        return core.sync(path9, options || {});
+        return core.sync(path8, options || {});
       } catch (er) {
         if (options && options.ignoreErrors || er.code === "EACCES") {
           return false;
@@ -161,7 +161,7 @@ var require_isexe = __commonJS({
 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 path9 = require("path");
+    var path8 = require("path");
     var COLON = isWindows ? ";" : ":";
     var isexe = require_isexe();
     var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -199,7 +199,7 @@ var require_which = __commonJS({
           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 = path9.join(pathPart, cmd);
+        const pCmd = path8.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         resolve(subStep(p, i, 0));
       });
@@ -226,7 +226,7 @@ var require_which = __commonJS({
       for (let i = 0; i < pathEnv.length; i++) {
         const ppRaw = pathEnv[i];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path9.join(pathPart, cmd);
+        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];
@@ -4783,20 +4783,20 @@ function findSystemGitWin32(base, onLookup) {
   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, path9) => err ? e(err) : c(path9)));
-  return whichPromise.then((path9) => findSpecificGit(path9, 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(path9, onLookup) {
+function findSpecificGit(path8, onLookup) {
   return new Promise((c, e) => {
-    onLookup(path9);
+    onLookup(path8);
     const buffers = [];
-    const child = (0, import_child_process.spawn)(path9, ["--version"]);
+    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: path9, version: parseVersion(Buffer.concat(buffers).toString("utf8").trim()) }));
+    child.on("exit", (code) => code ? e(new Error("Not found")) : c({ path: path8, version: parseVersion(Buffer.concat(buffers).toString("utf8").trim()) }));
   });
 }
 function cpErrorHandler(cb) {
@@ -4813,20 +4813,20 @@ function findGitDarwin(onLookup) {
       if (err) {
         return e("git not found");
       }
-      const path9 = gitPathBuffer.toString().replace(/^\s+|\s+$/g, "");
-      function getVersion(path10) {
-        onLookup(path10);
+      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: path10, version: parseVersion(stdout.trim()) });
+          return c({ path: path9, version: parseVersion(stdout.trim()) });
         });
       }
-      if (path9 !== "/usr/bin/git") {
-        return getVersion(path9);
+      if (path8 !== "/usr/bin/git") {
+        return getVersion(path8);
       }
-      getVersion(path9);
+      getVersion(path8);
       (0, import_child_process.exec)("xcode-select -p", (err2) => {
         if (err2 && err2.code === 2) {
           return e("git not found");
@@ -5697,15 +5697,17 @@ var GitStatus = class {
     import_coc9.events.on("BufWritePost", () => {
       timer = setTimeout(() => {
         this.refresh();
-      }, 300);
+      }, 50);
     }, this, this.disposables);
     this.disposables.push({
       dispose: () => {
         if (timer) clearTimeout(timer);
       }
     });
-    this.refresh().catch((_e) => {
-    });
+    setTimeout(() => {
+      this.refresh().catch((_e) => {
+      });
+    }, 300);
   }
   async refresh() {
     if (!this._enabled) return;
@@ -5750,41 +5752,43 @@ var DocumentManager = class {
     this.loadConfiguration();
     import_coc10.workspace.onDidChangeConfiguration(this.loadConfiguration, this, this.disposables);
     this.gitStatus = new GitStatus(service);
-    const createBuffer = (doc) => {
-      let { uri } = doc;
+    import_coc10.workspace.registerBufferSync((doc) => {
+      let disposed = false;
+      let gitBuffer;
+      let { bufnr, uri } = doc;
       service.createBuffer(doc, this.config).then((buf) => {
-        if (!buf || import_coc10.workspace.getDocument(uri) == null) return;
+        if (!buf || disposed) return;
+        gitBuffer = buf;
         this.defineSigns().catch((e) => {
           console.error(e.message);
         });
         this.buffers.set(doc.bufnr, buf);
       });
-    };
-    for (let doc of import_coc10.workspace.documents) {
-      createBuffer(doc);
-    }
-    import_coc10.workspace.onDidOpenTextDocument(async (e) => {
-      createBuffer(import_coc10.workspace.getDocument(e.bufnr));
-    }, null, this.disposables);
-    import_coc10.workspace.onDidChangeTextDocument(async (e) => {
-      let buf = this.buffers.get(e.bufnr);
-      if (buf) buf.refresh();
-    }, null, this.disposables);
-    import_coc10.workspace.onDidCloseTextDocument((e) => {
-      let buf = this.buffers.get(e.bufnr);
-      if (buf) buf.dispose();
-      this.buffers.delete(e.bufnr);
-      this.service.resolver.delete(e.uri);
-    }, null, this.disposables);
+      return {
+        onChange: () => {
+          if (gitBuffer) gitBuffer._refresh();
+        },
+        dispose: () => {
+          disposed = true;
+          this.buffers.delete(bufnr);
+          this.service.resolver.delete(uri);
+          if (gitBuffer) gitBuffer.dispose();
+        }
+      };
+    });
     import_coc10.events.on("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.events.on("BufWritePre", (bufnr) => {
-      if (!this.enableGutters || this.config.realtimeGutters) return;
-      let buf = this.buffers.get(bufnr);
-      if (buf) buf.updateGutters();
-    }, null, this.disposables);
+    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);
+      }
+    });
     import_coc10.events.on("FocusGained", async () => {
       let bufnr = await nvim.call("bufnr", ["%"]);
       let buf = this.buffers.get(bufnr);
@@ -6039,1523 +6043,1514 @@ var DocumentManager = class {
 // src/model/service.ts
 var import_coc14 = require("coc.nvim");
 
-// src/model/repo.ts
-var import_fs2 = __toESM(require("fs"));
-var import_os = __toESM(require("os"));
-var import_path5 = __toESM(require("path"));
-var import_util6 = __toESM(require("util"));
+// src/model/buffer.ts
+var import_coc11 = require("coc.nvim");
+var import_debounce2 = __toESM(require_debounce());
 
-// node_modules/uuid/dist/esm-node/rng.js
-var import_crypto = __toESM(require("crypto"));
-function rng() {
-  return import_crypto.default.randomBytes(16);
+// node_modules/timeago.js/esm/lang/en_US.js
+var EN_US = ["second", "minute", "hour", "day", "week", "month", "year"];
+function en_US_default(diff, idx) {
+  if (idx === 0)
+    return ["just now", "right now"];
+  var unit = EN_US[Math.floor(idx / 2)];
+  if (diff > 1)
+    unit += "s";
+  return [diff + " " + unit + " ago", "in " + diff + " " + unit];
 }
 
-// node_modules/uuid/dist/esm-node/bytesToUuid.js
-var byteToHex = [];
-for (i = 0; i < 256; ++i) {
-  byteToHex[i] = (i + 256).toString(16).substr(1);
-}
-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/timeago.js/esm/lang/zh_CN.js
+var ZH_CN = ["\u79D2", "\u5206\u949F", "\u5C0F\u65F6", "\u5929", "\u5468", "\u4E2A\u6708", "\u5E74"];
+function zh_CN_default(diff, idx) {
+  if (idx === 0)
+    return ["\u521A\u521A", "\u7247\u523B\u540E"];
+  var unit = ZH_CN[~~(idx / 2)];
+  return [diff + " " + unit + "\u524D", diff + " " + unit + "\u540E"];
 }
-var bytesToUuid_default = bytesToUuid;
 
-// node_modules/uuid/dist/esm-node/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;
-  }
-  options = options || {};
-  var rnds = options.random || (options.rng || rng)();
-  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];
-    }
+// node_modules/timeago.js/esm/register.js
+var Locales = {};
+var register = function(locale, func) {
+  Locales[locale] = func;
+};
+var getLocale = function(locale) {
+  return Locales[locale] || Locales["en_US"];
+};
+
+// node_modules/timeago.js/esm/utils/date.js
+var SEC_ARRAY = [
+  60,
+  60,
+  24,
+  7,
+  365 / 7 / 12,
+  12
+];
+function toDate(input) {
+  if (input instanceof Date)
+    return input;
+  if (!isNaN(input) || /^\d+$/.test(input))
+    return new Date(parseInt(input));
+  input = (input || "").trim().replace(/\.\d+/, "").replace(/-/, "/").replace(/-/, "/").replace(/(\d)T(\d)/, "$1 $2").replace(/Z/, " UTC").replace(/([+-]\d\d):?(\d\d)/, " $1$2");
+  return new Date(input);
+}
+function formatDiff(diff, localeFunc) {
+  var agoIn = diff < 0 ? 1 : 0;
+  diff = Math.abs(diff);
+  var totalSec = diff;
+  var idx = 0;
+  for (; diff >= SEC_ARRAY[idx] && idx < SEC_ARRAY.length; idx++) {
+    diff /= SEC_ARRAY[idx];
   }
-  return buf || bytesToUuid_default(rnds);
+  diff = Math.floor(diff);
+  idx *= 2;
+  if (diff > (idx === 0 ? 9 : 1))
+    idx += 1;
+  return localeFunc(diff, idx, totalSec)[agoIn].replace("%s", diff.toString());
+}
+function diffSec(date, relativeDate) {
+  var relDate = relativeDate ? toDate(relativeDate) : /* @__PURE__ */ new Date();
+  return (+relDate - +toDate(date)) / 1e3;
 }
-var v4_default = v4;
 
-// src/model/repo.ts
-var Repo = class {
-  constructor(git, channel, root) {
+// node_modules/timeago.js/esm/format.js
+var format = function(date, locale, opts) {
+  var sec = diffSec(date, opts && opts.relativeDate);
+  return formatDiff(sec, getLocale(locale));
+};
+
+// node_modules/timeago.js/esm/index.js
+register("en_US", en_US_default);
+register("zh_CN", zh_CN_default);
+
+// src/model/buffer.ts
+var import_url = require("url");
+var signGroup = "CocGit";
+var revPattern = "([0-9A-Za-z_.:/-]+)";
+var startPattern = new RegExp(`^<{7} (${revPattern})(:? .+)?$`);
+var sepPattern = new RegExp(`^={7}$`);
+var endPattern = new RegExp(`^>{7} (${revPattern})(:? .+)?$`);
+var commonPattern = /^\|{7}\smerged\scommon\sancestors/;
+var GitBuffer = class {
+  constructor(doc, config, relpath, repo, git, channel, floatFactory, hasConflicts) {
+    this.doc = doc;
+    this.config = config;
+    this.relpath = relpath;
+    this.repo = repo;
     this.git = git;
     this.channel = channel;
-    this.root = root;
-  }
-  /**
-   * 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));
-    const result = await this.exec(args);
-    if (!result.stdout) {
-      throw new Error(`No staged result.`);
-    }
-    let res = {};
-    let idx = 0;
-    let lines = result.stdout.split(/\r?\n/);
-    let curr;
-    let fsPath;
-    while (idx < lines.length) {
-      let line = lines[idx];
-      if (fsPath && line.startsWith("@@")) {
-        curr = void 0;
-        let ms = line.match(/^@@\s+-(\d+),?(\d*)\s+\+(\d+),?(\d*)\s+@@/);
-        if (ms) {
-          curr = {
-            remove: { lnum: Number(ms[1]), count: ms[2] ? Number(ms[2]) : 1 },
-            add: { lnum: Number(ms[3]), count: ms[4] ? Number(ms[4]) : 1 },
-            lines: []
-          };
-          res[fsPath] = res[fsPath] || [];
-          res[fsPath].push(curr);
-        }
-      } 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];
-          curr = void 0;
-          idx += 4;
-          continue;
-        }
-      }
-      idx++;
-    }
-    return res;
+    this.floatFactory = floatFactory;
+    this.hasConflicts = hasConflicts;
+    this.blameInfo = [];
+    this.diffs = [];
+    this.conflicts = [];
+    this.currentSigns = [];
+    this.gitStatus = "";
+    this.foldEnabled = false;
+    this._disposed = false;
+    this.mutex = new import_coc11.Mutex();
+    this.refresh = (0, import_debounce2.default)(() => {
+      this._refresh().catch((e) => {
+        channel.append(`[Error] ${e.message}`);
+      });
+    }, 200);
+    this._refresh();
   }
-  async getHEAD() {
-    try {
-      const result = await this.exec(["symbolic-ref", "--short", "HEAD"]);
-      if (!result.stdout) {
-        throw new Error("Not in a branch");
-      }
-      return result.stdout.trim();
-    } catch (err) {
-      const result = await this.exec(["rev-parse", "HEAD"]);
-      if (!result.stdout) {
-        throw new Error("Error parsing HEAD");
-      }
-      return result.stdout.trim();
-    }
+  get cachedDiffs() {
+    return this.diffs;
   }
-  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"));
+  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();
   }
-  async getStaged() {
-    let result = await this.exec(["diff", "--staged", "--name-status"]);
-    if (!result.stdout) return [0, 0];
-    let lines = result.stdout.trim().split(/\r?\n/);
-    let conflicted = 0;
-    let staged = 0;
-    lines.forEach((line) => {
-      if (!line.length) return;
-      if (line.startsWith("U")) {
-        conflicted++;
-      } else {
-        staged++;
+  getChunk(line) {
+    if (!this.diffs || this.diffs.length == 0) return void 0;
+    return this.diffs.find((ch) => {
+      let { start, added, removed, changeType } = ch;
+      if (line == 1 && start == 0 && ch.end == 0) {
+        return true;
+      }
+      let end = changeType === "changed" /* Change */ && added.count > removed.count ? ch.end + added.count - removed.count : ch.end;
+      if (start <= line && end >= line) {
+        return true;
       }
+      return false;
     });
-    return [conflicted, staged];
   }
-  async hasUntracked() {
-    let cp2 = this.git.stream(this.root, ["ls-files", "--others", "--exclude-standard"]);
-    return new Promise((resolve) => {
-      let hasData = false;
-      let timer = setTimeout(() => {
-        if (cp2.killed) return;
-        cp2.kill("SIGKILL");
-        resolve(false);
-      }, 100);
-      cp2.stdout.on("data", () => {
-        clearTimeout(timer);
-        hasData = true;
-        cp2.kill("SIGKILL");
-        resolve(hasData);
-      });
-      cp2.on("exit", () => {
-        clearTimeout(timer);
-        resolve(hasData);
+  async chunkUndo() {
+    let line = await import_coc11.workspace.nvim.call("line", ".");
+    let diff = this.getChunk(line);
+    if (!diff) return;
+    let { start, lines, changeType } = diff;
+    let added = lines.filter((s) => s.startsWith("-")).map((s) => s.slice(1));
+    let removeCount = lines.filter((s) => s.startsWith("+")).length;
+    let buf = this.doc.buffer;
+    if (changeType == "delete" /* Delete */) {
+      await buf.setLines(added, { start, end: start, strictIndexing: false });
+    } else {
+      await buf.setLines(added, {
+        start: start - 1,
+        end: start - 1 + removeCount,
+        strictIndexing: false
       });
-    });
-  }
-  async getStatus(character, decorator) {
-    try {
-      let head = await this.getHEAD();
-      if (!head) return "";
-      let [changed, staged, untracked] = await Promise.all([this.hasChanged(), this.getStaged(), this.hasUntracked()]);
-      const { changedDecorator, conflictedDecorator, stagedDecorator, untrackedDecorator } = decorator;
-      let more = "";
-      if (changed) more += changedDecorator;
-      if (staged[0]) more += conflictedDecorator;
-      if (staged[1]) more += stagedDecorator;
-      if (untracked) more += untrackedDecorator;
-      return `${character ? character + " " : ""}${head}${more}`;
-    } catch (e) {
-      this.channel.appendLine("Error on git status");
-      this.channel.append(e.message);
-      return "";
     }
   }
-  async getDiff(relFilepath, content, revision = "", encoding = "utf8") {
-    if (relFilepath.startsWith(`.git${import_path5.default.sep}`)) return;
-    let fullpath = import_path5.default.join(this.root, relFilepath);
-    if (!import_fs2.default.existsSync(fullpath)) return;
-    let staged;
+  async chunkStage() {
+    let relpath = toUnixSlash(this.relpath);
+    let line = await import_coc11.workspace.nvim.call("line", ".");
+    let diff = this.getChunk(line);
+    if (!diff) {
+      import_coc11.window.showErrorMessage("Not positioned in git chunk");
+      return;
+    }
+    let head;
+    if (diff.changeType === "add" /* Add */) {
+      head = `@@ -${diff.removed.start + 1},0 +${diff.removed.start + 1},${diff.added.count} @@`;
+    } else if (diff.changeType === "delete" /* Delete */) {
+      head = `@@ -${diff.removed.start},${diff.removed.count} +${diff.removed.start},0 @@`;
+    } else if (diff.changeType === "changed" /* Change */) {
+      head = `@@ -${diff.removed.start},${diff.removed.count} +${diff.removed.start},${diff.added.count} @@`;
+    }
+    const lines = [
+      `diff --git a/${relpath} b/${relpath}`,
+      `index 000000..000000 100644`,
+      `--- a/${relpath}`,
+      `+++ b/${relpath}`,
+      head
+    ];
+    lines.push(...diff.lines);
+    lines.push("");
     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");
+      await this.git.exec(this.repo.root, ["apply", "--cached", "--unidiff-zero", "-"], { input: lines.join("\n") });
+      this.refresh();
     } catch (e) {
-      this.channel.append(e.stack);
-      return;
+      this.channel.appendLine(`[Error] ${e.message}`);
     }
-    const stagedFile = import_path5.default.join(import_os.default.tmpdir(), `coc-${v4_default()}`);
-    const currentFile = import_path5.default.join(import_os.default.tmpdir(), `coc-${v4_default()}`);
-    await import_util6.default.promisify(import_fs2.default.writeFile)(stagedFile, staged + "\n", "utf8");
-    await import_util6.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_util6.default.promisify(import_fs2.default.unlink)(stagedFile);
-    await import_util6.default.promisify(import_fs2.default.unlink)(currentFile);
-    if (!output) return [];
-    this.channel.appendLine(`> git diff ${relFilepath}`);
-    const lines = output.trim().split("\n");
-    return parseDiff(lines);
   }
-  async getDiffAll(category) {
-    let diffGroups = /* @__PURE__ */ new Map();
-    let args = "";
-    if (category === 0 /* All */) {
-      args = "HEAD";
-    } else if (category === 1 /* Staged */) {
-      args = "--cached";
-    } else {
-      args = "";
-    }
-    let output = await getStdout(`git --no-pager diff --no-ext-diff -p -U0 --no-color ${args}`);
-    if (!output) return diffGroups;
-    const lines = output.trim().split("\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;
-        }
-      }
-      if (file) {
-        if (!lineGroups.has(file)) {
-          lineGroups.set(file, []);
+  async chunkUnstage() {
+    let { nvim } = import_coc11.workspace;
+    const { diffs } = this;
+    let line = await nvim.call("line", ".");
+    let adjust = 0;
+    let invalid = false;
+    for (let diff of diffs) {
+      if (diff.end >= line) {
+        if (diff.start <= line && diff.changeType != "delete" /* Delete */) {
+          import_coc11.window.showErrorMessage(`Current line contains unstaged change.`);
+          invalid = true;
         }
-        lineGroups.get(file).push(line);
+        break;
       }
+      adjust -= diff.added.count;
+      adjust += diff.removed.count;
     }
-    for (const [file2, lines2] of lineGroups) {
-      let diffs = parseDiff(lines2);
-      if (diffs) {
-        diffGroups.set(file2, diffs);
-      }
+    if (invalid) return;
+    line = line + adjust;
+    let stagedDiff = await this.repo.getStagedChunks(this.relpath);
+    let chunks = Object.values(stagedDiff)[0];
+    if (!chunks.length) {
+      import_coc11.window.showErrorMessage(`Staged chunk not found`);
+      return;
     }
-    return diffGroups;
-  }
-  async isIgnored(relativePath) {
-    let res = await this.safeRun(["check-ignore", "--", relativePath]);
-    return res.trim() == relativePath;
-  }
-  async hasConflicts(relativePath) {
-    let indexed = await this.isIndexed(relativePath);
-    if (!indexed) return false;
-    let res = await this.exec(["diff", "--staged", "--name-status", "--", relativePath]);
-    return res.stdout.trim().startsWith("U");
-  }
-  async isIndexed(relpath) {
-    let res = await this.exec(["ls-files", "--", relpath]);
-    return res.stdout && res.stdout.trim().length > 0;
-  }
-  async getUsername() {
-    if (typeof this.userName === "string") return this.userName;
-    try {
-      let res = await this.exec(["config", "user.name"]);
-      this.userName = res.stdout.trim();
-      return this.userName;
-    } catch (e) {
-      this.userName = "";
-      return "";
+    let chunk = chunks.find((o) => o.add.lnum <= line && o.add.lnum + o.add.count >= line);
+    if (!chunk) {
+      import_coc11.window.showErrorMessage(`Unable to find staged chunk on current line`);
+      return;
     }
-  }
-  async isShallow() {
+    this.channel.appendLine(`[Info] resolved chunk ${JSON.stringify(chunk, null, 2)}`);
+    let patch = createUnstagePatch(this.relpath, chunk);
+    if (!patch) return;
     try {
-      let res = await this.exec(["rev-parse", "--is-shallow-repository"]);
-      return res.stdout.trim() === "true";
+      await this.git.exec(this.repo.root, ["apply", "--cached", "--unidiff-zero", "-"], { input: patch });
+      this.refresh();
     } catch (e) {
-      return false;
+      import_coc11.window.showErrorMessage(`Unable to apply patch: ${e.message}`);
+      this.channel.appendLine(`[Error] ${e.message}`);
     }
   }
-  async exec(args, options = {}) {
-    return await this.git.exec(this.root, args, options);
-  }
-  async safeRun(args, options = {}) {
-    try {
-      let res = await this.exec(args, options);
-      return res ? res.stdout.replace(/\s*$/, "") : "";
-    } catch (e) {
-      return "";
+  async nextChunk() {
+    const { diffs } = this;
+    let { nvim } = import_coc11.workspace;
+    if (!diffs || diffs.length == 0) return;
+    let line = await nvim.call("line", ".");
+    for (let diff of diffs) {
+      if (diff.start > line) {
+        await import_coc11.window.moveTo({ line: Math.max(diff.start - 1, 0), character: 0 });
+        return;
+      }
+    }
+    if (await nvim.getOption("wrapscan")) {
+      await import_coc11.window.moveTo({ line: Math.max(diffs[0].start - 1, 0), character: 0 });
     }
   }
-};
-function parseDiff(diffLines) {
-  const allLines = diffLines.slice(4);
-  const diffs = [];
-  let diff = null;
-  for (const line of allLines) {
-    if (!line.startsWith("@@")) {
-      if (diff) {
-        diff.lines.push(line);
+  async prevChunk() {
+    const { nvim } = import_coc11.workspace;
+    let { diffs } = this;
+    let line = await nvim.call("line", ".");
+    if (!diffs || diffs.length == 0) return;
+    for (let diff of diffs.slice().reverse()) {
+      if (diff.end < line) {
+        await import_coc11.window.moveTo({ line: Math.max(diff.start - 1, 0), character: 0 });
+        return;
       }
-      continue;
     }
-    let diffKey = line.split("@@", 2)[1].trim();
-    const [pres, nows] = diffKey.split(/\s+/).map((str) => str.slice(1).split(","));
-    const removed = {
-      start: parseInt(pres[0], 10),
-      count: parseInt(`${pres[1] || 1}`, 10)
-    };
-    const added = {
-      start: parseInt(nows[0], 10),
-      count: parseInt(`${nows[1] || 1}`, 10)
-    };
-    if (added.count === 0) {
-      diff = {
-        lines: [],
-        start: added.start,
-        end: added.start,
-        head: line,
-        removed,
-        added,
-        changeType: "delete" /* Delete */
-      };
-      diffs.push(diff);
-    } else if (removed.count === 0) {
-      diff = {
-        lines: [],
-        start: added.start,
-        end: added.start + added.count - 1,
-        head: line,
-        removed,
-        added,
-        changeType: "add" /* Add */
-      };
-      diffs.push(diff);
-    } else {
-      diff = {
-        lines: [],
-        start: added.start,
-        end: added.start + Math.min(added.count, removed.count) - 1,
-        head: line,
-        removed,
-        added,
-        changeType: "changed" /* Change */
-      };
-      diffs.push(diff);
+    if (await nvim.getOption("wrapscan")) {
+      await import_coc11.window.moveTo({ line: Math.max(diffs[diffs.length - 1].start - 1, 0), character: 0 });
     }
   }
-  return diffs;
-}
-
-// src/model/git.ts
-var cp = __toESM(require("child_process"));
-var import_coc11 = require("coc.nvim");
-var import_iconv_lite = __toESM(require_lib());
-var import_path6 = __toESM(require("path"));
-var Git = class {
-  constructor(gitInfo, channel) {
-    this.gitInfo = gitInfo;
-    this.channel = channel;
-  }
-  async getRepositoryRoot(repositoryPath) {
-    const result = await this.exec(repositoryPath, ["rev-parse", "--show-toplevel"]);
-    let repoRootPath = import_path6.default.normalize(result.stdout.trim());
-    if (process.platform === "win32" && repoRootPath.startsWith("\\") && !process.env.SHELL) {
-      repoRootPath = repoRootPath.replace(/^\\([^\\]*)\\/, "$1:\\");
+  async chunkInfo() {
+    let line = await import_coc11.workspace.nvim.call("line", ".");
+    let diff = this.getChunk(line);
+    if (diff) {
+      let content = diff.head + "\n" + diff.lines.join("\n");
+      await this.showDoc(content, "diff");
+    } else {
+      let chunks = [];
+      try {
+        let stagedDiff = await this.repo.getStagedChunks(this.relpath);
+        chunks = Object.values(stagedDiff)[0];
+      } catch (e) {
+      }
+      let adjust = 0;
+      for (let diff2 of this.diffs) {
+        if (diff2.end >= line) {
+          break;
+        }
+        adjust -= diff2.added.count;
+        adjust += diff2.removed.count;
+      }
+      line = line + adjust;
+      let chunk = chunks.find((o) => o.add.lnum <= line && o.add.lnum + o.add.count >= line);
+      if (chunk) {
+        let content = "Staged changes\n" + chunk.lines.join("\n");
+        await this.showDoc(content, "diff");
+      } else {
+        await this.showCommit(true);
+      }
     }
-    return repoRootPath;
-  }
-  async exec(cwd, args, options = {}) {
-    options = Object.assign({ cwd }, options || {});
-    return await this._exec(args, options);
-  }
-  stream(cwd, args, options = {}) {
-    options = Object.assign({ cwd }, options || {});
-    return this.spawn(args, options);
   }
-  async _exec(args, options = {}) {
-    const child = this.spawn(args, options);
-    if (options.input) {
-      child.stdin.end(options.input, "utf8");
-    }
-    const bufferResult = await exec2(child, options.cancellationToken);
-    if (options.log !== false && bufferResult.stderr.length > 0) {
-      this.log(`${bufferResult.stderr}
-`);
+  async showBlameInfo(lnum) {
+    let { nvim } = import_coc11.workspace;
+    let { virtualTextSrcId, addGBlameToBufferVar, addGBlameToVirtualText } = this.config;
+    if (!this.showBlame) return;
+    let infos = this.blameInfo;
+    if (!infos) return;
+    let blameText;
+    if (infos.length == 0) {
+      blameText = "File not indexed";
+    } 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}`;
+      } else {
+        blameText = "Not committed yet";
+      }
     }
-    let encoding = options.encoding || "utf8";
-    encoding = import_iconv_lite.default.encodingExists(encoding) ? encoding : "utf8";
-    const result = {
-      exitCode: bufferResult.exitCode,
-      stdout: import_iconv_lite.default.decode(bufferResult.stdout, encoding),
-      stderr: bufferResult.stderr
-    };
-    if (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);
-      return Promise.reject(new Error("Failed to execute git"));
+    let buffer = nvim.createBuffer(this.doc.bufnr);
+    let hide_blame = await nvim.getVar("coc_git_hide_blame_virtual_text");
+    if (hide_blame) {
+      buffer.clearNamespace(virtualTextSrcId);
+    } else {
+      if (addGBlameToBufferVar) {
+        nvim.pauseNotification();
+        buffer.setVar("coc_git_blame", blameText, true);
+        nvim.call("coc#util#do_autocmd", ["CocGitStatusChange"], true);
+        nvim.resumeNotification(false, true);
+      }
+      if (addGBlameToVirtualText) {
+        const prefix = this.config.virtualTextPrefix;
+        nvim.pauseNotification();
+        buffer.clearNamespace(virtualTextSrcId);
+        buffer.setVirtualText(virtualTextSrcId, lnum - 1, [[prefix + blameText, "CocCodeLens"]]);
+        nvim.resumeNotification(true, true);
+      }
     }
-    return result;
   }
-  spawn(args, options = {}) {
-    if (!options) {
-      options = {};
-    }
-    if (!options.stdio && !options.input) {
-      options.stdio = ["ignore", null, null];
+  async showBlameDoc(lnum) {
+    let indexed = await this.repo.isIndexed(this.relpath);
+    if (!indexed) {
+      import_coc11.window.showWarningMessage("File not indexed");
+    } else if (await this.repo.isShallow()) {
+      import_coc11.window.showWarningMessage("Shallow repository, blame not available");
+    } else {
+      let infos = await this.getBlameInfo([lnum, lnum]);
+      let info = infos.find((o) => lnum >= o.startLnum && lnum <= o.endLnum);
+      if (info && info.author && info.author != "Not Committed Yet") {
+        let blameText = [];
+        blameText.push(`${info.author}, ${info.time}`);
+        blameText.push(`${info.summary}`);
+        blameText.push(`${info.sha.substring(0, 7)}`);
+        await this.showDoc(blameText.join("\n\n"), "text");
+      } else {
+        import_coc11.window.showWarningMessage("Not committed yet");
+      }
     }
-    options.env = Object.assign({}, process.env, options.env || {}, {
-      LC_ALL: "en_US.UTF-8",
-      LANG: "en_US.UTF-8"
-    });
-    if (process.platform === "win32") {
-      options.shell = true;
+  }
+  async diffDocument(force = false) {
+    let { nvim } = import_coc11.workspace;
+    let revision = this.config.diffRevision;
+    const { bufnr } = this.doc;
+    let content = this.doc.content;
+    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.length === 0) {
+      this.currentSigns = [];
+      this.diffs = [];
+      this.setBufferStatus("");
+      if (this.config.enableGutters) {
+        nvim.call("sign_unplace", [signGroup, { buffer: bufnr }], true);
+        nvim.redrawVim();
+      }
+      return;
     }
-    if (options.log !== false) {
-      this.log(`> git ${args.join(" ")}
-`);
+    if (equals(diffs, this.diffs)) {
+      return;
     }
-    return cp.spawn(this.gitInfo.path, args, options);
-  }
-  log(output) {
-    this.channel.append(output);
-  }
-};
-async function exec2(child, cancellationToken) {
-  if (!child.stdout || !child.stderr) {
-    throw new Error("Failed to get stdout or stderr from git process.");
-  }
-  if (cancellationToken && cancellationToken.isCancellationRequested) {
-    throw new Error("Cancelled");
-  }
-  const disposables = [];
-  const once = (ee, name, fn) => {
-    ee.once(name, fn);
-    disposables.push(import_coc11.Disposable.create(() => ee.removeListener(name, fn)));
-  };
-  const on = (ee, name, fn) => {
-    ee.on(name, fn);
-    disposables.push(import_coc11.Disposable.create(() => ee.removeListener(name, fn)));
-  };
-  let result = Promise.all([
-    new Promise((c, e) => {
-      once(child, "error", cpErrorHandler(e));
-      once(child, "exit", c);
-    }),
-    new Promise((c) => {
-      const buffers = [];
-      on(child.stdout, "data", (b) => buffers.push(b));
-      once(child.stdout, "close", () => c(Buffer.concat(buffers)));
-    }),
-    new Promise((c) => {
-      const buffers = [];
-      on(child.stderr, "data", (b) => buffers.push(b));
-      once(child.stderr, "close", () => c(Buffer.concat(buffers).toString("utf8")));
-    })
-  ]);
-  if (cancellationToken) {
-    const cancellationPromise = new Promise((_, e) => {
-      onceEvent(cancellationToken.onCancellationRequested)(() => {
-        try {
-          child.kill();
-        } catch (err) {
+    this.diffs = diffs;
+    let added = 0;
+    let changed = 0;
+    let removed = 0;
+    let signs = [];
+    for (let diff of diffs) {
+      if (diff.changeType == "add" /* Add */) {
+        added += diff.added.count;
+      } else if (diff.changeType == "delete" /* Delete */) {
+        removed += diff.removed.count;
+      } else if (diff.changeType == "changed" /* Change */) {
+        let [add, remove] = [diff.added.count, diff.removed.count];
+        let min = Math.min(add, remove);
+        changed += min;
+        added += add - min;
+        removed += remove - min;
+      }
+      let { start, end } = diff;
+      for (let i = start; i <= end; i++) {
+        let topdelete = diff.changeType == "delete" /* Delete */ && i == 0;
+        let changedelete = diff.changeType == "changed" /* Change */ && diff.removed.count > diff.added.count && i == end;
+        signs.push({
+          changeType: topdelete ? "topdelete" : changedelete ? "changedelete" : diff.changeType,
+          lnum: topdelete ? 1 : i
+        });
+      }
+      if (diff.changeType == "changed" /* Change */) {
+        let [add, remove] = [diff.added.count, diff.removed.count];
+        if (add > remove) {
+          for (let i = 0; i < add - remove; i++) {
+            signs.push({
+              changeType: "add" /* Add */,
+              lnum: diff.end + 1 + i
+            });
+          }
         }
-        e(new Error("Cancelled"));
-      });
-    });
-    result = Promise.race([result, cancellationPromise]);
-  }
-  try {
-    const [exitCode, stdout, stderr] = await result;
-    return { exitCode, stdout, stderr };
-  } finally {
-    (0, import_coc11.disposeAll)(disposables);
-  }
-}
-
-// src/model/resolver.ts
-var import_coc12 = require("coc.nvim");
-var import_fs3 = __toESM(require("fs"));
-var import_path7 = __toESM(require("path"));
-var import_util9 = require("util");
-async function getRealPath(fullpath) {
-  let resolved;
-  try {
-    resolved = await (0, import_util9.promisify)(import_fs3.default.realpath)(fullpath, "utf8");
-  } catch (e) {
-    if (e.message.includes("ENOENT")) {
-      try {
-        resolved = await import_coc12.workspace.nvim.call("expand", [fullpath]);
-      } catch (e2) {
       }
     }
+    let items = [];
+    if (added) items.push(`+${added}`);
+    if (changed) items.push(`~${changed}`);
+    if (removed) items.push(`-${removed}`);
+    let status = `  ${items.join(" ")} `;
+    this.setBufferStatus(status);
+    this.currentSigns = signs;
+    if (!this.config.realtimeGutters && !force) return;
+    this.updateGutters();
   }
-  return resolved || fullpath;
-}
-var Resolver = class {
-  constructor(git, channel) {
-    this.git = git;
-    this.channel = channel;
-    this.resolvedRoots = /* @__PURE__ */ new Map();
-    this.relativePaths = /* @__PURE__ */ new Map();
-  }
-  delete(uri) {
-    this.resolvedRoots.delete(uri);
-    this.relativePaths.delete(uri);
-  }
-  clear() {
-    this.resolvedRoots.clear();
-    this.relativePaths.clear();
+  updateGutters() {
+    if (this._disposed) return;
+    if (!this.config.enableGutters) return;
+    let { nvim } = import_coc11.workspace;
+    let { bufnr } = this.doc;
+    let { signPriority } = this.config;
+    let signs = this.currentSigns;
+    nvim.pauseNotification();
+    nvim.call("sign_unplace", [signGroup, { buffer: bufnr }], true);
+    for (let sign of signs) {
+      let name = this.getSignName(sign.changeType);
+      nvim.call("sign_place", [0, signGroup, name, bufnr, { lnum: sign.lnum, priority: signPriority }], true);
+    }
+    nvim.resumeNotification(true, true);
   }
-  getRelativePath(uri) {
-    return this.relativePaths.get(uri);
+  async loadBlames() {
+    if (!this.showBlame) return;
+    let result = [];
+    let indexed = await this.repo.isIndexed(this.relpath);
+    if (indexed) result = await this.getBlameInfo();
+    this.blameInfo = result;
   }
-  async resolveGitRoot(doc) {
-    if (!doc) return null;
-    let root;
-    const { uri } = doc;
-    root = this.resolvedRoots.get(uri);
-    if (root) return root;
-    if (doc.buftype == "acwrite") {
-      root = await this.resolveRootFromCwd();
-      this.resolvedRoots.set(uri, root);
-      return root;
+  async getBlameInfo(range) {
+    let { relpath } = this;
+    let root = this.repo.root;
+    let res = [];
+    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];
+      if (range) args.push("-L", range.join(","));
+      let r = await this.git.exec(root, args, {
+        log: false,
+        input: this.doc.content
+      });
+      if (!r.stdout) return res;
+      let info;
+      for (let line of r.stdout.trim().split(/\r?\n/)) {
+        line = line.trim();
+        if (/^(author |committer )?External file \(--contents\)/.test(line)) {
+          line = "Not committed yet.";
+        }
+        let ms = line.match(/^([A-Za-z0-9]+)\s(\d+)\s(\d+)\s(\d+)/);
+        if (ms) {
+          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]);
+            if (find) {
+              info.author = find.author;
+              info.time = find.time;
+              info.summary = find.summary;
+            }
+          }
+          res.push(info);
+        } else if (info) {
+          if (line.startsWith("author ")) {
+            let author = line.replace(/^author/, "").trim();
+            info.author = author == currentAuthor ? "You" : author;
+          } else if (line.startsWith("author-time ")) {
+            let text = line.replace(/^author-time/, "").trim();
+            const timestamps = parseInt(text, 10) * 1e3;
+            info.time = useRealTime ? new Date(timestamps).toLocaleString() : format(timestamps, process.env.LANG);
+          } else if (line.startsWith("summary ")) {
+            let text = line.replace(/^summary/, "").trim();
+            info.summary = text;
+          }
+        }
+      }
+      return res;
+    } catch (e) {
+      this.channel.appendLine(e.stack);
     }
-    if (doc.buftype != "" || doc.schema != "file") {
-      return null;
+    return res;
+  }
+  async diffCached() {
+    let res = await this.repo.safeRun(["diff", "--cached"]);
+    if (!res.trim()) {
+      import_coc11.window.showWarningMessage("Empty diff");
+      return;
     }
-    let fullpath = await getRealPath(import_coc12.Uri.parse(uri).fsPath);
-    if (process.platform == "win32") {
-      fullpath = import_path7.default.win32.normalize(fullpath);
+    let { nvim } = import_coc11.workspace;
+    nvim.pauseNotification();
+    nvim.command(`keepalt above new +setl\\ previewwindow`, true);
+    nvim.call("append", [0, res.split(/\r?\n/)], true);
+    nvim.command("normal! Gdd", true);
+    nvim.command(`exe 1`, true);
+    nvim.command("setfiletype git", true);
+    nvim.command("setl buftype=nofile nomodifiable bufhidden=wipe nobuflisted", true);
+    await nvim.resumeNotification();
+  }
+  async nextConflict() {
+    let { nvim } = import_coc11.workspace;
+    if (!this.conflicts.length) {
+      import_coc11.window.showWarningMessage("No conflicts detected");
+      return;
     }
-    if (!root) {
-      let parts = fullpath.split(import_path7.default.sep);
-      let idx = parts.indexOf(".git");
-      if (idx !== -1) {
-        root = parts.slice(0, idx).join(import_path7.default.sep);
-        this.resolvedRoots.set(uri, root);
-      } else {
-        try {
-          root = await this.git.getRepositoryRoot(import_path7.default.dirname(fullpath));
-          if (import_path7.default.isAbsolute(root)) {
-            this.resolvedRoots.set(uri, root);
-          } else {
-            root = void 0;
-          }
-        } catch (e) {
-        }
+    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;
       }
     }
-    if (root) {
-      this.relativePaths.set(uri, import_path7.default.relative(root, fullpath));
+    if (await nvim.getOption("wrapscan")) {
+      await import_coc11.window.moveTo({ line: Math.max(this.conflicts[0].start - 1, 0), character: 0 });
     }
-    this.channel.appendLine(`resolved root of ${fullpath}: ${root}`);
-    return root;
   }
-  async resolveRootFromCwd() {
-    let parts = import_coc12.workspace.cwd.split(import_path7.default.sep);
-    let idx = parts.indexOf(".git");
-    if (idx !== -1) return parts.slice(0, idx).join(import_path7.default.sep);
-    try {
-      return await this.git.getRepositoryRoot(import_coc12.workspace.cwd);
-    } catch (e) {
+  async prevConflict() {
+    let { nvim } = import_coc11.workspace;
+    if (!this.conflicts.length) {
+      import_coc11.window.showWarningMessage("No conflicts detected", "warning");
+      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;
+      }
+    }
+    if (await nvim.getOption("wrapscan")) {
+      await import_coc11.window.moveTo({ line: Math.max(this.conflicts[0].start - 1, 0), character: 0 });
     }
-    return null;
   }
-  dispose() {
-    this.resolvedRoots.clear();
-    this.relativePaths.clear();
+  async conflictKeepPart(part) {
+    const { nvim } = import_coc11.workspace;
+    let conflicts = this.conflicts;
+    if (!conflicts || conflicts.length == 0) {
+      import_coc11.window.showWarningMessage("No conflicts detected");
+      return;
+    }
+    let line = await nvim.call("line", ".");
+    for (let conflict of conflicts) {
+      if (conflict.start <= line && conflict.end >= line) {
+        switch (part) {
+          case 0 /* Current */:
+            let start = conflict.common ? conflict.common : conflict.sep;
+            await nvim.command(`${start},${conflict.end}d | ${conflict.start}d`);
+            return;
+          case 1 /* Incoming */:
+            await nvim.command(`${conflict.end}d | ${conflict.start},${conflict.sep}d`);
+            return;
+          case 2 /* Both */:
+            if (conflict.common) {
+              await nvim.command(`${conflict.end}d | ${conflict.common},${conflict.sep}d | ${conflict.start}d`);
+            } else {
+              await nvim.command(`${conflict.end}d | ${conflict.sep}d | ${conflict.start}d`);
+            }
+            return;
+        }
+      }
+    }
+    import_coc11.window.showWarningMessage("Not positioned on a conflict");
   }
-};
-
-// src/model/buffer.ts
-var import_coc13 = require("coc.nvim");
-var import_debounce2 = __toESM(require_debounce());
-
-// node_modules/timeago.js/esm/lang/en_US.js
-var EN_US = ["second", "minute", "hour", "day", "week", "month", "year"];
-function en_US_default(diff, idx) {
-  if (idx === 0)
-    return ["just now", "right now"];
-  var unit = EN_US[Math.floor(idx / 2)];
-  if (diff > 1)
-    unit += "s";
-  return [diff + " " + unit + " ago", "in " + diff + " " + unit];
-}
-
-// node_modules/timeago.js/esm/lang/zh_CN.js
-var ZH_CN = ["\u79D2", "\u5206\u949F", "\u5C0F\u65F6", "\u5929", "\u5468", "\u4E2A\u6708", "\u5E74"];
-function zh_CN_default(diff, idx) {
-  if (idx === 0)
-    return ["\u521A\u521A", "\u7247\u523B\u540E"];
-  var unit = ZH_CN[~~(idx / 2)];
-  return [diff + " " + unit + "\u524D", diff + " " + unit + "\u540E"];
-}
-
-// node_modules/timeago.js/esm/register.js
-var Locales = {};
-var register = function(locale, func) {
-  Locales[locale] = func;
-};
-var getLocale = function(locale) {
-  return Locales[locale] || Locales["en_US"];
-};
-
-// node_modules/timeago.js/esm/utils/date.js
-var SEC_ARRAY = [
-  60,
-  60,
-  24,
-  7,
-  365 / 7 / 12,
-  12
-];
-function toDate(input) {
-  if (input instanceof Date)
-    return input;
-  if (!isNaN(input) || /^\d+$/.test(input))
-    return new Date(parseInt(input));
-  input = (input || "").trim().replace(/\.\d+/, "").replace(/-/, "/").replace(/-/, "/").replace(/(\d)T(\d)/, "$1 $2").replace(/Z/, " UTC").replace(/([+-]\d\d):?(\d\d)/, " $1$2");
-  return new Date(input);
-}
-function formatDiff(diff, localeFunc) {
-  var agoIn = diff < 0 ? 1 : 0;
-  diff = Math.abs(diff);
-  var totalSec = diff;
-  var idx = 0;
-  for (; diff >= SEC_ARRAY[idx] && idx < SEC_ARRAY.length; idx++) {
-    diff /= SEC_ARRAY[idx];
+  async browser(action = "open", range, permalink = false) {
+    let { nvim } = import_coc11.workspace;
+    let config = import_coc11.workspace.getConfiguration("git");
+    let head = (await this.repo.safeRun(["rev-parse", "HEAD"])).trim();
+    let branch = config.get("browserBranchName", "").trim();
+    if (!branch.length) {
+      branch = (await this.repo.safeRun(["symbolic-ref", "--short", "-q", "HEAD"])).trim();
+    }
+    let lines = range && range.length == 2 ? [
+      range[0],
+      range[1]
+    ] : [await nvim.eval('line(".")')];
+    if (this.doc.filetype == "markdown") {
+      let line = await nvim.call("getline", ["."]);
+      if (line.startsWith("#")) {
+        let words = line.replace(/^#+\s*/, "").split(/\s+/);
+        lines = words.map((s) => s.toLowerCase()).join("-");
+      }
+    }
+    let output = await this.repo.safeRun(["remote"]);
+    if (!output.trim()) {
+      import_coc11.window.showWarningMessage(`No remote found`);
+      return;
+    }
+    let names = output.trim().split(/\r?\n/);
+    let browserRemoteName = config.get("browserRemoteName", "").trim();
+    if (browserRemoteName.length > 0) {
+      if (names.includes(browserRemoteName)) {
+        names = [browserRemoteName];
+      } else {
+        import_coc11.window.showWarningMessage("Configured git.browserRemoteName missing from remote list");
+        return;
+      }
+    }
+    let urls = [];
+    for (let name of names) {
+      let uri = await this.repo.safeRun(["config", "--get", `remote.${name}.url`]);
+      if (!uri.length) continue;
+      let repoURL = getRepoUrl(uri);
+      if (!repoURL) continue;
+      let tmp = new import_url.URL(repoURL);
+      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);
+      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);
+        import_coc11.window.showInformationMessage("Copied url to clipboard");
+      }
+    } else if (urls.length > 1) {
+      let url = await import_coc11.window.showQuickPick(urls, { canPickMany: false, title: "Pick remote url" });
+      if (url) {
+        if (action == "open") {
+          await import_coc11.workspace.openResource(url);
+        } else {
+          nvim.command(`let @+ = '${url}'`, true);
+          nvim.command(`let @* = '${url}'`, true);
+          import_coc11.window.showInformationMessage("Copied url to clipboard");
+        }
+      }
+    }
   }
-  diff = Math.floor(diff);
-  idx *= 2;
-  if (diff > (idx === 0 ? 9 : 1))
-    idx += 1;
-  return localeFunc(diff, idx, totalSec)[agoIn].replace("%s", diff.toString());
-}
-function diffSec(date, relativeDate) {
-  var relDate = relativeDate ? toDate(relativeDate) : /* @__PURE__ */ new Date();
-  return (+relDate - +toDate(date)) / 1e3;
-}
-
-// node_modules/timeago.js/esm/format.js
-var format = function(date, locale, opts) {
-  var sec = diffSec(date, opts && opts.relativeDate);
-  return formatDiff(sec, getLocale(locale));
-};
-
-// node_modules/timeago.js/esm/index.js
-register("en_US", en_US_default);
-register("zh_CN", zh_CN_default);
-
-// src/model/buffer.ts
-var import_url = require("url");
-var signGroup = "CocGit";
-var revPattern = "([0-9A-Za-z_.:/-]+)";
-var startPattern = new RegExp(`^<{7} (${revPattern})(:? .+)?$`);
-var sepPattern = new RegExp(`^={7}$`);
-var endPattern = new RegExp(`^>{7} (${revPattern})(:? .+)?$`);
-var commonPattern = /^\|{7}\smerged\scommon\sancestors/;
-var GitBuffer = class {
-  constructor(doc, config, relpath, repo, git, channel, floatFactory) {
-    this.doc = doc;
-    this.config = config;
-    this.relpath = relpath;
-    this.repo = repo;
-    this.git = git;
-    this.channel = channel;
-    this.floatFactory = floatFactory;
-    this.blameInfo = [];
-    this.diffs = [];
-    this.conflicts = [];
-    this.currentSigns = [];
-    this.gitStatus = "";
-    this.hasConflicts = false;
-    this.foldEnabled = false;
-    this._disposed = false;
-    this.mutex = new import_coc13.Mutex();
-    this.refresh = (0, import_debounce2.default)(() => {
-      this._refresh().catch((e) => {
-        channel.append(`[Error] ${e.message}`);
-      });
-    }, 200);
-    this.repo.hasConflicts(relpath).then((hasConflicts) => {
-      this.hasConflicts = hasConflicts;
-      this.refresh();
+  // show commit of current line in split window
+  async showCommit(useFloating = false) {
+    let indexed = await this.repo.isIndexed(this.relpath);
+    if (!indexed) {
+      import_coc11.window.showWarningMessage(`"${this.relpath}" not indexed.`);
+      return;
+    }
+    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 res = await this.repo.exec(args);
+    let output = res.stdout.trim();
+    if (!output.length) return;
+    let commit = output.match(/^\S+/)[0];
+    if (/^0+$/.test(commit)) {
+      import_coc11.window.showWarningMessage("not committed yet!");
+      return;
+    }
+    if (!useFloating) useFloating = this.config.showCommitInFloating;
+    if (useFloating) {
+      let content = await this.repo.safeRun(["--no-pager", "show", commit]);
+      if (content == null) return;
+      await this.showDoc(content.trim());
+      return;
+    }
+    await nvim.command(`keepalt above ${this.config.splitWindowCommand}`);
+    let hasFugitive = await nvim.getVar("loaded_fugitive");
+    if (hasFugitive) {
+      await nvim.command(`Gedit ${commit}`);
+    } else {
+      let content = await this.repo.safeRun(["--no-pager", "show", commit]);
+      if (content == null) return;
+      let lines = content.trim().split("\n");
+      nvim.pauseNotification();
+      nvim.command(`edit +setl\\ buftype=nofile [commit ${commit}]`, true);
+      nvim.command("setl foldmethod=syntax nobuflisted bufhidden=wipe", true);
+      nvim.command("setf git", true);
+      nvim.call("append", [0, lines], true);
+      nvim.command("normal! Gdd", true);
+      nvim.command(`exe 1`, true);
+      await nvim.resumeNotification(false, true);
+    }
+  }
+  async toggleFold() {
+    let { nvim } = import_coc11.workspace;
+    let buf = this.doc.buffer;
+    let win = await nvim.window;
+    let bufnr = buf.id;
+    let doc = import_coc11.workspace.getDocument(bufnr);
+    if (!doc) return;
+    let infos = this.currentSigns;
+    if (!infos || infos.length == 0) {
+      import_coc11.window.showWarningMessage("No changes");
+      return;
+    }
+    let lnums = infos.map((o) => o.lnum);
+    let foldContext = this.config.foldContext;
+    let max = this.doc.lineCount;
+    let ranges = [];
+    let start = null;
+    const addRange = (from, to) => {
+      let s = plus(from, foldContext, max);
+      let e = minus(to, foldContext, 0);
+      if (e - s <= 0) return;
+      ranges.push([s, e]);
+    };
+    for (let i = 1; i <= doc.lineCount; i++) {
+      let fold = lnums.indexOf(i) == -1;
+      if (fold && start == null) {
+        start = i;
+        continue;
+      }
+      if (start != null && !fold) {
+        addRange(start, i - 1);
+        start = null;
+      }
+      if (start != null && fold && i == doc.lineCount) {
+        addRange(start, i);
+      }
+    }
+    let enabled = this.foldEnabled;
+    if (enabled) {
+      this.foldEnabled = false;
+      let cursor = await nvim.eval('getpos(".")');
+      let lnums2 = ranges.map((o) => o[0]);
+      let settings = this.foldSettings;
+      nvim.pauseNotification();
+      for (let lnum of lnums2) {
+        nvim.command(`${lnum}normal! zd`, true);
+      }
+      win.setOption("foldmethod", settings.foldmethod, true);
+      win.setOption("foldenable", settings.foldenable, true);
+      win.setOption("foldlevel", settings.foldlevel, true);
+      nvim.call("setpos", [".", cursor], true);
+      await nvim.resumeNotification();
+    } else {
+      this.foldEnabled = true;
+      let [foldmethod, foldenable, foldlevel] = await nvim.eval("[&foldmethod,&foldenable,&foldlevel]");
+      this.foldSettings = {
+        foldmethod,
+        foldenable: foldenable !== 0,
+        foldlevel
+      };
+      nvim.pauseNotification();
+      win.setOption("foldmethod", "manual", true);
+      nvim.command("silent! normal! zE", true);
+      win.setOption("foldenable", true, true);
+      win.setOption("foldlevel", 0, true);
+      await nvim.resumeNotification();
+      nvim.pauseNotification();
+      for (let r of ranges) {
+        nvim.command(`${r[0]},${r[1]}fold`, true);
+      }
+      await nvim.resumeNotification();
+    }
+  }
+  async toggleGutters(enabled) {
+    this.config.enableGutters = enabled;
+    let { nvim } = import_coc11.workspace;
+    if (!enabled) {
+      nvim.call("sign_unplace", [signGroup, { buffer: this.doc.bufnr }], true);
+      nvim.redrawVim();
+    } else {
+      this.diffs = [];
+      await this.diffDocument(true);
+    }
+  }
+  async parseConflicts() {
+    if (!this.hasConflicts || !this.config.conflict.enabled) return;
+    const lines = this.doc.textDocument.lines;
+    let conflicts = [];
+    let conflict = null;
+    let state = 0 /* Initial */;
+    let mkStartConflict = (index, current) => ({
+      start: index + 1,
+      sep: 0,
+      end: 0,
+      current,
+      incoming: ""
     });
-    this.doc.buffer.getOption("fileencoding").then((encoding) => {
-      this.encoding = encoding;
-    }).catch((_e) => {
+    lines.forEach((line, index) => {
+      switch (state) {
+        case 0 /* Initial */: {
+          const match = line.match(startPattern);
+          if (match) {
+            conflict = mkStartConflict(index, match[1]);
+            state = 1 /* MatchedStart */;
+          }
+          break;
+        }
+        case 2 /* MatchedCommon */:
+        case 1 /* MatchedStart */: {
+          let match = line.match(sepPattern);
+          if (match) {
+            conflict.sep = index + 1;
+            state = 3 /* MatchedSep */;
+          } else {
+            const startMatch = line.match(startPattern);
+            if (startMatch) {
+              conflict = mkStartConflict(index, startMatch[1]);
+              state = 1 /* MatchedStart */;
+            } else if (line.match(endPattern)) {
+              conflict = null;
+              state = 0 /* Initial */;
+            } else if (line.match(commonPattern)) {
+              conflict.common = index + 1;
+              state = 2 /* MatchedCommon */;
+            }
+          }
+          break;
+        }
+        case 3 /* MatchedSep */: {
+          const match = line.match(endPattern);
+          if (match) {
+            conflict.end = index + 1;
+            conflict.incoming = match[1];
+            conflicts.push(conflict);
+            conflict = null;
+            state = 0 /* Initial */;
+          } else {
+            const startMatch = line.match(startPattern);
+            if (startMatch) {
+              conflict = mkStartConflict(index, startMatch[1]);
+              state = 1 /* MatchedStart */;
+            } else if (line.match(sepPattern)) {
+              conflict = null;
+              state = 0 /* Initial */;
+            }
+          }
+          break;
+        }
+      }
     });
-  }
-  get cachedDiffs() {
-    return this.diffs;
-  }
-  async _refresh() {
-    if (this._disposed) return;
-    let release = await this.mutex.acquire();
-    try {
-      await Promise.all([
-        this.diffDocument(),
-        this.loadBlames(),
-        this.parseConflicts()
-      ]);
-    } catch (e) {
-      this.channel.append(`[Error] refresh error ${e.message}`);
+    this.conflicts = conflicts;
+    this.highlightConflicts(conflicts);
+    if (conflicts.length == 0) {
+      this.hasConflicts = false;
     }
-    release();
   }
-  getChunk(line) {
-    if (!this.diffs || this.diffs.length == 0) return void 0;
-    return this.diffs.find((ch) => {
-      let { start, added, removed, changeType } = ch;
-      if (line == 1 && start == 0 && ch.end == 0) {
-        return true;
-      }
-      let end = changeType === "changed" /* Change */ && added.count > removed.count ? ch.end + added.count - removed.count : ch.end;
-      if (start <= line && end >= line) {
-        return true;
+  async highlightConflicts(conflicts) {
+    let buffer = this.doc.buffer;
+    let currentHlGroup = this.config.conflict.currentHlGroup;
+    let incomingHlGroup = this.config.conflict.incomingHlGroup;
+    let commonHlGroup = this.config.conflict.commonHlGroup;
+    let { nvim } = import_coc11.workspace;
+    nvim.pauseNotification();
+    buffer.clearNamespace(this.config.conflictSrcId, 0, -1);
+    const srcId = this.config.conflictSrcId;
+    conflicts.map((conflict) => {
+      let currEnd = conflict.common ? conflict.common - 1 : conflict.sep - 1;
+      let currRange = import_coc11.Range.create(import_coc11.Position.create(conflict.start - 1, 0), import_coc11.Position.create(currEnd, 0));
+      let incomingRange = import_coc11.Range.create(import_coc11.Position.create(conflict.sep, 0), import_coc11.Position.create(conflict.end, 0));
+      buffer.highlightRanges(srcId, currentHlGroup, [currRange]);
+      buffer.highlightRanges(srcId, incomingHlGroup, [incomingRange]);
+      if (conflict.common) {
+        let range = import_coc11.Range.create(import_coc11.Position.create(conflict.common - 1, 0), import_coc11.Position.create(conflict.sep - 1, 0));
+        buffer.highlightRanges(srcId, commonHlGroup, [range]);
       }
-      return false;
     });
+    nvim.resumeNotification(false, true);
   }
-  async chunkUndo() {
-    let line = await import_coc13.workspace.nvim.call("line", ".");
-    let diff = this.getChunk(line);
-    if (!diff) return;
-    let { start, lines, changeType } = diff;
-    let added = lines.filter((s) => s.startsWith("-")).map((s) => s.slice(1));
-    let removeCount = lines.filter((s) => s.startsWith("+")).length;
-    let buf = this.doc.buffer;
-    if (changeType == "delete" /* Delete */) {
-      await buf.setLines(added, { start, end: start, strictIndexing: false });
+  async showDoc(content, filetype = "diff") {
+    if (this.floatFactory) {
+      let docs = [{ content, filetype }];
+      await this.floatFactory.show(docs, this.config.floatConfig);
     } else {
-      await buf.setLines(added, {
-        start: start - 1,
-        end: start - 1 + removeCount,
-        strictIndexing: false
-      });
+      const lines = content.split("\n");
+      import_coc11.workspace.nvim.call("coc#ui#preview_info", [lines, "diff"], true);
     }
   }
-  async chunkStage() {
-    let relpath = toUnixSlash(this.relpath);
-    let line = await import_coc13.workspace.nvim.call("line", ".");
-    let diff = this.getChunk(line);
-    if (!diff) {
-      import_coc13.window.showErrorMessage("Not positioned in git chunk");
-      return;
+  setBufferStatus(status) {
+    let exists = this.gitStatus;
+    if (exists == status) return;
+    this.gitStatus = status;
+    let { nvim } = import_coc11.workspace;
+    let buffer = nvim.createBuffer(this.doc.bufnr);
+    nvim.pauseNotification();
+    buffer.setVar("coc_git_status", status, true);
+    nvim.callTimer("coc#util#do_autocmd", ["CocGitStatusChange"], true);
+    nvim.resumeNotification(false, true);
+  }
+  getSignName(changeType) {
+    switch (changeType) {
+      case "delete" /* Delete */:
+        return "CocGitRemoved";
+      case "add" /* Add */:
+        return "CocGitAdded";
+      case "changed" /* Change */:
+        return "CocGitChanged";
+      case "topdelete":
+        return "CocGitTopRemoved";
+      case "changedelete":
+        return "CocGitChangeRemoved";
     }
-    let head;
-    if (diff.changeType === "add" /* Add */) {
-      head = `@@ -${diff.removed.start + 1},0 +${diff.removed.start + 1},${diff.added.count} @@`;
-    } else if (diff.changeType === "delete" /* Delete */) {
-      head = `@@ -${diff.removed.start},${diff.removed.count} +${diff.removed.start},0 @@`;
-    } else if (diff.changeType === "changed" /* Change */) {
-      head = `@@ -${diff.removed.start},${diff.removed.count} +${diff.removed.start},${diff.added.count} @@`;
+    return "";
+  }
+  get showBlame() {
+    return this.config.addGBlameToVirtualText || this.config.addGBlameToBufferVar;
+  }
+  dispose() {
+    let { nvim } = import_coc11.workspace;
+    let { bufnr } = this.doc;
+    let buffer = nvim.createBuffer(bufnr);
+    buffer.setVar("coc_git_status", "", true);
+    buffer.clearNamespace(this.config.conflictSrcId, 0, -1);
+    nvim.call("sign_unplace", [signGroup, { buffer: bufnr }], true);
+    this.refresh.clear();
+    if (this.config.addGBlameToBufferVar) {
+      buffer.setVar("coc_git_blame", "", true);
     }
-    const lines = [
-      `diff --git a/${relpath} b/${relpath}`,
-      `index 000000..000000 100644`,
-      `--- a/${relpath}`,
-      `+++ b/${relpath}`,
-      head
-    ];
-    lines.push(...diff.lines);
-    lines.push("");
-    try {
-      await this.git.exec(this.repo.root, ["apply", "--cached", "--unidiff-zero", "-"], { input: lines.join("\n") });
-      this.refresh();
-    } catch (e) {
-      this.channel.appendLine(`[Error] ${e.message}`);
+    if (this.config.addGBlameToVirtualText) {
+      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;
   }
-  async chunkUnstage() {
-    let { nvim } = import_coc13.workspace;
-    const { diffs } = this;
-    let line = await nvim.call("line", ".");
-    let adjust = 0;
-    let invalid = false;
-    for (let diff of diffs) {
-      if (diff.end >= line) {
-        if (diff.start <= line && diff.changeType != "delete" /* Delete */) {
-          import_coc13.window.showErrorMessage(`Current line contains unstaged change.`);
-          invalid = true;
-        }
-        break;
-      }
-      adjust -= diff.added.count;
-      adjust += diff.removed.count;
+};
+function plus(val, count, max) {
+  if (!count) return val;
+  val = val + count;
+  return Math.min(max, val);
+}
+function minus(val, count, min) {
+  if (!count) return val;
+  val = val - count;
+  return Math.max(min, val);
+}
+
+// src/model/git.ts
+var cp = __toESM(require("child_process"));
+var import_coc12 = require("coc.nvim");
+var import_iconv_lite = __toESM(require_lib());
+var import_path5 = __toESM(require("path"));
+var Git = class {
+  constructor(gitInfo, channel) {
+    this.gitInfo = gitInfo;
+    this.channel = channel;
+  }
+  async getRepositoryRoot(repositoryPath) {
+    const result = await this.exec(repositoryPath, ["rev-parse", "--show-toplevel"]);
+    let repoRootPath = import_path5.default.normalize(result.stdout.trim());
+    if (process.platform === "win32" && repoRootPath.startsWith("\\") && !process.env.SHELL) {
+      repoRootPath = repoRootPath.replace(/^\\([^\\]*)\\/, "$1:\\");
     }
-    if (invalid) return;
-    line = line + adjust;
-    let stagedDiff = await this.repo.getStagedChunks(this.relpath);
-    let chunks = Object.values(stagedDiff)[0];
-    if (!chunks.length) {
-      import_coc13.window.showErrorMessage(`Staged chunk not found`);
-      return;
+    return repoRootPath;
+  }
+  async exec(cwd, args, options = {}) {
+    options = Object.assign({ cwd }, options || {});
+    return await this._exec(args, options);
+  }
+  stream(cwd, args, options = {}) {
+    options = Object.assign({ cwd }, options || {});
+    return this.spawn(args, options);
+  }
+  async _exec(args, options = {}) {
+    const child = this.spawn(args, options);
+    if (options.input) {
+      child.stdin.end(options.input, "utf8");
     }
-    let chunk = chunks.find((o) => o.add.lnum <= line && o.add.lnum + o.add.count >= line);
-    if (!chunk) {
-      import_coc13.window.showErrorMessage(`Unable to find staged chunk on current line`);
-      return;
+    const bufferResult = await exec2(child, options.cancellationToken);
+    if (options.log !== false && bufferResult.stderr.length > 0) {
+      this.log(`${bufferResult.stderr}
+`);
     }
-    this.channel.appendLine(`[Info] resolved chunk ${JSON.stringify(chunk, null, 2)}`);
-    let patch = createUnstagePatch(this.relpath, chunk);
-    if (!patch) return;
-    try {
-      await this.git.exec(this.repo.root, ["apply", "--cached", "--unidiff-zero", "-"], { input: patch });
-      this.refresh();
-    } catch (e) {
-      import_coc13.window.showErrorMessage(`Unable to apply patch: ${e.message}`);
-      this.channel.appendLine(`[Error] ${e.message}`);
+    let encoding = options.encoding || "utf8";
+    encoding = import_iconv_lite.default.encodingExists(encoding) ? encoding : "utf8";
+    const result = {
+      exitCode: bufferResult.exitCode,
+      stdout: import_iconv_lite.default.decode(bufferResult.stdout, encoding),
+      stderr: bufferResult.stderr
+    };
+    if (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);
+      return Promise.reject(new Error("Failed to execute git"));
     }
+    return result;
   }
-  async nextChunk() {
-    const { diffs } = this;
-    let { nvim } = import_coc13.workspace;
-    if (!diffs || diffs.length == 0) return;
-    let line = await nvim.call("line", ".");
-    for (let diff of diffs) {
-      if (diff.start > line) {
-        await import_coc13.window.moveTo({ line: Math.max(diff.start - 1, 0), character: 0 });
-        return;
-      }
+  spawn(args, options = {}) {
+    if (!options) {
+      options = {};
     }
-    if (await nvim.getOption("wrapscan")) {
-      await import_coc13.window.moveTo({ line: Math.max(diffs[0].start - 1, 0), character: 0 });
+    if (!options.stdio && !options.input) {
+      options.stdio = ["ignore", null, null];
     }
-  }
-  async prevChunk() {
-    const { nvim } = import_coc13.workspace;
-    let { diffs } = this;
-    let line = await nvim.call("line", ".");
-    if (!diffs || diffs.length == 0) return;
-    for (let diff of diffs.slice().reverse()) {
-      if (diff.end < line) {
-        await import_coc13.window.moveTo({ line: Math.max(diff.start - 1, 0), character: 0 });
-        return;
-      }
+    options.env = Object.assign({}, process.env, options.env || {}, {
+      LC_ALL: "en_US.UTF-8",
+      LANG: "en_US.UTF-8"
+    });
+    if (process.platform === "win32") {
+      options.shell = true;
     }
-    if (await nvim.getOption("wrapscan")) {
-      await import_coc13.window.moveTo({ line: Math.max(diffs[diffs.length - 1].start - 1, 0), character: 0 });
+    if (options.log !== false) {
+      this.log(`> git ${args.join(" ")}
+`);
     }
+    return cp.spawn(this.gitInfo.path, args, options);
   }
-  async chunkInfo() {
-    let line = await import_coc13.workspace.nvim.call("line", ".");
-    let diff = this.getChunk(line);
-    if (diff) {
-      let content = diff.head + "\n" + diff.lines.join("\n");
-      await this.showDoc(content, "diff");
-    } else {
-      let chunks;
-      try {
-        let stagedDiff = await this.repo.getStagedChunks(this.relpath);
-        chunks = Object.values(stagedDiff)[0];
-      } catch (e) {
-        return;
-      }
-      if (!chunks.length) {
-        return;
-      }
-      let adjust = 0;
-      for (let diff2 of this.diffs) {
-        if (diff2.end >= line) {
-          break;
-        }
-        adjust -= diff2.added.count;
-        adjust += diff2.removed.count;
-      }
-      line = line + adjust;
-      let chunk = chunks.find((o) => o.add.lnum <= line && o.add.lnum + o.add.count >= line);
-      if (chunk) {
-        let content = "Staged changes\n" + chunk.lines.join("\n");
-        await this.showDoc(content, "diff");
-      }
-    }
+  log(output) {
+    this.channel.append(output);
   }
-  async showBlameInfo(lnum) {
-    let { nvim } = import_coc13.workspace;
-    let { virtualTextSrcId, addGBlameToBufferVar, addGBlameToVirtualText } = this.config;
-    if (!this.showBlame) return;
-    let infos = this.blameInfo;
-    if (!infos) return;
-    let blameText;
-    if (infos.length == 0) {
-      blameText = "File not indexed";
-    } 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}`;
-      } else {
-        blameText = "Not committed yet";
-      }
-    }
-    let buffer = nvim.createBuffer(this.doc.bufnr);
-    let hide_blame = await nvim.getVar("coc_git_hide_blame_virtual_text");
-    if (hide_blame) {
-      buffer.clearNamespace(virtualTextSrcId);
-    } else {
-      if (addGBlameToBufferVar) {
-        nvim.pauseNotification();
-        buffer.setVar("coc_git_blame", blameText, true);
-        nvim.call("coc#util#do_autocmd", ["CocGitStatusChange"], true);
-        nvim.resumeNotification(false, true);
-      }
-      if (addGBlameToVirtualText) {
-        const prefix = this.config.virtualTextPrefix;
-        nvim.pauseNotification();
-        buffer.clearNamespace(virtualTextSrcId);
-        buffer.setVirtualText(virtualTextSrcId, lnum - 1, [[prefix + blameText, "CocCodeLens"]]);
-        nvim.resumeNotification(true, true);
-      }
-    }
+};
+async function exec2(child, cancellationToken) {
+  if (!child.stdout || !child.stderr) {
+    throw new Error("Failed to get stdout or stderr from git process.");
   }
-  async showBlameDoc(lnum) {
-    let indexed = await this.repo.isIndexed(this.relpath);
-    if (!indexed) {
-      import_coc13.window.showWarningMessage("File not indexed");
-    } else if (await this.repo.isShallow()) {
-      import_coc13.window.showWarningMessage("Shallow repository, blame not available");
-    } else {
-      let infos = await this.getBlameInfo([lnum, lnum]);
-      let info = infos.find((o) => lnum >= o.startLnum && lnum <= o.endLnum);
-      if (info && info.author && info.author != "Not Committed Yet") {
-        let blameText = [];
-        blameText.push(`${info.author}, ${info.time}`);
-        blameText.push(`${info.summary}`);
-        blameText.push(`${info.sha.substring(0, 7)}`);
-        await this.showDoc(blameText.join("\n\n"), "text");
-      } else {
-        import_coc13.window.showWarningMessage("Not committed yet");
-      }
-    }
+  if (cancellationToken && cancellationToken.isCancellationRequested) {
+    throw new Error("Cancelled");
   }
-  async diffDocument(force = false) {
-    var _a;
-    let { nvim } = import_coc13.workspace;
-    let revision = this.config.diffRevision;
-    const { bufnr } = this.doc;
-    let content = this.doc.content;
-    let eol = this.doc.textDocument["eol"];
-    const diffs = await this.repo.getDiff(this.relpath, eol ? content : content + "\n", revision, this.encoding || "utf8");
-    if (diffs == null) {
-      if (((_a = this.currentSigns) == null ? void 0 : _a.length) > 0) {
-        this.currentSigns = [];
-        nvim.call("sign_unplace", [signGroup, { buffer: bufnr }], true);
-      }
-      return;
-    }
-    if (equals(diffs, this.diffs)) {
-      return;
-    }
-    this.diffs = diffs;
-    if (!diffs || diffs.length == 0) {
-      this.setBufferStatus("");
-      if (this.config.enableGutters) {
-        nvim.call("sign_unplace", [signGroup, { buffer: bufnr }], true);
-      }
-      this.currentSigns = [];
-    } else {
-      let added = 0;
-      let changed = 0;
-      let removed = 0;
-      let signs = [];
-      for (let diff of diffs) {
-        if (diff.changeType == "add" /* Add */) {
-          added += diff.added.count;
-        } else if (diff.changeType == "delete" /* Delete */) {
-          removed += diff.removed.count;
-        } else if (diff.changeType == "changed" /* Change */) {
-          let [add, remove] = [diff.added.count, diff.removed.count];
-          let min = Math.min(add, remove);
-          changed += min;
-          added += add - min;
-          removed += remove - min;
-        }
-        let { start, end } = diff;
-        for (let i = start; i <= end; i++) {
-          let topdelete = diff.changeType == "delete" /* Delete */ && i == 0;
-          let changedelete = diff.changeType == "changed" /* Change */ && diff.removed.count > diff.added.count && i == end;
-          signs.push({
-            changeType: topdelete ? "topdelete" : changedelete ? "changedelete" : diff.changeType,
-            lnum: topdelete ? 1 : i
-          });
-        }
-        if (diff.changeType == "changed" /* Change */) {
-          let [add, remove] = [diff.added.count, diff.removed.count];
-          if (add > remove) {
-            for (let i = 0; i < add - remove; i++) {
-              signs.push({
-                changeType: "add" /* Add */,
-                lnum: diff.end + 1 + i
-              });
-            }
-          }
+  const disposables = [];
+  const once = (ee, name, fn) => {
+    ee.once(name, fn);
+    disposables.push(import_coc12.Disposable.create(() => ee.removeListener(name, fn)));
+  };
+  const on = (ee, name, fn) => {
+    ee.on(name, fn);
+    disposables.push(import_coc12.Disposable.create(() => ee.removeListener(name, fn)));
+  };
+  let result = Promise.all([
+    new Promise((c, e) => {
+      once(child, "error", cpErrorHandler(e));
+      once(child, "exit", c);
+    }),
+    new Promise((c) => {
+      const buffers = [];
+      on(child.stdout, "data", (b) => buffers.push(b));
+      once(child.stdout, "close", () => c(Buffer.concat(buffers)));
+    }),
+    new Promise((c) => {
+      const buffers = [];
+      on(child.stderr, "data", (b) => buffers.push(b));
+      once(child.stderr, "close", () => c(Buffer.concat(buffers).toString("utf8")));
+    })
+  ]);
+  if (cancellationToken) {
+    const cancellationPromise = new Promise((_, e) => {
+      onceEvent(cancellationToken.onCancellationRequested)(() => {
+        try {
+          child.kill();
+        } catch (err) {
         }
-      }
-      let items = [];
-      if (added) items.push(`+${added}`);
-      if (changed) items.push(`~${changed}`);
-      if (removed) items.push(`-${removed}`);
-      let status = `  ${items.join(" ")} `;
-      this.setBufferStatus(status);
-      this.currentSigns = signs;
-      if (!this.config.realtimeGutters && !force) return;
-      this.updateGutters();
-    }
+        e(new Error("Cancelled"));
+      });
+    });
+    result = Promise.race([result, cancellationPromise]);
   }
-  updateGutters() {
-    if (this._disposed) return;
-    if (!this.config.enableGutters) return;
-    let { nvim } = import_coc13.workspace;
-    let { bufnr } = this.doc;
-    let { signPriority } = this.config;
-    let signs = this.currentSigns;
-    nvim.pauseNotification();
-    nvim.call("sign_unplace", [signGroup, { buffer: bufnr }], true);
-    for (let sign of signs) {
-      let name = this.getSignName(sign.changeType);
-      nvim.call("sign_place", [0, signGroup, name, bufnr, { lnum: sign.lnum, priority: signPriority }], true);
+  try {
+    const [exitCode, stdout, stderr] = await result;
+    return { exitCode, stdout, stderr };
+  } finally {
+    (0, import_coc12.disposeAll)(disposables);
+  }
+}
+
+// src/model/repo.ts
+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);
+}
+
+// node_modules/uuid/dist/esm-node/bytesToUuid.js
+var byteToHex = [];
+for (i = 0; i < 256; ++i) {
+  byteToHex[i] = (i + 256).toString(16).substr(1);
+}
+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("");
+}
+var bytesToUuid_default = bytesToUuid;
+
+// node_modules/uuid/dist/esm-node/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;
+  }
+  options = options || {};
+  var rnds = options.random || (options.rng || rng)();
+  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];
     }
-    nvim.resumeNotification(false, true);
   }
-  async loadBlames() {
-    if (!this.showBlame) return;
-    let result = [];
-    let indexed = await this.repo.isIndexed(this.relpath);
-    if (indexed) result = await this.getBlameInfo();
-    this.blameInfo = result;
+  return buf || bytesToUuid_default(rnds);
+}
+var v4_default = v4;
+
+// src/model/repo.ts
+var Repo = class {
+  constructor(git, channel, root) {
+    this.git = git;
+    this.channel = channel;
+    this.root = root;
   }
-  async getBlameInfo(range) {
-    let { relpath } = this;
-    let root = this.repo.root;
-    let res = [];
-    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];
-      if (range) args.push("-L", range.join(","));
-      let r = await this.git.exec(root, args, {
-        log: false,
-        input: this.doc.content
-      });
-      if (!r.stdout) return res;
-      let info;
-      for (let line of r.stdout.trim().split(/\r?\n/)) {
-        line = line.trim();
-        if (/^(author |committer )?External file \(--contents\)/.test(line)) {
-          line = "Not committed yet.";
+  /**
+   * 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));
+    const result = await this.exec(args);
+    if (!result.stdout) {
+      throw new Error(`No staged result.`);
+    }
+    let res = {};
+    let idx = 0;
+    let lines = result.stdout.split(/\r?\n/);
+    let curr;
+    let fsPath;
+    while (idx < lines.length) {
+      let line = lines[idx];
+      if (fsPath && line.startsWith("@@")) {
+        curr = void 0;
+        let ms = line.match(/^@@\s+-(\d+),?(\d*)\s+\+(\d+),?(\d*)\s+@@/);
+        if (ms) {
+          curr = {
+            remove: { lnum: Number(ms[1]), count: ms[2] ? Number(ms[2]) : 1 },
+            add: { lnum: Number(ms[3]), count: ms[4] ? Number(ms[4]) : 1 },
+            lines: []
+          };
+          res[fsPath] = res[fsPath] || [];
+          res[fsPath].push(curr);
         }
-        let ms = line.match(/^([A-Za-z0-9]+)\s(\d+)\s(\d+)\s(\d+)/);
+      } 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) {
-          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]);
-            if (find) {
-              info.author = find.author;
-              info.time = find.time;
-              info.summary = find.summary;
-            }
-          }
-          res.push(info);
-        } else if (info) {
-          if (line.startsWith("author ")) {
-            let author = line.replace(/^author/, "").trim();
-            info.author = author == currentAuthor ? "You" : author;
-          } else if (line.startsWith("author-time ")) {
-            let text = line.replace(/^author-time/, "").trim();
-            const timestamps = parseInt(text, 10) * 1e3;
-            info.time = useRealTime ? new Date(timestamps).toLocaleString() : format(timestamps, process.env.LANG);
-          } else if (line.startsWith("summary ")) {
-            let text = line.replace(/^summary/, "").trim();
-            info.summary = text;
-          }
+          fsPath = ms[1];
+          curr = void 0;
+          idx += 4;
+          continue;
         }
       }
-      return res;
-    } catch (e) {
-      this.channel.appendLine(e.stack);
+      idx++;
     }
     return res;
   }
-  async diffCached() {
-    let res = await this.repo.safeRun(["diff", "--cached"]);
-    if (!res.trim()) {
-      import_coc13.window.showWarningMessage("Empty diff");
-      return;
-    }
-    let { nvim } = import_coc13.workspace;
-    nvim.pauseNotification();
-    nvim.command(`keepalt above new +setl\\ previewwindow`, true);
-    nvim.call("append", [0, res.split(/\r?\n/)], true);
-    nvim.command("normal! Gdd", true);
-    nvim.command(`exe 1`, true);
-    nvim.command("setfiletype git", true);
-    nvim.command("setl buftype=nofile nomodifiable bufhidden=wipe nobuflisted", true);
-    await nvim.resumeNotification();
-  }
-  async nextConflict() {
-    let { nvim } = import_coc13.workspace;
-    if (!this.conflicts.length) {
-      import_coc13.window.showWarningMessage("No conflicts detected");
-      return;
-    }
-    let line = await nvim.call("line", ".");
-    for (let conflict of this.conflicts) {
-      if (conflict.start > line) {
-        await import_coc13.window.moveTo({ line: Math.max(conflict.start - 1, 0), character: 0 });
-        return;
+  async getHEAD() {
+    try {
+      const result = await this.exec(["symbolic-ref", "--short", "HEAD"]);
+      if (!result.stdout) {
+        throw new Error("Not in a branch");
       }
-    }
-    if (await nvim.getOption("wrapscan")) {
-      await import_coc13.window.moveTo({ line: Math.max(this.conflicts[0].start - 1, 0), character: 0 });
-    }
-  }
-  async prevConflict() {
-    let { nvim } = import_coc13.workspace;
-    if (!this.conflicts.length) {
-      import_coc13.window.showWarningMessage("No conflicts detected", "warning");
-      return;
-    }
-    let line = await nvim.call("line", ".");
-    for (let conflict of this.conflicts) {
-      if (conflict.start > line) {
-        await import_coc13.window.moveTo({ line: Math.max(conflict.start - 1, 0), character: 0 });
-        return;
+      return result.stdout.trim();
+    } catch (err) {
+      const result = await this.exec(["rev-parse", "HEAD"]);
+      if (!result.stdout) {
+        throw new Error("Error parsing HEAD");
       }
-    }
-    if (await nvim.getOption("wrapscan")) {
-      await import_coc13.window.moveTo({ line: Math.max(this.conflicts[0].start - 1, 0), character: 0 });
+      return result.stdout.trim();
     }
   }
-  async conflictKeepPart(part) {
-    const { nvim } = import_coc13.workspace;
-    let conflicts = this.conflicts;
-    if (!conflicts || conflicts.length == 0) {
-      import_coc13.window.showWarningMessage("No conflicts detected");
-      return;
-    }
-    let line = await nvim.call("line", ".");
-    for (let conflict of conflicts) {
-      if (conflict.start <= line && conflict.end >= line) {
-        switch (part) {
-          case 0 /* Current */:
-            let start = conflict.common ? conflict.common : conflict.sep;
-            await nvim.command(`${start},${conflict.end}d | ${conflict.start}d`);
-            return;
-          case 1 /* Incoming */:
-            await nvim.command(`${conflict.end}d | ${conflict.start},${conflict.sep}d`);
-            return;
-          case 2 /* Both */:
-            if (conflict.common) {
-              await nvim.command(`${conflict.end}d | ${conflict.common},${conflict.sep}d | ${conflict.start}d`);
-            } else {
-              await nvim.command(`${conflict.end}d | ${conflict.sep}d | ${conflict.start}d`);
-            }
-            return;
-        }
-      }
-    }
-    import_coc13.window.showWarningMessage("Not positioned on a conflict");
+  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"));
   }
-  async browser(action = "open", range, permalink = false) {
-    let { nvim } = import_coc13.workspace;
-    let config = import_coc13.workspace.getConfiguration("git");
-    let head = (await this.repo.safeRun(["rev-parse", "HEAD"])).trim();
-    let branch = config.get("browserBranchName", "").trim();
-    if (!branch.length) {
-      branch = (await this.repo.safeRun(["symbolic-ref", "--short", "-q", "HEAD"])).trim();
-    }
-    let lines = range && range.length == 2 ? [
-      range[0],
-      range[1]
-    ] : [await nvim.eval('line(".")')];
-    if (this.doc.filetype == "markdown") {
-      let line = await nvim.call("getline", ["."]);
-      if (line.startsWith("#")) {
-        let words = line.replace(/^#+\s*/, "").split(/\s+/);
-        lines = words.map((s) => s.toLowerCase()).join("-");
+  async getStaged() {
+    let result = await this.exec(["diff", "--staged", "--name-status"]);
+    if (!result.stdout) return [0, 0];
+    let lines = result.stdout.trim().split(/\r?\n/);
+    let conflicted = 0;
+    let staged = 0;
+    lines.forEach((line) => {
+      if (!line.length) return;
+      if (line.startsWith("U")) {
+        conflicted++;
+      } else {
+        staged++;
       }
+    });
+    return [conflicted, staged];
+  }
+  async hasUntracked() {
+    let cp2 = this.git.stream(this.root, ["ls-files", "--others", "--exclude-standard"]);
+    return new Promise((resolve) => {
+      let hasData = false;
+      let timer = setTimeout(() => {
+        if (cp2.killed) return;
+        cp2.kill("SIGKILL");
+        resolve(false);
+      }, 100);
+      cp2.stdout.on("data", () => {
+        clearTimeout(timer);
+        hasData = true;
+        cp2.kill("SIGKILL");
+        resolve(hasData);
+      });
+      cp2.on("exit", () => {
+        clearTimeout(timer);
+        resolve(hasData);
+      });
+    });
+  }
+  async getStatus(character, decorator) {
+    try {
+      let head = await this.getHEAD();
+      if (!head) return "";
+      let [changed, staged, untracked] = await Promise.all([this.hasChanged(), this.getStaged(), this.hasUntracked()]);
+      const { changedDecorator, conflictedDecorator, stagedDecorator, untrackedDecorator } = decorator;
+      let more = "";
+      if (changed) more += changedDecorator;
+      if (staged[0]) more += conflictedDecorator;
+      if (staged[1]) more += stagedDecorator;
+      if (untracked) more += untrackedDecorator;
+      return `${character ? character + " " : ""}${head}${more}`;
+    } catch (e) {
+      this.channel.appendLine("Error on git status");
+      this.channel.append(e.message);
+      return "";
     }
-    let output = await this.repo.safeRun(["remote"]);
-    if (!output.trim()) {
-      import_coc13.window.showWarningMessage(`No remote found`);
+  }
+  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);
       return;
     }
-    let names = output.trim().split(/\r?\n/);
-    let browserRemoteName = config.get("browserRemoteName", "").trim();
-    if (browserRemoteName.length > 0) {
-      if (names.includes(browserRemoteName)) {
-        names = [browserRemoteName];
-      } else {
-        import_coc13.window.showWarningMessage("Configured git.browserRemoteName missing from remote list");
-        return;
-      }
-    }
-    let urls = [];
-    for (let name of names) {
-      let uri = await this.repo.safeRun(["config", "--get", `remote.${name}.url`]);
-      if (!uri.length) continue;
-      let repoURL = getRepoUrl(uri);
-      if (!repoURL) continue;
-      let tmp = new import_url.URL(repoURL);
-      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);
-      if (url) urls.push(url);
+    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);
+    if (!output) return [];
+    this.channel.appendLine(`> git diff ${relFilepath}`);
+    const lines = output.trim().split("\n");
+    return parseDiff(lines);
+  }
+  async getDiffAll(category) {
+    let diffGroups = /* @__PURE__ */ new Map();
+    let args = "";
+    if (category === 0 /* All */) {
+      args = "HEAD";
+    } else if (category === 1 /* Staged */) {
+      args = "--cached";
+    } else {
+      args = "";
     }
-    if (urls.length == 1) {
-      if (action == "open") {
-        await import_coc13.workspace.openResource(urls[0]);
-      } else {
-        nvim.command(`let @+ = '${urls[0]}'`, true);
-        import_coc13.window.showInformationMessage("Copied url to clipboard");
-      }
-    } else if (urls.length > 1) {
-      let url = await import_coc13.window.showQuickPick(urls, { canPickMany: false, title: "Pick remote url" });
-      if (url) {
-        if (action == "open") {
-          await import_coc13.workspace.openResource(url);
+    let output = await getStdout(`git --no-pager diff --no-ext-diff -p -U0 --no-color ${args}`);
+    if (!output) return diffGroups;
+    const lines = output.trim().split("\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 {
-          nvim.command(`let @+ = '${url}'`, true);
-          nvim.command(`let @* = '${url}'`, true);
-          import_coc13.window.showInformationMessage("Copied url to clipboard");
+          file = null;
         }
       }
+      if (file) {
+        if (!lineGroups.has(file)) {
+          lineGroups.set(file, []);
+        }
+        lineGroups.get(file).push(line);
+      }
     }
-  }
-  // show commit of current line in split window
-  async showCommit() {
-    let indexed = await this.repo.isIndexed(this.relpath);
-    if (!indexed) {
-      import_coc13.window.showWarningMessage(`"${this.relpath}" not indexed.`);
-      return;
-    }
-    let nvim = import_coc13.workspace.nvim;
-    let line = await nvim.eval('line(".")');
-    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;
-    let commit = output.match(/^\S+/)[0];
-    if (/^0+$/.test(commit)) {
-      import_coc13.window.showWarningMessage("not committed yet!");
-      return;
+    for (const [file2, lines2] of lineGroups) {
+      let diffs = parseDiff(lines2);
+      if (diffs) {
+        diffGroups.set(file2, diffs);
+      }
     }
-    let useFloating = this.config.showCommitInFloating;
-    if (useFloating) {
-      let content = await this.repo.safeRun(["--no-pager", "show", commit]);
-      if (content == null) return;
-      await this.showDoc(content.trim());
-      return;
+    return diffGroups;
+  }
+  async isIgnored(relativePath) {
+    let res = await this.safeRun(["check-ignore", "--", relativePath]);
+    return res.trim() == relativePath;
+  }
+  async hasConflicts(relativePath) {
+    let indexed = await this.isIndexed(relativePath);
+    if (!indexed) return false;
+    let res = await this.exec(["diff", "--staged", "--name-status", "--", relativePath]);
+    return res.stdout.trim().startsWith("U");
+  }
+  async isIndexed(relpath) {
+    let res = await this.exec(["ls-files", "--", relpath]);
+    return res.stdout && res.stdout.trim().length > 0;
+  }
+  async getUsername() {
+    if (typeof this.userName === "string") return this.userName;
+    try {
+      let res = await this.exec(["config", "user.name"]);
+      this.userName = res.stdout.trim();
+      return this.userName;
+    } catch (e) {
+      this.userName = "";
+      return "";
     }
-    await nvim.command(`keepalt above ${this.config.splitWindowCommand}`);
-    let hasFugitive = await nvim.getVar("loaded_fugitive");
-    if (hasFugitive) {
-      await nvim.command(`Gedit ${commit}`);
-    } else {
-      let content = await this.repo.safeRun(["--no-pager", "show", commit]);
-      if (content == null) return;
-      let lines = content.trim().split("\n");
-      nvim.pauseNotification();
-      nvim.command(`edit +setl\\ buftype=nofile [commit ${commit}]`, true);
-      nvim.command("setl foldmethod=syntax nobuflisted bufhidden=wipe", true);
-      nvim.command("setf git", true);
-      nvim.call("append", [0, lines], true);
-      nvim.command("normal! Gdd", true);
-      nvim.command(`exe 1`, true);
-      await nvim.resumeNotification(false, true);
+  }
+  async isShallow() {
+    try {
+      let res = await this.exec(["rev-parse", "--is-shallow-repository"]);
+      return res.stdout.trim() === "true";
+    } catch (e) {
+      return false;
     }
   }
-  async toggleFold() {
-    let { nvim } = import_coc13.workspace;
-    let buf = this.doc.buffer;
-    let win = await nvim.window;
-    let bufnr = buf.id;
-    let doc = import_coc13.workspace.getDocument(bufnr);
-    if (!doc) return;
-    let infos = this.currentSigns;
-    if (!infos || infos.length == 0) {
-      import_coc13.window.showWarningMessage("No changes");
-      return;
+  async exec(args, options = {}) {
+    return await this.git.exec(this.root, args, options);
+  }
+  async safeRun(args, options = {}) {
+    try {
+      let res = await this.exec(args, options);
+      return res ? res.stdout.replace(/\s*$/, "") : "";
+    } catch (e) {
+      return "";
     }
-    let lnums = infos.map((o) => o.lnum);
-    let foldContext = this.config.foldContext;
-    let max = this.doc.lineCount;
-    let ranges = [];
-    let start = null;
-    const addRange = (from, to) => {
-      let s = plus(from, foldContext, max);
-      let e = minus(to, foldContext, 0);
-      if (e - s <= 0) return;
-      ranges.push([s, e]);
-    };
-    for (let i = 1; i <= doc.lineCount; i++) {
-      let fold = lnums.indexOf(i) == -1;
-      if (fold && start == null) {
-        start = i;
-        continue;
-      }
-      if (start != null && !fold) {
-        addRange(start, i - 1);
-        start = null;
-      }
-      if (start != null && fold && i == doc.lineCount) {
-        addRange(start, i);
+  }
+};
+function parseDiff(diffLines) {
+  const allLines = diffLines.slice(4);
+  const diffs = [];
+  let diff = null;
+  for (const line of allLines) {
+    if (!line.startsWith("@@")) {
+      if (diff) {
+        diff.lines.push(line);
       }
+      continue;
     }
-    let enabled = this.foldEnabled;
-    if (enabled) {
-      this.foldEnabled = false;
-      let cursor = await nvim.eval('getpos(".")');
-      let lnums2 = ranges.map((o) => o[0]);
-      let settings = this.foldSettings;
-      nvim.pauseNotification();
-      for (let lnum of lnums2) {
-        nvim.command(`${lnum}normal! zd`, true);
-      }
-      win.setOption("foldmethod", settings.foldmethod, true);
-      win.setOption("foldenable", settings.foldenable, true);
-      win.setOption("foldlevel", settings.foldlevel, true);
-      nvim.call("setpos", [".", cursor], true);
-      await nvim.resumeNotification();
-    } else {
-      this.foldEnabled = true;
-      let [foldmethod, foldenable, foldlevel] = await nvim.eval("[&foldmethod,&foldenable,&foldlevel]");
-      this.foldSettings = {
-        foldmethod,
-        foldenable: foldenable !== 0,
-        foldlevel
+    let diffKey = line.split("@@", 2)[1].trim();
+    const [pres, nows] = diffKey.split(/\s+/).map((str) => str.slice(1).split(","));
+    const removed = {
+      start: parseInt(pres[0], 10),
+      count: parseInt(`${pres[1] || 1}`, 10)
+    };
+    const added = {
+      start: parseInt(nows[0], 10),
+      count: parseInt(`${nows[1] || 1}`, 10)
+    };
+    if (added.count === 0) {
+      diff = {
+        lines: [],
+        start: added.start,
+        end: added.start,
+        head: line,
+        removed,
+        added,
+        changeType: "delete" /* Delete */
+      };
+      diffs.push(diff);
+    } else if (removed.count === 0) {
+      diff = {
+        lines: [],
+        start: added.start,
+        end: added.start + added.count - 1,
+        head: line,
+        removed,
+        added,
+        changeType: "add" /* Add */
       };
-      nvim.pauseNotification();
-      win.setOption("foldmethod", "manual", true);
-      nvim.command("silent! normal! zE", true);
-      win.setOption("foldenable", true, true);
-      win.setOption("foldlevel", 0, true);
-      await nvim.resumeNotification();
-      nvim.pauseNotification();
-      for (let r of ranges) {
-        nvim.command(`${r[0]},${r[1]}fold`, true);
-      }
-      await nvim.resumeNotification();
+      diffs.push(diff);
+    } else {
+      diff = {
+        lines: [],
+        start: added.start,
+        end: added.start + Math.min(added.count, removed.count) - 1,
+        head: line,
+        removed,
+        added,
+        changeType: "changed" /* Change */
+      };
+      diffs.push(diff);
     }
   }
-  async toggleGutters(enabled) {
-    this.config.enableGutters = enabled;
-    let { nvim } = import_coc13.workspace;
-    if (!enabled) {
-      nvim.call("sign_unplace", [signGroup, { buffer: this.doc.bufnr }], true);
-    } else {
-      this.diffs = [];
-      await this.diffDocument(true);
+  return diffs;
+}
+
+// src/model/resolver.ts
+var import_coc13 = require("coc.nvim");
+var import_fs3 = __toESM(require("fs"));
+var import_path7 = __toESM(require("path"));
+var import_util10 = require("util");
+async function getRealPath(fullpath) {
+  let resolved;
+  try {
+    resolved = await (0, import_util10.promisify)(import_fs3.default.realpath)(fullpath, "utf8");
+  } catch (e) {
+    if (e.message.includes("ENOENT")) {
+      try {
+        resolved = await import_coc13.workspace.nvim.call("expand", [fullpath]);
+      } catch (e2) {
+      }
     }
   }
-  async parseConflicts() {
-    if (!this.hasConflicts || !this.config.conflict.enabled) return;
-    const lines = this.doc.textDocument.lines;
-    let conflicts = [];
-    let conflict = null;
-    let state = 0 /* Initial */;
-    let mkStartConflict = (index, current) => ({
-      start: index + 1,
-      sep: 0,
-      end: 0,
-      current,
-      incoming: ""
-    });
-    lines.forEach((line, index) => {
-      switch (state) {
-        case 0 /* Initial */: {
-          const match = line.match(startPattern);
-          if (match) {
-            conflict = mkStartConflict(index, match[1]);
-            state = 1 /* MatchedStart */;
-          }
-          break;
-        }
-        case 2 /* MatchedCommon */:
-        case 1 /* MatchedStart */: {
-          let match = line.match(sepPattern);
-          if (match) {
-            conflict.sep = index + 1;
-            state = 3 /* MatchedSep */;
-          } else {
-            const startMatch = line.match(startPattern);
-            if (startMatch) {
-              conflict = mkStartConflict(index, startMatch[1]);
-              state = 1 /* MatchedStart */;
-            } else if (line.match(endPattern)) {
-              conflict = null;
-              state = 0 /* Initial */;
-            } else if (line.match(commonPattern)) {
-              conflict.common = index + 1;
-              state = 2 /* MatchedCommon */;
-            }
-          }
-          break;
-        }
-        case 3 /* MatchedSep */: {
-          const match = line.match(endPattern);
-          if (match) {
-            conflict.end = index + 1;
-            conflict.incoming = match[1];
-            conflicts.push(conflict);
-            conflict = null;
-            state = 0 /* Initial */;
+  return resolved || fullpath;
+}
+var Resolver = class {
+  constructor(git, channel) {
+    this.git = git;
+    this.channel = channel;
+    this.resolvedRoots = /* @__PURE__ */ new Map();
+    this.relativePaths = /* @__PURE__ */ new Map();
+  }
+  delete(uri) {
+    this.resolvedRoots.delete(uri);
+    this.relativePaths.delete(uri);
+  }
+  clear() {
+    this.resolvedRoots.clear();
+    this.relativePaths.clear();
+  }
+  getRelativePath(uri) {
+    return this.relativePaths.get(uri);
+  }
+  async resolveGitRoot(doc) {
+    if (!doc) return null;
+    let root;
+    const { uri } = doc;
+    root = this.resolvedRoots.get(uri);
+    if (root) return root;
+    if (doc.buftype == "acwrite") {
+      root = await this.resolveRootFromCwd();
+      this.resolvedRoots.set(uri, root);
+      return root;
+    }
+    if (doc.buftype != "" || doc.schema != "file") {
+      return null;
+    }
+    let fullpath = await getRealPath(import_coc13.Uri.parse(uri).fsPath);
+    if (process.platform == "win32") {
+      fullpath = import_path7.default.win32.normalize(fullpath);
+    }
+    if (!root) {
+      let parts = fullpath.split(import_path7.default.sep);
+      let idx = parts.indexOf(".git");
+      if (idx !== -1) {
+        root = parts.slice(0, idx).join(import_path7.default.sep);
+        this.resolvedRoots.set(uri, root);
+      } else {
+        try {
+          let stat = import_fs3.default.statSync(fullpath);
+          let dir = stat.isDirectory() ? fullpath : import_path7.default.dirname(fullpath);
+          root = await this.git.getRepositoryRoot(dir);
+          if (import_path7.default.isAbsolute(root)) {
+            this.resolvedRoots.set(uri, root);
           } else {
-            const startMatch = line.match(startPattern);
-            if (startMatch) {
-              conflict = mkStartConflict(index, startMatch[1]);
-              state = 1 /* MatchedStart */;
-            } else if (line.match(sepPattern)) {
-              conflict = null;
-              state = 0 /* Initial */;
-            }
+            root = void 0;
           }
-          break;
+        } catch (e) {
         }
       }
-    });
-    this.conflicts = conflicts;
-    this.highlightConflicts(conflicts);
-    if (conflicts.length == 0) {
-      this.hasConflicts = false;
     }
-  }
-  async highlightConflicts(conflicts) {
-    let buffer = this.doc.buffer;
-    let currentHlGroup = this.config.conflict.currentHlGroup;
-    let incomingHlGroup = this.config.conflict.incomingHlGroup;
-    let commonHlGroup = this.config.conflict.commonHlGroup;
-    let { nvim } = import_coc13.workspace;
-    nvim.pauseNotification();
-    buffer.clearNamespace(this.config.conflictSrcId, 0, -1);
-    const srcId = this.config.conflictSrcId;
-    conflicts.map((conflict) => {
-      let currEnd = conflict.common ? conflict.common - 1 : conflict.sep - 1;
-      let currRange = import_coc13.Range.create(import_coc13.Position.create(conflict.start - 1, 0), import_coc13.Position.create(currEnd, 0));
-      let incomingRange = import_coc13.Range.create(import_coc13.Position.create(conflict.sep, 0), import_coc13.Position.create(conflict.end, 0));
-      buffer.highlightRanges(srcId, currentHlGroup, [currRange]);
-      buffer.highlightRanges(srcId, incomingHlGroup, [incomingRange]);
-      if (conflict.common) {
-        let range = import_coc13.Range.create(import_coc13.Position.create(conflict.common - 1, 0), import_coc13.Position.create(conflict.sep - 1, 0));
-        buffer.highlightRanges(srcId, commonHlGroup, [range]);
-      }
-    });
-    nvim.resumeNotification(false, true);
-  }
-  async showDoc(content, filetype = "diff") {
-    if (this.floatFactory) {
-      let docs = [{ content, filetype }];
-      await this.floatFactory.show(docs, this.config.floatConfig);
-    } else {
-      const lines = content.split("\n");
-      import_coc13.workspace.nvim.call("coc#ui#preview_info", [lines, "diff"], true);
+    if (root) {
+      this.relativePaths.set(uri, import_path7.default.relative(root, fullpath));
     }
+    this.channel.appendLine(`resolved root of ${fullpath}: ${root}`);
+    return root;
   }
-  setBufferStatus(status) {
-    let exists = this.gitStatus;
-    if (exists == status) return;
-    this.gitStatus = status;
-    let { nvim } = import_coc13.workspace;
-    let buffer = nvim.createBuffer(this.doc.bufnr);
-    nvim.pauseNotification();
-    buffer.setVar("coc_git_status", status, true);
-    nvim.call("coc#util#do_autocmd", ["CocGitStatusChange"], true);
-    nvim.resumeNotification(false, true);
-  }
-  getSignName(changeType) {
-    switch (changeType) {
-      case "delete" /* Delete */:
-        return "CocGitRemoved";
-      case "add" /* Add */:
-        return "CocGitAdded";
-      case "changed" /* Change */:
-        return "CocGitChanged";
-      case "topdelete":
-        return "CocGitTopRemoved";
-      case "changedelete":
-        return "CocGitChangeRemoved";
+  async resolveRootFromCwd() {
+    let parts = import_coc13.workspace.cwd.split(import_path7.default.sep);
+    let idx = parts.indexOf(".git");
+    if (idx !== -1) return parts.slice(0, idx).join(import_path7.default.sep);
+    try {
+      return await this.git.getRepositoryRoot(import_coc13.workspace.cwd);
+    } catch (e) {
     }
-    return "";
-  }
-  get showBlame() {
-    return this.config.addGBlameToVirtualText || this.config.addGBlameToBufferVar;
+    return null;
   }
   dispose() {
-    let { nvim } = import_coc13.workspace;
-    let { bufnr } = this.doc;
-    let buffer = nvim.createBuffer(bufnr);
-    buffer.setVar("coc_git_status", "", true);
-    buffer.clearNamespace(this.config.conflictSrcId, 0, -1);
-    nvim.call("sign_unplace", [signGroup, { buffer: bufnr }], true);
-    if (this.config.addGBlameToBufferVar) {
-      buffer.setVar("coc_git_blame", "", true);
-    }
-    if (this.config.addGBlameToVirtualText) {
-      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;
+    this.resolvedRoots.clear();
+    this.relativePaths.clear();
   }
 };
-function plus(val, count, max) {
-  if (!count) return val;
-  val = val + count;
-  return Math.min(max, val);
-}
-function minus(val, count, min) {
-  if (!count) return val;
-  val = val - count;
-  return Math.max(min, val);
-}
 
 // src/model/service.ts
-var import_path8 = __toESM(require("path"));
+var uriToRoot = /* @__PURE__ */ new Map();
 var GitService = class {
   constructor(gitInfo) {
     this.repos = /* @__PURE__ */ new Map();
@@ -7567,6 +7562,7 @@ var GitService = class {
     }
   }
   getRepoFromRoot(root) {
+    if (!root) return void 0;
     if (this.repos.has(root)) {
       return this.repos.get(root);
     }
@@ -7583,13 +7579,23 @@ var GitService = class {
     if (!relpath) return void 0;
     let ignored = await repo.isIgnored(relpath);
     if (ignored) return void 0;
-    return new GitBuffer(doc, config, relpath, repo, this.git, this.outputChannel, this.floatFactory);
+    uriToRoot.set(doc.uri, root);
+    let hasConflicts = await repo.hasConflicts(relpath);
+    return new GitBuffer(doc, config, relpath, repo, this.git, this.outputChannel, this.floatFactory, hasConflicts);
   }
   async getCurrentRepo() {
-    let { nvim } = import_coc14.workspace;
-    let [fullpath, buftype] = await nvim.eval('[expand("%:p"),&buftype]');
-    if (!import_path8.default.isAbsolute(fullpath) || buftype != "") return void 0;
-    let root = await this.resolver.resolveGitRoot({ uri: import_coc14.Uri.file(fullpath).toString(), schema: "file", buftype: "" });
+    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);
+      }
+    } else {
+      let cwd = import_coc14.workspace.cwd;
+      root = await this.resolver.resolveGitRoot({ uri: import_coc14.Uri.file(cwd).toString(), schema: "file", buftype: "" });
+    }
     if (root == null) return void 0;
     return this.getRepoFromRoot(root);
   }
@@ -7906,7 +7912,7 @@ async function activate(context) {
   let gitInfo;
   try {
     let pathHint = config.get("command", "git");
-    gitInfo = await findGit(pathHint, (path9) => context.logger.info(`Looking for git in: ${path9}`));
+    gitInfo = await findGit(pathHint, (path8) => context.logger.info(`Looking for git in: ${path8}`));
   } catch (e) {
     import_coc16.window.showErrorMessage("git command required for coc-git");
     return;