coc-git 2.7.10 → 2.7.12

package/lib/index.js

@@ -695,8 +695,8 @@ var require_windows = __commonJS({
   "node_modules/isexe/windows.js"(exports2, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs5 = require("fs");
-    function checkPathExt(path9, options) {
+    var fs6 = require("fs");
+    function checkPathExt(path10, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
         return true;
@@ -707,25 +707,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 && path10.substr(-p.length).toLowerCase() === p) {
           return true;
         }
       }
       return false;
     }
-    function checkStat(stat, path9, options) {
+    function checkStat(stat, path10, options) {
       if (!stat.isSymbolicLink() && !stat.isFile()) {
         return false;
       }
-      return checkPathExt(path9, options);
+      return checkPathExt(path10, options);
     }
-    function isexe(path9, options, cb) {
-      fs5.stat(path9, function(er, stat) {
-        cb(er, er ? false : checkStat(stat, path9, options));
+    function isexe(path10, options, cb) {
+      fs6.stat(path10, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, path10, options));
       });
     }
-    function sync(path9, options) {
-      return checkStat(fs5.statSync(path9), path9, options);
+    function sync(path10, options) {
+      return checkStat(fs6.statSync(path10), path10, options);
     }
   }
 });
@@ -735,14 +735,14 @@ var require_mode = __commonJS({
   "node_modules/isexe/mode.js"(exports2, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs5 = require("fs");
-    function isexe(path9, options, cb) {
-      fs5.stat(path9, function(er, stat) {
+    var fs6 = require("fs");
+    function isexe(path10, options, cb) {
+      fs6.stat(path10, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
-    function sync(path9, options) {
-      return checkStat(fs5.statSync(path9), options);
+    function sync(path10, options) {
+      return checkStat(fs6.statSync(path10), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -766,7 +766,7 @@ var require_mode = __commonJS({
 // node_modules/isexe/index.js
 var require_isexe = __commonJS({
   "node_modules/isexe/index.js"(exports2, module2) {
-    var fs5 = require("fs");
+    var fs6 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -775,7 +775,7 @@ var require_isexe = __commonJS({
     }
     module2.exports = isexe;
     isexe.sync = sync;
-    function isexe(path9, options, cb) {
+    function isexe(path10, options, cb) {
       if (typeof options === "function") {
         cb = options;
         options = {};
@@ -785,7 +785,7 @@ var require_isexe = __commonJS({
           throw new TypeError("callback not provided");
         }
         return new Promise(function(resolve, reject) {
-          isexe(path9, options || {}, function(er, is) {
+          isexe(path10, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
@@ -794,7 +794,7 @@ var require_isexe = __commonJS({
           });
         });
       }
-      core(path9, options || {}, function(er, is) {
+      core(path10, options || {}, function(er, is) {
         if (er) {
           if (er.code === "EACCES" || options && options.ignoreErrors) {
             er = null;
@@ -804,9 +804,9 @@ var require_isexe = __commonJS({
         cb(er, is);
       });
     }
-    function sync(path9, options) {
+    function sync(path10, options) {
       try {
-        return core.sync(path9, options || {});
+        return core.sync(path10, options || {});
       } catch (er) {
         if (options && options.ignoreErrors || er.code === "EACCES") {
           return false;
@@ -822,7 +822,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 path10 = require("path");
     var COLON = isWindows ? ";" : ":";
     var isexe = require_isexe();
     var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -860,7 +860,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 = path10.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         resolve(subStep(p, i, 0));
       });
@@ -887,7 +887,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 = path10.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];
@@ -4537,7 +4537,7 @@ __export(index_exports, {
   formatBlameText: () => formatBlameText
 });
 module.exports = __toCommonJS(index_exports);
-var import_coc18 = require("coc.nvim");
+var import_coc19 = require("coc.nvim");
 
 // src/constants.ts
 var DEFAULT_TYPES = [
@@ -4673,12 +4673,12 @@ var Bcommits = class extends import_coc.BasicList {
     }, { tabPersist: true });
     this.addAction("view", async (item, context) => {
       let { commit, root, file } = item.data;
-      let { window: window12 } = context;
+      let { window: window13 } = context;
       let content = (await this.manager.git.exec(root, ["show", `${commit}:${file}`])).stdout;
       let lines = content.replace(/\n$/, "").split("\n");
       let name = await nvim.call("fnameescape", [`(${commit}) ${file}`]);
       nvim.pauseNotification();
-      nvim.call("win_gotoid", [window12.id], true);
+      nvim.call("win_gotoid", [window13.id], true);
       nvim.command(`tabe ${name}`, true);
       nvim.call("append", [0, lines], true);
       nvim.command("normal! Gdd", true);
@@ -4757,6 +4757,16 @@ var Bcommits = class extends import_coc.BasicList {
 // src/lists/branches.ts
 var import_coc2 = require("coc.nvim");
 var import_safe = __toESM(require_safe());
+function parseBranchLine(line) {
+  const name = line.slice(2);
+  if (!name || name.includes(" -> ")) return void 0;
+  const remote = name.startsWith("remotes/");
+  return {
+    current: line[0] == "*",
+    branch: remote ? name.slice("remotes/".length) : name,
+    remote
+  };
+}
 var Branches = class {
   constructor(nvim, manager) {
     this.manager = manager;
@@ -4828,15 +4838,14 @@ var Branches = class {
     if (output == null) return;
     output = output.replace(/\s+$/, "");
     for (let line of output.split(/\r?\n/)) {
-      let remote = line.slice(2).startsWith("remotes/");
+      const data = parseBranchLine(line);
+      if (!data) continue;
       res.push({
         label: import_safe.default.yellow(line.slice(0, 2)) + line.slice(2),
         filterText: line.slice(2),
         data: {
-          current: line[0] == "*",
           root,
-          branch: remote ? line.slice(10) : line.slice(2),
-          remote
+          ...data
         }
       });
     }
@@ -5092,14 +5101,12 @@ var Gfiles = class extends import_coc4.BasicList {
     this.detail = "Pass git sha as first command argument, when empty, HEAD is used.\nExample: :CocList gfiles 7b5c5cb";
     this.defaultAction = "edit";
     this.actions = [];
-    const preferences = import_coc4.workspace.getConfiguration("coc.preferences");
-    let jumpCommand = preferences.get("jumpCommand", "edit");
     for (let name of ["edit", "tabe", "vsplit", "split"]) {
       this.addAction(name, async (item, ctx) => {
         let { root, sha, filepath, branch } = item.data;
         if (!sha) return;
         if (branch == "HEAD") {
-          let cmd2 = name == "edit" ? jumpCommand : name;
+          let cmd2 = name == "edit" ? import_coc4.workspace.getConfiguration("coc.preferences").get("jumpCommand", "edit") : name;
           if (ctx.options.position === "tab") cmd2 = "tabe";
           let fullpath = import_path.default.join(root, filepath);
           await import_coc4.workspace.jumpTo(import_coc4.Uri.file(fullpath).toString(), null, cmd2);
@@ -5107,7 +5114,7 @@ var Gfiles = class extends import_coc4.BasicList {
         }
         let content = (await this.manager.git.exec(root, ["cat-file", "-p", sha])).stdout;
         let lines = content.replace(/\n$/, "").split("\n");
-        let cmd = name == "edit" ? jumpCommand : name;
+        let cmd = name == "edit" ? import_coc4.workspace.getConfiguration("coc.preferences").get("jumpCommand", "edit") : name;
         let bufferName = await nvim.call("fnameescape", [`(${branch}) ${filepath}`]);
         nvim.pauseNotification();
         nvim.command(`${cmd} ${bufferName}`, true);
@@ -5169,6 +5176,21 @@ var import_safe2 = __toESM(require_safe());
 var import_fs = __toESM(require("fs"));
 var import_path3 = __toESM(require("path"));
 
+// src/model/statusEntry.ts
+function parseStatusEntries(output) {
+  const result = [];
+  const entries = output.split("\0");
+  for (let i = 0; i < entries.length; i++) {
+    const line = entries[i];
+    if (!line) continue;
+    result.push({ index: line[0], tree: line[1], relative: line.slice(3) });
+    if (line[0] === "R" || line[0] === "C" || line[1] === "R" || line[1] === "C") {
+      i++;
+    }
+  }
+  return result;
+}
+
 // src/util.ts
 var import_child_process = require("child_process");
 var import_coc5 = require("coc.nvim");
@@ -5200,7 +5222,7 @@ function quoteGitPath(filepath) {
 }
 function createUnstagePatch(relpath, chunk) {
   if (chunk.remove.count == 0 && chunk.add.count == 0) return "";
-  let head = `@@ -${chunk.add.lnum},${chunk.add.count} +${chunk.add.lnum + 1 - chunk.add.count},${chunk.remove.count} @@`;
+  let head = `@@ -${chunk.add.lnum},${chunk.add.count} +${chunk.remove.lnum},${chunk.remove.count} @@`;
   if (!head) return "";
   const from = quoteGitPath(`a/${relpath}`);
   const to = quoteGitPath(`b/${relpath}`);
@@ -5316,15 +5338,22 @@ function getUrl(fix, repoURL, name, filepath, lines) {
   }
   const encodePath = (value) => value.split("/").map(encodeURIComponent).join("/");
   let url = repoURL + "/blob/" + encodePath(name) + "/" + encodePath(filepath) + (anchor ? "#" + encodeURIComponent(anchor) : "");
-  let parts = fix.split("|");
-  if (parts.length < 2) return url;
+  const separator = fix.lastIndexOf("|");
+  if (separator === -1) return url;
   try {
-    let match = RegExp(parts[0]), result = parts[1];
+    let match = RegExp(fix.slice(0, separator)), result = fix.slice(separator + 1);
     return url.replace(match, result);
   } catch (_e) {
     return url;
   }
 }
+async function feedTreeToggleKey(nvim, configuredKey) {
+  let key = configuredKey;
+  if (/^<[^"\\\r\n]+>$/.test(configuredKey)) {
+    key = await nvim.call("eval", [`"\\${configuredKey}"`]);
+  }
+  await nvim.call("feedkeys", [key, "in"]);
+}
 function parseVersion(raw) {
   return raw.replace(/^git version /, "");
 }
@@ -5335,20 +5364,20 @@ function findSystemGitWin32(base, onLookup) {
   return findSpecificGit(import_path2.default.join(base, "Git", "cmd", "git.exe"), onLookup);
 }
 function findGitWin32InPath(onLookup) {
-  const whichPromise = new Promise((c, e) => (0, import_which.default)("git.exe", (err, 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, path10) => err ? e(err) : c(path10)));
+  return whichPromise.then((path10) => findSpecificGit(path10, onLookup));
 }
 function findGitWin32(onLookup) {
   return findSystemGitWin32(process.env["ProgramW6432"], onLookup).then(void 0, () => findSystemGitWin32(process.env["ProgramFiles(x86)"], onLookup)).then(void 0, () => findSystemGitWin32(process.env["ProgramFiles"], onLookup)).then(void 0, () => findSystemGitWin32(import_path2.default.join(process.env["LocalAppData"], "Programs"), onLookup)).then(void 0, () => findGitWin32InPath(onLookup));
 }
-function findSpecificGit(path9, onLookup) {
+function findSpecificGit(path10, onLookup) {
   return new Promise((c, e) => {
-    onLookup(path9);
+    onLookup(path10);
     const buffers = [];
-    const child = (0, import_child_process.spawn)(path9, ["--version"]);
+    const child = (0, import_child_process.spawn)(path10, ["--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: path10, version: parseVersion(Buffer.concat(buffers).toString("utf8").trim()) }));
   });
 }
 function cpErrorHandler(cb) {
@@ -5365,9 +5394,9 @@ function findGitDarwin(onLookup) {
       if (err) {
         return e("git not found");
       }
-      const path9 = gitPathBuffer.toString().replace(/^\s+|\s+$/g, "");
-      if (path9 !== "/usr/bin/git") {
-        findSpecificGit(path9, onLookup).then(c, e);
+      const path10 = gitPathBuffer.toString().replace(/^\s+|\s+$/g, "");
+      if (path10 !== "/usr/bin/git") {
+        findSpecificGit(path10, onLookup).then(c, e);
         return;
       }
       (0, import_child_process.exec)("xcode-select -p", (err2) => {
@@ -5375,7 +5404,7 @@ function findGitDarwin(onLookup) {
           e("git not found");
           return;
         }
-        findSpecificGit(path9, onLookup).then(c, e);
+        findSpecificGit(path10, onLookup).then(c, e);
       });
     });
   });
@@ -5404,6 +5433,21 @@ function onceEvent(event) {
 }
 
 // src/lists/gstatus.ts
+async function commitWithFugitive(nvim, items) {
+  let { root } = items[0].data;
+  const cwd = await nvim.call("getcwd");
+  let escapedRoot = await nvim.call("fnameescape", [root]);
+  let escapedCwd = await nvim.call("fnameescape", [cwd]);
+  await nvim.command(`lcd ${escapedRoot}`);
+  try {
+    let escapedFiles = await Promise.all(items.map((item) => nvim.call("fnameescape", [item.data.relative])));
+    await nvim.command(`G commit -v -- ${escapedFiles.join(" ")}`);
+  } catch (e) {
+    import_coc6.window.showErrorMessage(`G commit command failed, make sure fugitive installed.`);
+  } finally {
+    await nvim.command(`lcd ${escapedCwd}`);
+  }
+}
 var STATUS_MAP = {
   " ": " ",
   M: import_safe2.default.cyan("~"),
@@ -5416,19 +5460,6 @@ var STATUS_MAP = {
   "?": import_safe2.default.gray("?"),
   "!": import_safe2.default.gray("!")
 };
-function parseStatusEntries(output) {
-  let result = [];
-  let entries = output.split("\0");
-  for (let i = 0; i < entries.length; i++) {
-    let line = entries[i];
-    if (!line) continue;
-    result.push({ index: line[0], tree: line[1], relative: line.slice(3) });
-    if (line[0] === "R" || line[0] === "C" || line[1] === "R" || line[1] === "C") {
-      i++;
-    }
-  }
-  return result;
-}
 var GStatus = class extends import_coc6.BasicList {
   constructor(nvim, manager) {
     super();
@@ -5452,15 +5483,7 @@ var GStatus = class extends import_coc6.BasicList {
       }]);
     });
     this.addMultipleAction("commit", async (items) => {
-      let { root } = items[0].data;
-      let escapedRoot = await nvim.call("fnameescape", [root]);
-      await nvim.command(`lcd ${escapedRoot}`);
-      let escapedFiles = await Promise.all(items.map((item) => nvim.call("fnameescape", [item.data.relative])));
-      try {
-        await nvim.command(`G commit -v -- ${escapedFiles.join(" ")}`);
-      } catch (e) {
-        import_coc6.window.showErrorMessage(`G commit command failed, make sure fugitive installed.`);
-      }
+      await commitWithFugitive(nvim, items);
     });
     this.addAction("reset", async (item) => {
       let { staged, tree, relative, root } = item.data;
@@ -5602,20 +5625,20 @@ var GChunks = class extends import_coc7.BasicList {
       let stagedDiff = await buf.repo.getStagedChunks(relpath);
       let chunks = (_a = Object.values(stagedDiff)[0]) != null ? _a : [];
       if (chunks.length > 0) {
-        for (let diff of chunks) {
+        for (let chunk of chunks) {
           let adjust = 0;
           let stagedSign = import_safe3.default.green("*");
-          let line = diff.add.lnum;
-          for (let diff2 of diffs) {
-            if (diff2.end >= line) {
+          let line = chunk.add.lnum;
+          for (let unstagedDiff of diffs) {
+            if (unstagedDiff.end >= line) {
               break;
             }
-            adjust += diff2.added.count;
-            adjust -= diff2.removed.count;
+            adjust += unstagedDiff.added.count;
+            adjust -= unstagedDiff.removed.count;
           }
           line += adjust;
           res.push({
-            label: `${stagedSign} Line:${line} ${diff.lines[0]}`,
+            label: `${stagedSign} Line:${line} ${chunk.lines[0]}`,
             data: {
               line
             }
@@ -5698,8 +5721,8 @@ var GitStatus = class {
       if (!this._enabled) this.setGitStatus("");
       this.scheduleRefresh(0);
     }, null, this.disposables);
-    import_coc9.events.on("BufEnter", this.refresh, this, this.disposables);
-    import_coc9.events.on("FocusGained", this.refresh, this, this.disposables);
+    import_coc9.events.on("BufEnter", () => this.scheduleRefresh(100), this, this.disposables);
+    import_coc9.events.on("FocusGained", () => this.scheduleRefresh(100), this, this.disposables);
     import_coc9.events.on("BufWritePost", () => this.scheduleRefresh(50), this, this.disposables);
     this.disposables.push({ dispose: () => this.clearTimer() });
     this.scheduleRefresh(300);
@@ -6136,8 +6159,10 @@ var DocumentManager = class {
       import_coc10.window.showWarningMessage(`not belongs to git repository.`);
       return null;
     }
-    let repo = this.service.getRepoFromRoot(root);
-    return repo.getDiffAll(category);
+    return this.getDiffAllForRoot(root, category);
+  }
+  async getDiffAllForRoot(root, category) {
+    return this.service.getRepoFromRoot(root).getDiffAll(category);
   }
   dispose() {
     (0, import_coc10.disposeAll)(this.disposables);
@@ -6180,13 +6205,13 @@ function parseNameStatus(output) {
     }
     if (status === "R" || status === "C") {
       const oldPath = fields[index++];
-      const path9 = fields[index++];
-      if (!oldPath || !path9) throw parserError("name-status", "missing rename/copy path");
-      result.push({ status, score, oldPath, path: path9 });
+      const path10 = fields[index++];
+      if (!oldPath || !path10) throw parserError("name-status", "missing rename/copy path");
+      result.push({ status, score, oldPath, path: path10 });
     } else {
-      const path9 = fields[index++];
-      if (!path9) throw parserError("name-status", "missing path");
-      result.push({ status, path: path9 });
+      const path10 = fields[index++];
+      if (!path10) throw parserError("name-status", "missing path");
+      result.push({ status, path: path10 });
     }
   }
   return result;
@@ -6205,7 +6230,7 @@ function parseNumstat(output) {
     }
     const additionsText = record.slice(0, firstTab);
     const deletionsText = record.slice(firstTab + 1, secondTab);
-    const path9 = record.slice(secondTab + 1);
+    const path10 = record.slice(secondTab + 1);
     const binary = additionsText === "-" || deletionsText === "-";
     if (binary && (additionsText !== "-" || deletionsText !== "-")) {
       throw parserError("numstat", "only binary records may contain -");
@@ -6213,9 +6238,9 @@ function parseNumstat(output) {
     if (!binary && (!/^\d+$/.test(additionsText) || !/^\d+$/.test(deletionsText))) {
       throw parserError("numstat", `invalid line counts in ${JSON.stringify(record)}`);
     }
-    if (path9) {
+    if (path10) {
       result.push({
-        path: path9,
+        path: path10,
         additions: binary ? void 0 : Number(additionsText),
         deletions: binary ? void 0 : Number(deletionsText),
         binary
@@ -6380,9 +6405,12 @@ function patchArguments(comparison, change) {
   return args;
 }
 function commitUri(comparison, relativePath) {
+  return revisionUri(comparison.commit.sha, relativePath);
+}
+function revisionUri(revision, relativePath) {
   return import_coc11.Uri.from({
     scheme: COMMIT_DOCUMENT_SCHEME,
-    authority: comparison.commit.sha,
+    authority: revision,
     path: `/${relativePath}`
   });
 }
@@ -6409,7 +6437,27 @@ var CommitDocumentProvider = class {
   }
   async open(root, comparison, change, targetWinId, line) {
     const uri = commitUri(comparison, change.path);
-    const resource = { uri, root, comparison, change };
+    const resource = { kind: "comparison", uri, root, comparison, change };
+    await this.openResource(resource, targetWinId, line);
+  }
+  async openRevision(root, revision, relativePath, targetWinId, line) {
+    const result = await this.git.exec(root, ["rev-parse", "--verify", "--end-of-options", `${revision}^{commit}`]);
+    const sha = result.stdout.trim();
+    if (!sha) throw new Error(`Invalid Git revision: ${revision}`);
+    const object = `${sha}:${relativePath}`;
+    const type = (await this.git.exec(root, ["cat-file", "-t", object])).stdout.trim();
+    if (type !== "blob") throw new Error(`Git path is not a file: ${relativePath}`);
+    const resource = {
+      kind: "revision",
+      uri: revisionUri(sha, relativePath),
+      root,
+      revision: sha,
+      relativePath
+    };
+    await this.openResource(resource, targetWinId, line);
+  }
+  async openResource(resource, targetWinId, line) {
+    const { uri } = resource;
     this.resources.set(uri.toString(), resource);
     const moved = await import_coc11.workspace.nvim.call("win_gotoid", [targetWinId]);
     if (!moved) await import_coc11.workspace.nvim.command("new");
@@ -6430,6 +6478,14 @@ var CommitDocumentProvider = class {
   async load(resource, token) {
     if (resource.content !== void 0 && resource.hunks) return;
     const options = token ? { cancellationToken: token } : void 0;
+    if (resource.kind === "revision") {
+      const object2 = `${resource.revision}:${resource.relativePath}`;
+      const content2 = await this.git.exec(resource.root, ["cat-file", "-p", object2], options);
+      if (token == null ? void 0 : token.isCancellationRequested) return;
+      resource.content = content2.stdout.replace(/\r?\n$/, "");
+      resource.hunks = [];
+      return;
+    }
     const object = `${resource.comparison.commit.sha}:${resource.change.path}`;
     const [content, patch] = await Promise.all([
       this.git.exec(resource.root, ["cat-file", "-p", object], options),
@@ -7307,14 +7363,7 @@ var GitBuffer = class {
       import_coc12.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 head = diff.head;
     const from = quoteGitPath(`a/${relpath}`);
     const to = quoteGitPath(`b/${relpath}`);
     const lines = [
@@ -8511,6 +8560,9 @@ var GitService = class {
 var import_coc16 = require("coc.nvim");
 var import_safe5 = __toESM(require_safe());
 var import_url2 = require("url");
+function isIssuePage(value) {
+  return Array.isArray(value);
+}
 function byteSlice(content, start, end) {
   let buf = Buffer.from(content, "utf8");
   return buf.slice(start, end).toString("utf8");
@@ -8605,7 +8657,7 @@ function addSource(context, service) {
         const pageUri = `${uri}&page=${pageIndex}`;
         pageIndex++;
         let info = await (0, import_coc16.fetch)(pageUri, { headers: { "Private-Token": token } });
-        if (!info.length) {
+        if (!isIssuePage(info) || info.length === 0) {
           break;
         }
         for (let i = 0, len = info.length; i < len; i++) {
@@ -8642,7 +8694,7 @@ function addSource(context, service) {
       page_idx++;
       try {
         let info = await (0, import_coc16.fetch)(page_uri, { headers });
-        if (info.length == 0) {
+        if (!isIssuePage(info) || info.length === 0) {
           break;
         }
         for (let i = 0, len = info.length; i < len; i++) {
@@ -9092,9 +9144,7 @@ var CommitFilesController = class {
     const element = node;
     if (element.kind !== "root" && element.kind !== "directory") return;
     const configuredKey = import_coc17.workspace.getConfiguration("tree").get("key.toggle", "t");
-    const key = configuredKey.startsWith("<") && configuredKey.endsWith(">") ? `\\${configuredKey}` : configuredKey;
-    const escaped = key.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-    await import_coc17.workspace.nvim.call("eval", [`feedkeys("${escaped}", "in")`]);
+    await feedTreeToggleKey(import_coc17.workspace.nvim, configuredKey);
   }
   async open(revision, requestedRoot, options = {}) {
     var _a;
@@ -9328,156 +9378,550 @@ var CommitFilesController = class {
   }
 };
 
+// src/tree/statusFiles.ts
+var import_fs5 = __toESM(require("fs"));
+var import_path9 = __toESM(require("path"));
+var import_coc18 = require("coc.nvim");
+function emptyAggregate2() {
+  return { fileCount: 0, stagedCount: 0, unstagedCount: 0, untrackedCount: 0, conflictCount: 0 };
+}
+function isUntracked(entry) {
+  return entry.index === "?" && entry.tree === "?";
+}
+function isConflict(entry) {
+  return entry.index === "U" || entry.tree === "U" || entry.index + entry.tree === "AA" || entry.index + entry.tree === "DD";
+}
+function isStaged(entry) {
+  return entry.index !== " " && entry.index !== "?" && entry.index !== "!";
+}
+function isUnstaged(entry) {
+  return entry.tree !== " " && entry.tree !== "?" && entry.tree !== "!";
+}
+function addFileAggregate2(target, entry) {
+  target.fileCount++;
+  if (isStaged(entry)) target.stagedCount++;
+  if (isUnstaged(entry)) target.unstagedCount++;
+  if (isUntracked(entry)) target.untrackedCount++;
+  if (isConflict(entry)) target.conflictCount++;
+}
+function addAggregate2(target, source) {
+  target.fileCount += source.fileCount;
+  target.stagedCount += source.stagedCount;
+  target.unstagedCount += source.unstagedCount;
+  target.untrackedCount += source.untrackedCount;
+  target.conflictCount += source.conflictCount;
+}
+function compareNodes2(left, right) {
+  if (left.kind === "directory" && right.kind !== "directory") return -1;
+  if (left.kind !== "directory" && right.kind === "directory") return 1;
+  return left.relativePath.localeCompare(right.relativePath);
+}
+function buildStatusTree(rootPath, entries) {
+  const root = {
+    ...emptyAggregate2(),
+    kind: "root",
+    id: `${rootPath}\0root`,
+    name: import_path9.default.basename(rootPath) || rootPath,
+    relativePath: "",
+    parent: void 0,
+    root: rootPath,
+    children: []
+  };
+  const directories = /* @__PURE__ */ new Map();
+  const ensureDirectory = (segments) => {
+    if (!segments.length) return root;
+    const relativePath = segments.join("/");
+    const existing = directories.get(relativePath);
+    if (existing) return existing;
+    const parent = ensureDirectory(segments.slice(0, -1));
+    const directory = {
+      ...emptyAggregate2(),
+      kind: "directory",
+      id: `${rootPath}\0directory\0${relativePath}`,
+      name: segments[segments.length - 1],
+      relativePath,
+      parent,
+      children: []
+    };
+    directories.set(relativePath, directory);
+    parent.children.push(directory);
+    return directory;
+  };
+  for (const entry of entries) {
+    const segments = entry.relative.split("/");
+    const name = segments.pop();
+    if (!name) continue;
+    const parent = ensureDirectory(segments);
+    parent.children.push({
+      kind: "file",
+      id: `${rootPath}\0file\0${entry.relative}`,
+      name,
+      relativePath: entry.relative,
+      parent,
+      entry
+    });
+  }
+  const aggregate = (node) => {
+    const own = emptyAggregate2();
+    for (const child of node.children) {
+      if (child.kind === "file") addFileAggregate2(own, child.entry);
+      else {
+        aggregate(child);
+        addAggregate2(own, child);
+      }
+    }
+    Object.assign(node, own);
+    node.children.sort(compareNodes2);
+  };
+  aggregate(root);
+  return root;
+}
+function firstFile(node) {
+  for (const child of node.children) {
+    if (child.kind === "file") return child;
+    const file = firstFile(child);
+    if (file) return file;
+  }
+  return void 0;
+}
+function escapeDisplay2(value) {
+  return value.replace(/\r/g, "\\r").replace(/\n/g, "\\n").replace(/\t/g, "\\t");
+}
+var STATUS_NAMES = {
+  M: "Modified",
+  A: "Added",
+  D: "Deleted",
+  R: "Renamed",
+  C: "Copied",
+  T: "Type changed",
+  U: "Unmerged"
+};
+function aggregateDescription(value) {
+  const parts = [`${value.fileCount} file${value.fileCount === 1 ? "" : "s"}`];
+  if (value.stagedCount) parts.push(`${value.stagedCount} staged`);
+  if (value.unstagedCount) parts.push(`${value.unstagedCount} unstaged`);
+  if (value.untrackedCount) parts.push(`${value.untrackedCount} untracked`);
+  if (value.conflictCount) parts.push(`${value.conflictCount} conflicted`);
+  return parts.join(" \xB7 ");
+}
+function fileDescription2(entry) {
+  var _a, _b;
+  const code = `[${entry.index}${entry.tree}]`;
+  if (isUntracked(entry)) return `${code} \xB7 Untracked`;
+  if (entry.index === "!" && entry.tree === "!") return `${code} \xB7 Ignored`;
+  const parts = [code];
+  if (isStaged(entry)) parts.push(`staged: ${(_a = STATUS_NAMES[entry.index]) != null ? _a : entry.index}`);
+  if (isUnstaged(entry)) parts.push(`unstaged: ${(_b = STATUS_NAMES[entry.tree]) != null ? _b : entry.tree}`);
+  if (isConflict(entry) && !parts.some((part) => part.includes("Unmerged"))) parts.push("conflicted");
+  return parts.join(" \xB7 ");
+}
+function statusIcon2(entry) {
+  if (isConflict(entry)) return { text: "!", hlGroup: "Error" };
+  if (isUntracked(entry)) return { text: "?", hlGroup: "Comment" };
+  const status = entry.tree !== " " ? entry.tree : entry.index;
+  if (status === "A" || status === "C") return { text: "+", hlGroup: "DiffAdd" };
+  if (status === "D") return { text: "-", hlGroup: "DiffDelete" };
+  if (status === "R") return { text: "R", hlGroup: "DiffChange" };
+  return { text: "~", hlGroup: "DiffChange" };
+}
+function toggleCommand(node) {
+  return { command: "git.statusFiles.toggle", title: "Toggle directory", arguments: [node] };
+}
+var StatusFilesProvider = class {
+  constructor(rootPath, entries, actions) {
+    this.actions = actions;
+    this.emitter = new import_coc18.Emitter();
+    this.onDidChangeTreeData = this.emitter.event;
+    this.root = buildStatusTree(rootPath, entries);
+  }
+  setEntries(entries) {
+    this.root = buildStatusTree(this.root.root, entries);
+    this.emitter.fire(void 0);
+  }
+  getTreeItem(element) {
+    if (element.kind === "root") {
+      const item2 = new import_coc18.TreeItem(escapeDisplay2(element.name), element.children.length ? import_coc18.TreeItemCollapsibleState.Expanded : import_coc18.TreeItemCollapsibleState.None);
+      item2.id = element.id;
+      item2.description = aggregateDescription(element);
+      item2.tooltip = escapeDisplay2(element.root);
+      item2.command = { command: "git.statusFiles.refresh", title: "Refresh Git status" };
+      return item2;
+    }
+    if (element.kind === "directory") {
+      const item2 = new import_coc18.TreeItem(escapeDisplay2(element.name), element.children.length ? import_coc18.TreeItemCollapsibleState.Expanded : import_coc18.TreeItemCollapsibleState.None);
+      item2.id = element.id;
+      item2.description = aggregateDescription(element);
+      item2.tooltip = escapeDisplay2(element.relativePath);
+      item2.command = toggleCommand(element);
+      return item2;
+    }
+    const item = new import_coc18.TreeItem(escapeDisplay2(element.name), import_coc18.TreeItemCollapsibleState.None);
+    item.id = element.id;
+    item.icon = statusIcon2(element.entry);
+    item.description = fileDescription2(element.entry);
+    item.tooltip = `${escapeDisplay2(element.relativePath)}
+${fileDescription2(element.entry)}`;
+    item.command = { command: "git.statusFiles.open", title: "Open file", arguments: [element] };
+    return item;
+  }
+  getChildren(element) {
+    if (!element) return [this.root];
+    return element.kind === "file" ? [] : element.children;
+  }
+  getParent(element) {
+    return element.parent;
+  }
+  resolveActions(_item, element) {
+    if (element.kind === "root") return [{ title: "Refresh", handler: () => this.actions.refresh() }];
+    if (element.kind === "directory") return [{ title: "Copy directory path", handler: (node) => this.actions.copyPath(node) }];
+    const actions = [
+      { title: "Open file", handler: (node) => this.actions.openFile(node) },
+      { title: "Copy relative path", handler: (node) => this.actions.copyPath(node) }
+    ];
+    const entry = element.entry;
+    if (isUntracked(entry) || isUnstaged(entry)) actions.push({ title: "Add", handler: (node) => this.actions.addFile(node) });
+    if (isStaged(entry)) actions.push({ title: "Restore staged changes", handler: (node) => this.actions.restoreStagedFile(node) });
+    if (isUnstaged(entry) && !isUntracked(entry) && !isConflict(entry)) {
+      actions.push({ title: "Restore working tree changes", handler: (node) => this.actions.restoreWorkingTreeFile(node) });
+    }
+    return actions;
+  }
+  dispose() {
+    this.emitter.dispose();
+  }
+};
+var StatusFilesController = class {
+  constructor(manager, commitDocuments) {
+    this.manager = manager;
+    this.commitDocuments = commitDocuments;
+  }
+  async open(requestedRoot) {
+    let root = requestedRoot;
+    if (!root) root = await this.manager.resolveGitRootFromBufferOrCwd(await import_coc18.workspace.nvim.call("bufnr", ["%"]));
+    if (!root) {
+      import_coc18.window.showWarningMessage("Can't resolve git repository for current buffer or cwd.");
+      return;
+    }
+    try {
+      root = await this.manager.git.getRepositoryRoot(root);
+    } catch (_e) {
+      import_coc18.window.showWarningMessage("Can't resolve git repository for current buffer or cwd.");
+      return;
+    }
+    const targetWinId = await import_coc18.workspace.nvim.call("win_getid");
+    this.disposeSession();
+    try {
+      const entries = await this.loadEntries(root);
+      const provider = new StatusFilesProvider(root, entries, this.actions);
+      const view = import_coc18.window.createTreeView("git.statusFiles", {
+        treeDataProvider: provider,
+        enableFilter: true,
+        winfixwidth: true,
+        bufhidden: "wipe",
+        canSelectMany: false,
+        autoWidth: true
+      });
+      view.title = "Git Status";
+      view.description = aggregateDescription(buildStatusTree(root, entries));
+      this.session = { root, provider, view, targetWinId };
+      await view.show(import_coc18.workspace.getConfiguration("git").get("statusTree.splitCommand", "belowright 40vs"));
+      const file = firstFile(provider.getChildren()[0]);
+      if (file) await view.reveal(file, { select: true, focus: true, expand: true });
+      view.onDidChangeVisibility((event) => {
+        var _a;
+        if (!event.visible && ((_a = this.session) == null ? void 0 : _a.view) === view) this.disposeSession();
+      });
+    } catch (e) {
+      this.disposeSession();
+      import_coc18.window.showErrorMessage(`Failed to open Git Status: ${e.message}`);
+    }
+  }
+  async toggle(node) {
+    if (!node || typeof node !== "object") return;
+    const element = node;
+    if (element.kind !== "root" && element.kind !== "directory") return;
+    const configuredKey = import_coc18.workspace.getConfiguration("tree").get("key.toggle", "t");
+    await feedTreeToggleKey(import_coc18.workspace.nvim, configuredKey);
+  }
+  async refresh() {
+    const session = this.session;
+    if (!session) return;
+    try {
+      const entries = await this.loadEntries(session.root);
+      if (this.session !== session) return;
+      session.provider.setEntries(entries);
+      session.view.description = aggregateDescription(buildStatusTree(session.root, entries));
+    } catch (e) {
+      import_coc18.window.showErrorMessage(`Failed to refresh Git Status: ${e.message}`);
+    }
+  }
+  close() {
+    this.disposeSession();
+  }
+  async openFile(node) {
+    var _a, _b, _c;
+    const session = this.session;
+    if (!session) return;
+    const absolute = import_path9.default.resolve(session.root, ...node.relativePath.split("/"));
+    const relative = import_path9.default.relative(session.root, absolute);
+    if (relative.startsWith(`..${import_path9.default.sep}`) || import_path9.default.isAbsolute(relative)) {
+      import_coc18.window.showWarningMessage(`Working tree path is outside repository: ${escapeDisplay2(node.relativePath)}`);
+      return;
+    }
+    let stat;
+    try {
+      stat = await import_fs5.default.promises.stat(absolute);
+    } catch (error) {
+      if (error.code !== "ENOENT" && error.code !== "ENOTDIR") {
+        import_coc18.window.showErrorMessage(`Failed to inspect working tree path: ${escapeDisplay2(node.relativePath)}`);
+        return;
+      }
+      try {
+        await this.commitDocuments.openRevision(session.root, "HEAD", node.relativePath, session.targetWinId);
+      } catch (_error) {
+        import_coc18.window.showWarningMessage(`File not found in working tree or HEAD: ${escapeDisplay2(node.relativePath)}`);
+      }
+      return;
+    }
+    if (!stat.isFile()) {
+      import_coc18.window.showWarningMessage(`Working tree path is not a file: ${escapeDisplay2(node.relativePath)}`);
+      return;
+    }
+    let line = 1;
+    try {
+      const groups = await this.manager.getDiffAllForRoot(session.root, 0 /* All */);
+      line = Math.max(1, (_c = (_b = (_a = groups.get(node.relativePath)) == null ? void 0 : _a[0]) == null ? void 0 : _b.start) != null ? _c : 1);
+    } catch (_e) {
+    }
+    const moved = await import_coc18.workspace.nvim.call("win_gotoid", [session.targetWinId]);
+    if (!moved) await import_coc18.workspace.nvim.command("new");
+    try {
+      await import_coc18.workspace.jumpTo(import_coc18.Uri.file(absolute), import_coc18.Position.create(line - 1, 0));
+    } catch (e) {
+      import_coc18.window.showErrorMessage(`Failed to open working tree file: ${e.message}`);
+    }
+  }
+  async addFile(node) {
+    await this.updateFile(node, ["add", "--", node.relativePath]);
+  }
+  async restoreStagedFile(node) {
+    await this.updateFile(node, ["reset", "--", node.relativePath]);
+  }
+  async restoreWorkingTreeFile(node) {
+    await this.updateFile(node, ["checkout", "--", node.relativePath]);
+  }
+  get actions() {
+    return {
+      refresh: () => this.refresh(),
+      openFile: (node) => this.openFile(node),
+      addFile: (node) => this.addFile(node),
+      restoreStagedFile: (node) => this.restoreStagedFile(node),
+      restoreWorkingTreeFile: (node) => this.restoreWorkingTreeFile(node),
+      copyPath: (node) => import_coc18.workspace.nvim.call("setreg", ["+", node.relativePath]).then(() => void 0)
+    };
+  }
+  async updateFile(node, args) {
+    const session = this.session;
+    if (!session) return;
+    try {
+      await this.manager.git.exec(session.root, args);
+      await this.refresh();
+    } catch (e) {
+      import_coc18.window.showErrorMessage(`Failed to update Git status for ${escapeDisplay2(node.relativePath)}: ${e.message}`);
+    }
+  }
+  async loadEntries(root) {
+    const result = await this.manager.git.exec(root, ["status", "--porcelain=v1", "-z", "-uall"]);
+    return parseStatusEntries(result.stdout);
+  }
+  disposeSession() {
+    const session = this.session;
+    if (!session) return;
+    this.session = void 0;
+    session.provider.dispose();
+    session.view.dispose();
+  }
+  dispose() {
+    this.close();
+  }
+};
+
 // src/index.ts
 async function activate(context) {
   var _a;
-  const config = import_coc18.workspace.getConfiguration("git");
+  const config = import_coc19.workspace.getConfiguration("git");
   const { subscriptions } = 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, (path10) => context.logger.info(`Looking for git in: ${path10}`));
   } catch (e) {
-    import_coc18.window.showErrorMessage("git command required for coc-git");
+    import_coc19.window.showErrorMessage("git command required for coc-git");
     return;
   }
-  const virtualTextSrcId = await import_coc18.workspace.nvim.createNamespace("coc-git-virtual");
-  const conflictSrcId = await import_coc18.workspace.nvim.createNamespace("coc-git-conflicts");
-  const commitDocumentSrcId = await import_coc18.workspace.nvim.createNamespace("coc-git-commit-document");
-  const { nvim } = import_coc18.workspace;
+  const virtualTextSrcId = await import_coc19.workspace.nvim.createNamespace("coc-git-virtual");
+  const conflictSrcId = await import_coc19.workspace.nvim.createNamespace("coc-git-conflicts");
+  const commitDocumentSrcId = await import_coc19.workspace.nvim.createNamespace("coc-git-commit-document");
+  const { nvim } = import_coc19.workspace;
   const service = new GitService(gitInfo);
   const manager = new DocumentManager(nvim, service, virtualTextSrcId, conflictSrcId);
   subscriptions.push(manager);
   const commitDocuments = new CommitDocumentProvider(service.git, commitDocumentSrcId);
   subscriptions.push(commitDocuments);
-  subscriptions.push(import_coc18.workspace.registerTextDocumentContentProvider(COMMIT_DOCUMENT_SCHEME, commitDocuments));
+  subscriptions.push(import_coc19.workspace.registerTextDocumentContentProvider(COMMIT_DOCUMENT_SCHEME, commitDocuments));
   nvim.command("highlight default link CocGitCommitAdd DiffAdd", true);
   nvim.command("highlight default link CocGitCommitDelete DiffDelete", true);
   const commitFiles = new CommitFilesController(manager);
   subscriptions.push(commitFiles);
+  const statusFiles = new StatusFilesController(manager, commitDocuments);
+  subscriptions.push(statusFiles);
   addSource(context, service);
-  subscriptions.push(import_coc18.commands.registerCommand("git.refresh", () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.refresh", () => {
     manager.refresh();
   }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["n"], "git-nextchunk", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.statusTree", async () => {
+    await statusFiles.open();
+  }));
+  subscriptions.push(import_coc19.commands.registerCommand("git.statusFiles.open", async (node) => {
+    await statusFiles.openFile(node);
+  }, void 0, true));
+  subscriptions.push(import_coc19.commands.registerCommand("git.statusFiles.add", async (node) => {
+    await statusFiles.addFile(node);
+  }, void 0, true));
+  subscriptions.push(import_coc19.commands.registerCommand("git.statusFiles.restoreStaged", async (node) => {
+    await statusFiles.restoreStagedFile(node);
+  }, void 0, true));
+  subscriptions.push(import_coc19.commands.registerCommand("git.statusFiles.restoreWorkingTree", async (node) => {
+    await statusFiles.restoreWorkingTreeFile(node);
+  }, void 0, true));
+  subscriptions.push(import_coc19.commands.registerCommand("git.statusFiles.refresh", async () => {
+    await statusFiles.refresh();
+  }, void 0, true));
+  subscriptions.push(import_coc19.commands.registerCommand("git.statusFiles.toggle", async (node) => {
+    await statusFiles.toggle(node);
+  }, void 0, true));
+  subscriptions.push(import_coc19.commands.registerCommand("git.statusFiles.close", () => {
+    statusFiles.close();
+  }, void 0, true));
+  subscriptions.push(import_coc19.workspace.registerKeymap(["n"], "git-nextchunk", async () => {
     if (!await commitDocuments.nextChunk()) await manager.nextChunk();
   }, { sync: false }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["n"], "git-prevchunk", async () => {
+  subscriptions.push(import_coc19.workspace.registerKeymap(["n"], "git-prevchunk", async () => {
     if (!await commitDocuments.prevChunk()) await manager.prevChunk();
   }, { sync: false }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["n"], "git-nextconflict", async () => {
+  subscriptions.push(import_coc19.workspace.registerKeymap(["n"], "git-nextconflict", async () => {
     await manager.nextConflict();
   }, { sync: false }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["n"], "git-prevconflict", async () => {
+  subscriptions.push(import_coc19.workspace.registerKeymap(["n"], "git-prevconflict", async () => {
     await manager.prevConflict();
   }, { sync: false }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["n"], "git-keepcurrent", async () => {
+  subscriptions.push(import_coc19.workspace.registerKeymap(["n"], "git-keepcurrent", async () => {
     await manager.keepCurrent();
   }, { sync: false }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["n"], "git-keepincoming", async () => {
+  subscriptions.push(import_coc19.workspace.registerKeymap(["n"], "git-keepincoming", async () => {
     await manager.keepIncoming();
   }, { sync: false }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["n"], "git-keepboth", async () => {
+  subscriptions.push(import_coc19.workspace.registerKeymap(["n"], "git-keepboth", async () => {
     await manager.keepBoth();
   }, { sync: false }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["n"], "git-chunkinfo", async () => {
+  subscriptions.push(import_coc19.workspace.registerKeymap(["n"], "git-chunkinfo", async () => {
     await manager.chunkInfo();
   }, { sync: false }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["n"], "git-commit", async () => {
+  subscriptions.push(import_coc19.workspace.registerKeymap(["n"], "git-commit", async () => {
     await manager.showCommit();
   }, { sync: false }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["n"], "git-showblamedoc", async () => {
+  subscriptions.push(import_coc19.workspace.registerKeymap(["n"], "git-showblamedoc", async () => {
     await manager.showBlameDoc();
   }, { sync: false }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.nextChunk", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.nextChunk", async () => {
     if (!await commitDocuments.nextChunk()) await manager.nextChunk();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.prevChunk", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.prevChunk", async () => {
     if (!await commitDocuments.prevChunk()) await manager.prevChunk();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.keepCurrent", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.keepCurrent", async () => {
     await manager.keepCurrent();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.keepIncoming", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.keepIncoming", async () => {
     await manager.keepIncoming();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.keepBoth", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.keepBoth", async () => {
     await manager.keepBoth();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.chunkInfo", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.chunkInfo", async () => {
     await manager.chunkInfo();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.allChunkInfo", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.allChunkInfo", async () => {
     return await manager.allChunkInfo();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.chunkStage", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.chunkStage", async () => {
     await manager.chunkStage();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.chunkUnstage", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.chunkUnstage", async () => {
     await manager.chunkUnstage();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.chunkUndo", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.chunkUndo", async () => {
     await manager.chunkUndo();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.showCommit", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.showCommit", async () => {
     await manager.showCommit();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.commitFiles.open", async (revision, root) => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.commitFiles.open", async (revision, root) => {
     await commitFiles.open(revision, root);
   }, void 0, true));
-  subscriptions.push(import_coc18.commands.registerCommand("git.showCommitTree", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.showCommitTree", async () => {
     const current = await manager.getCurrentCommit();
     if (current) await commitFiles.open(current.sha, current.root, { showCurrentFile: true, line: current.line });
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.commitFiles.invoke", async (node) => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.commitFiles.invoke", async (node) => {
     await commitFiles.invoke(node);
   }, void 0, true));
-  subscriptions.push(import_coc18.commands.registerCommand("git.commitFiles.toggle", async (node) => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.commitFiles.toggle", async (node) => {
     await commitFiles.toggle(node);
   }, void 0, true));
-  subscriptions.push(import_coc18.commands.registerCommand("git.commitFiles.openDocument", async (root, comparison, change, targetWinId, line) => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.commitFiles.openDocument", async (root, comparison, change, targetWinId, line) => {
     targetWinId = targetWinId != null ? targetWinId : await nvim.call("win_getid");
     await commitDocuments.open(root, comparison, change, targetWinId, line);
   }, void 0, true));
-  subscriptions.push(import_coc18.commands.registerCommand("git.browserOpen", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.browserOpen", async () => {
     await manager.browser();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.copyUrl", async (...args) => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.copyUrl", async (...args) => {
     await manager.browser("copy", args);
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.copyPermalink", async (...args) => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.copyPermalink", async (...args) => {
     await manager.browser("copy", args, true);
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.push", async (...args) => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.push", async (...args) => {
     await manager.push(args);
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.diffCached", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.diffCached", async () => {
     await manager.diffCached();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.toggleGutters", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.toggleGutters", async () => {
     await manager.toggleGutters();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.foldUnchanged", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.foldUnchanged", async () => {
     await manager.toggleFold();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.showBlameDoc", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.showBlameDoc", async () => {
     await manager.showBlameDoc();
   }));
-  subscriptions.push(import_coc18.listManager.registerList(new GStatus(nvim, manager)));
-  subscriptions.push(import_coc18.listManager.registerList(new Branches(nvim, manager)));
-  subscriptions.push(import_coc18.listManager.registerList(new Commits(nvim, manager)));
-  subscriptions.push(import_coc18.listManager.registerList(new Bcommits(nvim, manager)));
-  subscriptions.push(import_coc18.listManager.registerList(new Gfiles(nvim, manager)));
-  subscriptions.push(import_coc18.listManager.registerList(new GChunks(nvim, manager)));
-  subscriptions.push(import_coc18.listManager.registerList(new GChanges(nvim, manager)));
-  subscriptions.push(import_coc18.languages.registerCompletionItemProvider("semantic-commit", "Commit", (_a = config.get("semanticCommit.filetypes")) != null ? _a : [], {
+  subscriptions.push(import_coc19.listManager.registerList(new GStatus(nvim, manager)));
+  subscriptions.push(import_coc19.listManager.registerList(new Branches(nvim, manager)));
+  subscriptions.push(import_coc19.listManager.registerList(new Commits(nvim, manager)));
+  subscriptions.push(import_coc19.listManager.registerList(new Bcommits(nvim, manager)));
+  subscriptions.push(import_coc19.listManager.registerList(new Gfiles(nvim, manager)));
+  subscriptions.push(import_coc19.listManager.registerList(new GChunks(nvim, manager)));
+  subscriptions.push(import_coc19.listManager.registerList(new GChanges(nvim, manager)));
+  subscriptions.push(import_coc19.languages.registerCompletionItemProvider("semantic-commit", "Commit", (_a = config.get("semanticCommit.filetypes")) != null ? _a : [], {
     provideCompletionItems: async (document, position) => {
       if (position.line !== 0) {
         return [];
       }
       const text = document.getText(
-        import_coc18.Range.create(
-          import_coc18.Position.create(position.line, 0),
+        import_coc19.Range.create(
+          import_coc19.Position.create(position.line, 0),
           position
         )
       );
@@ -9487,10 +9931,10 @@ async function activate(context) {
         return DEFAULT_TYPES.map((o) => {
           return {
             label: o.value,
-            kind: import_coc18.CompletionItemKind.Snippet,
+            kind: import_coc19.CompletionItemKind.Snippet,
             documentation: { kind: "plaintext", value: o.name },
             // detail: o.name,
-            insertTextFormat: import_coc18.InsertTextFormat.Snippet,
+            insertTextFormat: import_coc19.InsertTextFormat.Snippet,
             // tslint:disable-next-line: no-invalid-template-strings
             insertText: o.value + text2 + "\n\n"
           };
@@ -9499,12 +9943,12 @@ async function activate(context) {
       return [];
     }
   }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["o", "x"], "git-chunk-inner", async () => {
+  subscriptions.push(import_coc19.workspace.registerKeymap(["o", "x"], "git-chunk-inner", async () => {
     let diff = await manager.getCurrentChunk();
     if (!diff) return;
     await nvim.command(`normal! ${diff.start}GV${diff.end}G`);
   }, { sync: true, silent: true }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["o", "x"], "git-chunk-outer", async () => {
+  subscriptions.push(import_coc19.workspace.registerKeymap(["o", "x"], "git-chunk-outer", async () => {
     let diff = await manager.getCurrentChunk();
     if (!diff) return;
     let total = await nvim.call("line", ["$"]);