coc-git 2.4.11 → 2.5.0

package/lib/index.js

@@ -670,17 +670,17 @@ var require_zalgo = __commonJS((exports2, module2) => {
 
 // node_modules/colors/lib/maps/america.js
 var require_america = __commonJS((exports2, module2) => {
-  module2["exports"] = function(colors4) {
+  module2["exports"] = function(colors5) {
     return function(letter, i, exploded) {
       if (letter === " ")
         return letter;
       switch (i % 3) {
         case 0:
-          return colors4.red(letter);
+          return colors5.red(letter);
         case 1:
-          return colors4.white(letter);
+          return colors5.white(letter);
         case 2:
-          return colors4.blue(letter);
+          return colors5.blue(letter);
       }
     };
   };
@@ -688,22 +688,22 @@ var require_america = __commonJS((exports2, module2) => {
 
 // node_modules/colors/lib/maps/zebra.js
 var require_zebra = __commonJS((exports2, module2) => {
-  module2["exports"] = function(colors4) {
+  module2["exports"] = function(colors5) {
     return function(letter, i, exploded) {
-      return i % 2 === 0 ? letter : colors4.inverse(letter);
+      return i % 2 === 0 ? letter : colors5.inverse(letter);
     };
   };
 });
 
 // node_modules/colors/lib/maps/rainbow.js
 var require_rainbow = __commonJS((exports2, module2) => {
-  module2["exports"] = function(colors4) {
+  module2["exports"] = function(colors5) {
     var rainbowColors = ["red", "yellow", "green", "blue", "magenta"];
     return function(letter, i, exploded) {
       if (letter === " ") {
         return letter;
       } else {
-        return colors4[rainbowColors[i++ % rainbowColors.length]](letter);
+        return colors5[rainbowColors[i++ % rainbowColors.length]](letter);
       }
     };
   };
@@ -711,7 +711,7 @@ var require_rainbow = __commonJS((exports2, module2) => {
 
 // node_modules/colors/lib/maps/random.js
 var require_random = __commonJS((exports2, module2) => {
-  module2["exports"] = function(colors4) {
+  module2["exports"] = function(colors5) {
     var available = [
       "underline",
       "inverse",
@@ -732,40 +732,40 @@ var require_random = __commonJS((exports2, module2) => {
       "brightMagenta"
     ];
     return function(letter, i, exploded) {
-      return letter === " " ? letter : colors4[available[Math.round(Math.random() * (available.length - 2))]](letter);
+      return letter === " " ? letter : colors5[available[Math.round(Math.random() * (available.length - 2))]](letter);
     };
   };
 });
 
 // node_modules/colors/lib/colors.js
 var require_colors = __commonJS((exports2, module2) => {
-  var colors4 = {};
-  module2["exports"] = colors4;
-  colors4.themes = {};
+  var colors5 = {};
+  module2["exports"] = colors5;
+  colors5.themes = {};
   var util2 = require("util");
-  var ansiStyles = colors4.styles = require_styles();
+  var ansiStyles = colors5.styles = require_styles();
   var defineProps = Object.defineProperties;
   var newLineRegex = new RegExp(/[\r\n]+/g);
-  colors4.supportsColor = require_supports_colors().supportsColor;
-  if (typeof colors4.enabled === "undefined") {
-    colors4.enabled = colors4.supportsColor() !== false;
+  colors5.supportsColor = require_supports_colors().supportsColor;
+  if (typeof colors5.enabled === "undefined") {
+    colors5.enabled = colors5.supportsColor() !== false;
   }
-  colors4.enable = function() {
-    colors4.enabled = true;
+  colors5.enable = function() {
+    colors5.enabled = true;
   };
-  colors4.disable = function() {
-    colors4.enabled = false;
+  colors5.disable = function() {
+    colors5.enabled = false;
   };
-  colors4.stripColors = colors4.strip = function(str) {
+  colors5.stripColors = colors5.strip = function(str) {
     return ("" + str).replace(/\x1B\[\d+m/g, "");
   };
-  var stylize = colors4.stylize = function stylize2(str, style) {
-    if (!colors4.enabled) {
+  var stylize = colors5.stylize = function stylize2(str, style) {
+    if (!colors5.enabled) {
       return str + "";
     }
     var styleMap = ansiStyles[style];
-    if (!styleMap && style in colors4) {
-      return colors4[style](str);
+    if (!styleMap && style in colors5) {
+      return colors5[style](str);
     }
     return styleMap.open + str + styleMap.close;
   };
@@ -797,7 +797,7 @@ var require_colors = __commonJS((exports2, module2) => {
     });
     return ret;
   }();
-  var proto = defineProps(function colors5() {
+  var proto = defineProps(function colors6() {
   }, styles);
   function applyStyle() {
     var args = Array.prototype.slice.call(arguments);
@@ -808,7 +808,7 @@ var require_colors = __commonJS((exports2, module2) => {
         return util2.inspect(arg);
       }
     }).join(" ");
-    if (!colors4.enabled || !str) {
+    if (!colors5.enabled || !str) {
       return str;
     }
     var newLinesPresent = str.indexOf("\n") != -1;
@@ -825,22 +825,22 @@ var require_colors = __commonJS((exports2, module2) => {
     }
     return str;
   }
-  colors4.setTheme = function(theme) {
+  colors5.setTheme = function(theme) {
     if (typeof theme === "string") {
       console.log("colors.setTheme now only accepts an object, not a string.  If you are trying to set a theme from a file, it is now your (the caller's) responsibility to require the file.  The old syntax looked like colors.setTheme(__dirname + '/../themes/generic-logging.js'); The new syntax looks like colors.setTheme(require(__dirname + '/../themes/generic-logging.js'));");
       return;
     }
     for (var style in theme) {
       (function(style2) {
-        colors4[style2] = function(str) {
+        colors5[style2] = function(str) {
           if (typeof theme[style2] === "object") {
             var out = str;
             for (var i in theme[style2]) {
-              out = colors4[theme[style2][i]](out);
+              out = colors5[theme[style2][i]](out);
             }
             return out;
           }
-          return colors4[theme[style2]](str);
+          return colors5[theme[style2]](str);
         };
       })(style);
     }
@@ -861,27 +861,27 @@ var require_colors = __commonJS((exports2, module2) => {
     exploded = exploded.map(map2);
     return exploded.join("");
   };
-  colors4.trap = require_trap();
-  colors4.zalgo = require_zalgo();
-  colors4.maps = {};
-  colors4.maps.america = require_america()(colors4);
-  colors4.maps.zebra = require_zebra()(colors4);
-  colors4.maps.rainbow = require_rainbow()(colors4);
-  colors4.maps.random = require_random()(colors4);
-  for (var map in colors4.maps) {
+  colors5.trap = require_trap();
+  colors5.zalgo = require_zalgo();
+  colors5.maps = {};
+  colors5.maps.america = require_america()(colors5);
+  colors5.maps.zebra = require_zebra()(colors5);
+  colors5.maps.rainbow = require_rainbow()(colors5);
+  colors5.maps.random = require_random()(colors5);
+  for (var map in colors5.maps) {
     (function(map2) {
-      colors4[map2] = function(str) {
-        return sequencer(colors4.maps[map2], str);
+      colors5[map2] = function(str) {
+        return sequencer(colors5.maps[map2], str);
       };
     })(map);
   }
-  defineProps(colors4, init());
+  defineProps(colors5, init());
 });
 
 // node_modules/colors/safe.js
 var require_safe = __commonJS((exports2, module2) => {
-  var colors4 = require_colors();
-  module2["exports"] = colors4;
+  var colors5 = require_colors();
+  module2["exports"] = colors5;
 });
 
 // node_modules/debounce/index.js
@@ -4508,7 +4508,7 @@ var require_lib = __commonJS((exports2, module2) => {
 __export(exports, {
   activate: () => activate
 });
-var import_coc14 = __toModule(require("coc.nvim"));
+var import_coc15 = __toModule(require("coc.nvim"));
 
 // src/constants.ts
 var DEFAULT_TYPES = [
@@ -4924,11 +4924,11 @@ var Bcommits = class extends import_coc2.BasicList {
     }, {tabPersist: true});
     this.addAction("view", async (item, context) => {
       let {commit, root, file} = item.data;
-      let {window: window9} = context;
+      let {window: window10} = context;
       let content = await import_coc2.runCommand(`git show ${commit}:${shellescape(file)}`, {cwd: root});
       let lines = content.replace(/\n$/, "").split("\n");
       nvim.pauseNotification();
-      nvim.call("win_gotoid", [window9.id], true);
+      nvim.call("win_gotoid", [window10.id], true);
       nvim.command(`exe "tabe ".fnameescape('(${commit}) ${file}')`, true);
       nvim.call("append", [0, lines], true);
       nvim.command("normal! Gdd", true);
@@ -5529,6 +5529,9 @@ var GStatus = class extends import_coc6.BasicList {
       throw new Error(`Can't resolve git root.`);
       return;
     }
+    if (this.manager.gstatusSaveBeforeOpen) {
+      await this.nvim.command(`wa`);
+    }
     let output = await runCommand(`git status --porcelain -uall ${context.args.join(" ")}`, {cwd: root});
     output = output.replace(/\s+$/, "");
     if (!output)
@@ -5557,19 +5560,90 @@ var GStatus = class extends import_coc6.BasicList {
 };
 var gstatus_default = GStatus;
 
+// src/lists/gchunks.ts
+var import_coc7 = __toModule(require("coc.nvim"));
+var import_safe3 = __toModule(require_safe());
+var GChunks = class extends import_coc7.BasicList {
+  constructor(nvim, manager) {
+    super(nvim);
+    this.manager = manager;
+    this.name = "gchunks";
+    this.description = "Git changes of current buffer";
+    this.defaultAction = "jump";
+    this.actions.push({
+      name: "jump",
+      execute: (item) => {
+        if (Array.isArray(item))
+          return;
+        import_coc7.window.moveTo({line: Math.max(item.data.line - 1, 0), character: 0});
+      }
+    });
+  }
+  async loadItems(context) {
+    let buf = this.manager.getBuffer(context.buffer.id);
+    if (!buf) {
+      throw new Error(`Can't resolve git root.`);
+      return;
+    }
+    let res = [];
+    let diffs = buf.cachedDiffs;
+    if (diffs && diffs.length > 0) {
+      for (let diff of diffs) {
+        let stagedSign = " ";
+        res.push({
+          label: `${stagedSign} Line:${diff.start} ${diff.lines[0]}`,
+          sortText: `${diff.start}`,
+          data: {
+            line: diff.start
+          }
+        });
+      }
+    }
+    try {
+      let {relpath} = buf;
+      let stagedDiff = await buf.repo.getStagedChunks(relpath);
+      let chunks = Object.values(stagedDiff)[0];
+      if (chunks.length > 0) {
+        for (let diff 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) {
+              break;
+            }
+            adjust += diff2.added.count;
+            adjust -= diff2.removed.count;
+          }
+          line += adjust;
+          res.push({
+            label: `${stagedSign} Line:${line} ${diff.lines[0]}`,
+            data: {
+              line: `${line}`
+            }
+          });
+        }
+      }
+    } catch (e) {
+    }
+    return res;
+  }
+};
+var gchunks_default = GChunks;
+
 // src/manager.ts
-var import_coc8 = __toModule(require("coc.nvim"));
+var import_coc9 = __toModule(require("coc.nvim"));
 var import_debounce = __toModule(require_debounce());
 
 // src/model/status.ts
-var import_coc7 = __toModule(require("coc.nvim"));
+var import_coc8 = __toModule(require("coc.nvim"));
 var GitStatus = class {
   constructor(service) {
     this.service = service;
     this.disposables = [];
     this._enabled = false;
-    this.mutex = new import_coc7.Mutex();
-    let config = import_coc7.workspace.getConfiguration("git");
+    this.mutex = new import_coc8.Mutex();
+    let config = import_coc8.workspace.getConfiguration("git");
     this._enabled = config.get("enableGlobalStatus", true);
     this.branchCharacter = config.get("branchCharacter", "");
     this.characters = {
@@ -5578,10 +5652,10 @@ var GitStatus = class {
       stagedDecorator: config.get("stagedDecorator"),
       untrackedDecorator: config.get("untrackedDecorator")
     };
-    import_coc7.events.on("BufEnter", this.refresh, this, this.disposables);
-    import_coc7.events.on("FocusGained", this.refresh, this, this.disposables);
+    import_coc8.events.on("BufEnter", this.refresh, this, this.disposables);
+    import_coc8.events.on("FocusGained", this.refresh, this, this.disposables);
     let timer;
-    import_coc7.events.on("BufWritePost", () => {
+    import_coc8.events.on("BufWritePost", () => {
       timer = setTimeout(() => {
         this.refresh();
       }, 300);
@@ -5616,14 +5690,14 @@ var GitStatus = class {
     if (this.gitStatus == status)
       return;
     this.gitStatus = status;
-    let {nvim} = import_coc7.workspace;
+    let {nvim} = import_coc8.workspace;
     nvim.pauseNotification();
     nvim.setVar("coc_git_status", status, true);
     nvim.call("coc#util#do_autocmd", ["CocGitStatusChange"], true);
     nvim.resumeNotification(false, true);
   }
   dispose() {
-    import_coc7.disposeAll(this.disposables);
+    import_coc8.disposeAll(this.disposables);
   }
 };
 var status_default = GitStatus;
@@ -5659,12 +5733,12 @@ var DocumentManager = class {
     this.disposables = [];
     this.defined = false;
     this.loadConfiguration();
-    import_coc8.workspace.onDidChangeConfiguration(this.loadConfiguration, this, this.disposables);
+    import_coc9.workspace.onDidChangeConfiguration(this.loadConfiguration, this, this.disposables);
     this.gitStatus = new status_default(service);
     const createBuffer = (doc) => {
       let {uri} = doc;
       service.createBuffer(doc, this.config).then((buf) => {
-        if (!buf || import_coc8.workspace.getDocument(uri) == null)
+        if (!buf || import_coc9.workspace.getDocument(uri) == null)
           return;
         this.defineSigns().catch((e) => {
           console.error(e.message);
@@ -5672,43 +5746,43 @@ var DocumentManager = class {
         this.buffers.set(doc.bufnr, buf);
       });
     };
-    for (let doc of import_coc8.workspace.documents) {
+    for (let doc of import_coc9.workspace.documents) {
       createBuffer(doc);
     }
-    import_coc8.workspace.onDidOpenTextDocument(async (e) => {
-      createBuffer(import_coc8.workspace.getDocument(e.bufnr));
+    import_coc9.workspace.onDidOpenTextDocument(async (e) => {
+      createBuffer(import_coc9.workspace.getDocument(e.bufnr));
     }, null, this.disposables);
-    import_coc8.workspace.onDidChangeTextDocument(async (e) => {
+    import_coc9.workspace.onDidChangeTextDocument(async (e) => {
       let buf = this.buffers.get(e.bufnr);
       if (buf)
         buf.refresh();
     }, null, this.disposables);
-    import_coc8.workspace.onDidCloseTextDocument((e) => {
+    import_coc9.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);
-    import_coc8.events.on("CursorMoved", import_debounce.default(async (bufnr, cursor) => {
+    import_coc9.events.on("CursorMoved", import_debounce.default(async (bufnr, cursor) => {
       let buf = this.buffers.get(bufnr);
       if (buf)
         await buf.showBlameInfo(cursor[0]);
     }, 100), null, this.disposables);
-    import_coc8.events.on("BufWritePre", (bufnr) => {
+    import_coc9.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_coc8.events.on("FocusGained", async () => {
+    import_coc9.events.on("FocusGained", async () => {
       let bufnr = await nvim.call("bufnr", ["%"]);
       let buf = this.buffers.get(bufnr);
       if (buf)
         buf.refresh();
     }, null, this.disposables);
-    import_coc8.events.on("BufEnter", (bufnr) => {
+    import_coc9.events.on("BufEnter", (bufnr) => {
       let buf = this.buffers.get(bufnr);
       if (buf)
         buf.refresh();
@@ -5719,7 +5793,7 @@ var DocumentManager = class {
       return;
     this.defined = true;
     let {nvim} = this;
-    const config = import_coc8.workspace.getConfiguration("git");
+    const config = import_coc9.workspace.getConfiguration("git");
     let items = ["Changed", "Added", "Removed", "TopRemoved", "ChangeRemoved"];
     nvim.pauseNotification();
     for (let item of items) {
@@ -5734,13 +5808,13 @@ var DocumentManager = class {
   loadConfiguration(e) {
     if (e && !e.affectsConfiguration("git"))
       return;
-    let config = import_coc8.workspace.getConfiguration("git");
+    let config = import_coc9.workspace.getConfiguration("git");
     let obj = {
       remoteName: config.get("remoteName", "origin"),
       diffRevision: config.get("diffRevision", ""),
       issueFormat: config.get("issueFormat", "#%i"),
       virtualTextPrefix: config.get("virtualTextPrefix", "     "),
-      addGBlameToVirtualText: import_coc8.workspace.nvim.hasFunction("nvim_buf_set_virtual_text") && config.get("addGBlameToVirtualText", false),
+      addGBlameToVirtualText: import_coc9.workspace.nvim.hasFunction("nvim_buf_set_virtual_text") && config.get("addGBlameToVirtualText", false),
       addGBlameToBufferVar: config.get("addGBlameToBufferVar", false),
       blameUseRealTime: config.get("blameUseRealTime", false),
       enableGutters: config.get("enableGutters", true),
@@ -5774,6 +5848,9 @@ var DocumentManager = class {
         currentHlGroup: config.get("conflict.current.hlGroup", "DiffChange"),
         incomingHlGroup: config.get("conflict.incoming.hlGroup", "DiffAdd")
       },
+      gstatus: {
+        saveBeforeOpen: config.get("gstatus.saveBeforeOpen", false)
+      },
       virtualTextSrcId: this.virtualTextSrcId,
       conflictSrcId: this.conflictSrcId
     };
@@ -5782,12 +5859,15 @@ var DocumentManager = class {
   get enableGutters() {
     return this.config.enableGutters;
   }
+  get gstatusSaveBeforeOpen() {
+    return this.config.gstatus.saveBeforeOpen;
+  }
   get git() {
     return this.service.git;
   }
   async toggleGutters() {
     let enabled = this.enableGutters;
-    let config = import_coc8.workspace.getConfiguration("git");
+    let config = import_coc9.workspace.getConfiguration("git");
     config.update("enableGutters", !enabled, true);
     for (let buf of this.buffers.values()) {
       await buf.toggleGutters(!enabled);
@@ -5799,7 +5879,7 @@ var DocumentManager = class {
       await buf.toggleFold();
   }
   async resolveGitRootFromBufferOrCwd(bufnr) {
-    let doc = import_coc8.workspace.getDocument(bufnr);
+    let doc = import_coc9.workspace.getDocument(bufnr);
     let root;
     let {resolver} = this.service;
     if (doc) {
@@ -5901,36 +5981,36 @@ var DocumentManager = class {
     }
   }
   async push(args) {
-    let bufnr = await import_coc8.workspace.nvim.call("bufnr", "%");
+    let bufnr = await import_coc9.workspace.nvim.call("bufnr", "%");
     let root = await this.resolveGitRootFromBufferOrCwd(bufnr);
     let extra = this.config.pushArguments;
     if (!root) {
-      import_coc8.window.showMessage(`not belongs to git repository.`, "warning");
+      import_coc9.window.showMessage(`not belongs to git repository.`, "warning");
       return;
     }
     if (args && args.length) {
-      await import_coc8.window.runTerminalCommand(`git push ${[...args, ...extra].join(" ")}`, root, true);
+      await import_coc9.window.runTerminalCommand(`git push ${[...args, ...extra].join(" ")}`, root, true);
       return;
     }
     let repo = this.service.getRepoFromRoot(root);
     let output = await repo.safeRun(["remote"]);
     let remote = output.trim().split(/\r?\n/)[0];
     if (!remote) {
-      import_coc8.window.showMessage(`remote not found`, "warning");
+      import_coc9.window.showMessage(`remote not found`, "warning");
       return;
     }
     output = await repo.safeRun(["rev-parse", "--abbrev-ref", "HEAD"]);
     if (!output) {
-      import_coc8.window.showMessage(`current branch not found`, "warning");
+      import_coc9.window.showMessage(`current branch not found`, "warning");
       return;
     }
-    await import_coc8.window.runTerminalCommand(`git push ${remote} ${output}${extra.length ? " " + extra.join(" ") : ""}`, root, true);
+    await import_coc9.window.runTerminalCommand(`git push ${remote} ${output}${extra.length ? " " + extra.join(" ") : ""}`, root, true);
   }
   get buffer() {
-    return import_coc8.workspace.nvim.call("bufnr", "%").then((bufnr) => {
+    return import_coc9.workspace.nvim.call("bufnr", "%").then((bufnr) => {
       let buf = this.buffers.get(bufnr);
       if (!buf)
-        import_coc8.window.showMessage(`Cant't resolve git repository for current buffer.`, "warning");
+        import_coc9.window.showMessage(`Cant't resolve git repository for current buffer.`, "warning");
       return buf;
     });
   }
@@ -5944,13 +6024,13 @@ var DocumentManager = class {
       buf.dispose();
     }
     this.buffers.clear();
-    import_coc8.disposeAll(this.disposables);
+    import_coc9.disposeAll(this.disposables);
   }
 };
 var manager_default = DocumentManager;
 
 // src/model/service.ts
-var import_coc12 = __toModule(require("coc.nvim"));
+var import_coc13 = __toModule(require("coc.nvim"));
 
 // src/model/repo.ts
 var import_fs2 = __toModule(require("fs"));
@@ -6223,7 +6303,7 @@ function parseDiff(diffStr) {
 
 // src/model/git.ts
 var cp = __toModule(require("child_process"));
-var import_coc9 = __toModule(require("coc.nvim"));
+var import_coc10 = __toModule(require("coc.nvim"));
 var import_iconv_lite = __toModule(require_lib());
 var import_path5 = __toModule(require("path"));
 var Git = class {
@@ -6300,11 +6380,11 @@ async function exec2(child, cancellationToken) {
   const disposables = [];
   const once = (ee, name, fn) => {
     ee.once(name, fn);
-    disposables.push(import_coc9.Disposable.create(() => ee.removeListener(name, fn)));
+    disposables.push(import_coc10.Disposable.create(() => ee.removeListener(name, fn)));
   };
   const on = (ee, name, fn) => {
     ee.on(name, fn);
-    disposables.push(import_coc9.Disposable.create(() => ee.removeListener(name, fn)));
+    disposables.push(import_coc10.Disposable.create(() => ee.removeListener(name, fn)));
   };
   let result = Promise.all([
     new Promise((c, e) => {
@@ -6338,12 +6418,12 @@ async function exec2(child, cancellationToken) {
     const [exitCode, stdout, stderr] = await result;
     return {exitCode, stdout, stderr};
   } finally {
-    import_coc9.disposeAll(disposables);
+    import_coc10.disposeAll(disposables);
   }
 }
 
 // src/model/resolver.ts
-var import_coc10 = __toModule(require("coc.nvim"));
+var import_coc11 = __toModule(require("coc.nvim"));
 var import_fs3 = __toModule(require("fs"));
 var import_path6 = __toModule(require("path"));
 var import_util9 = __toModule(require("util"));
@@ -6354,7 +6434,7 @@ async function getRealPath(fullpath) {
   } catch (e) {
     if (e.message.includes("ENOENT")) {
       try {
-        resolved = await import_coc10.workspace.nvim.call("expand", [fullpath]);
+        resolved = await import_coc11.workspace.nvim.call("expand", [fullpath]);
       } catch (e2) {
       }
     }
@@ -6395,7 +6475,7 @@ var Resolver = class {
     if (doc.buftype != "" || doc.schema != "file") {
       return null;
     }
-    let fullpath = await getRealPath(import_coc10.Uri.parse(uri).fsPath);
+    let fullpath = await getRealPath(import_coc11.Uri.parse(uri).fsPath);
     if (process.platform == "win32") {
       fullpath = import_path6.default.win32.normalize(fullpath);
     }
@@ -6424,12 +6504,12 @@ var Resolver = class {
     return root;
   }
   async resolveRootFromCwd() {
-    let parts = import_coc10.workspace.cwd.split(import_path6.default.sep);
+    let parts = import_coc11.workspace.cwd.split(import_path6.default.sep);
     let idx = parts.indexOf(".git");
     if (idx !== -1)
       return parts.slice(0, idx).join(import_path6.default.sep);
     try {
-      return await this.git.getRepositoryRoot(import_coc10.workspace.cwd);
+      return await this.git.getRepositoryRoot(import_coc11.workspace.cwd);
     } catch (e) {
     }
     return null;
@@ -6442,7 +6522,7 @@ var Resolver = class {
 var resolver_default = Resolver;
 
 // src/model/buffer.ts
-var import_coc11 = __toModule(require("coc.nvim"));
+var import_coc12 = __toModule(require("coc.nvim"));
 
 // node_modules/timeago.js/esm/lang/en_US.js
 var EN_US = ["second", "minute", "hour", "day", "week", "month", "year"];
@@ -6540,7 +6620,7 @@ var GitBuffer = class {
     this.hasConflicts = false;
     this.foldEnabled = false;
     this._disposed = false;
-    this.mutex = new import_coc11.Mutex();
+    this.mutex = new import_coc12.Mutex();
     this.refresh = import_debounce2.default(() => {
       this._refresh().catch((e) => {
         channel.append(`[Error] ${e.message}`);
@@ -6585,7 +6665,7 @@ var GitBuffer = class {
     });
   }
   async chunkUndo() {
-    let line = await import_coc11.workspace.nvim.call("line", ".");
+    let line = await import_coc12.workspace.nvim.call("line", ".");
     let diff = this.getChunk(line);
     if (!diff)
       return;
@@ -6605,10 +6685,10 @@ var GitBuffer = class {
   }
   async chunkStage() {
     let relpath = toUnixSlash(this.relpath);
-    let line = await import_coc11.workspace.nvim.call("line", ".");
+    let line = await import_coc12.workspace.nvim.call("line", ".");
     let diff = this.getChunk(line);
     if (!diff) {
-      import_coc11.window.showMessage("Not positioned in git chunk", "error");
+      import_coc12.window.showMessage("Not positioned in git chunk", "error");
       return;
     }
     let head;
@@ -6636,7 +6716,7 @@ var GitBuffer = class {
     }
   }
   async chunkUnstage() {
-    let {nvim} = import_coc11.workspace;
+    let {nvim} = import_coc12.workspace;
     const {diffs} = this;
     let line = await nvim.call("line", ".");
     let adjust = 0;
@@ -6644,7 +6724,7 @@ var GitBuffer = class {
     for (let diff of diffs) {
       if (diff.end >= line) {
         if (diff.start <= line && diff.changeType != ChangeType.Delete) {
-          import_coc11.window.showErrorMessage(`Current line contains unstaged change.`);
+          import_coc12.window.showErrorMessage(`Current line contains unstaged change.`);
           invalid = true;
         }
         break;
@@ -6658,12 +6738,12 @@ var GitBuffer = class {
     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`);
+      import_coc12.window.showErrorMessage(`Staged chunk not found`);
       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`);
+      import_coc12.window.showErrorMessage(`Unable to find staged chunk on current line`);
       return;
     }
     this.channel.appendLine(`[Info] resolved chunk ${JSON.stringify(chunk, null, 2)}`);
@@ -6674,52 +6754,77 @@ var GitBuffer = class {
       await this.git.exec(this.repo.root, ["apply", "--cached", "--unidiff-zero", "-"], {input: patch});
       this.refresh();
     } catch (e) {
-      import_coc11.window.showErrorMessage(`Unable to apply patch: ${e.message}`);
+      import_coc12.window.showErrorMessage(`Unable to apply patch: ${e.message}`);
       this.channel.appendLine(`[Error] ${e.message}`);
     }
   }
   async nextChunk() {
     const {diffs} = this;
-    let {nvim} = import_coc11.workspace;
+    let {nvim} = import_coc12.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});
+        await import_coc12.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});
+      await import_coc12.window.moveTo({line: Math.max(diffs[0].start - 1, 0), character: 0});
     }
   }
   async prevChunk() {
-    const {nvim} = import_coc11.workspace;
+    const {nvim} = import_coc12.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});
+        await import_coc12.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[diffs.length - 1].start - 1, 0), character: 0});
+      await import_coc12.window.moveTo({line: Math.max(diffs[diffs.length - 1].start - 1, 0), character: 0});
     }
   }
   async chunkInfo() {
-    let line = await import_coc11.workspace.nvim.call("line", ".");
+    let line = await import_coc12.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 chagnes\n" + chunk.lines.join("\n");
+        await this.showDoc(content, "diff");
+      }
     }
   }
   async showBlameInfo(lnum) {
-    let {nvim} = import_coc11.workspace;
+    let {nvim} = import_coc12.workspace;
     let {virtualTextSrcId, addGBlameToBufferVar, addGBlameToVirtualText} = this.config;
     if (!this.showBlame)
       return;
@@ -6751,7 +6856,7 @@ var GitBuffer = class {
       if (addGBlameToVirtualText) {
         const prefix = this.config.virtualTextPrefix;
         await buffer.clearNamespace(virtualTextSrcId);
-        if (import_coc11.workspace.has("nvim-0.6.0")) {
+        if (import_coc12.workspace.has("nvim-0.6.0")) {
           await buffer.setExtMark(virtualTextSrcId, lnum - 1, 0, {
             hl_mode: "combine",
             virt_text: [[prefix + blameText, "CocCodeLens"]]
@@ -6765,7 +6870,7 @@ var GitBuffer = class {
   async showBlameDoc(lnum) {
     let indexed = await this.repo.isIndexed(this.relpath);
     if (!indexed) {
-      import_coc11.window.showMessage("File not indexed");
+      import_coc12.window.showMessage("File not indexed");
     } else {
       let infos = await this.getBlameInfo();
       let info = infos.find((o) => lnum >= o.startLnum && lnum <= o.endLnum);
@@ -6776,13 +6881,13 @@ var GitBuffer = class {
         blameText.push(`${info.sha.substring(0, 7)}`);
         await this.showDoc(blameText.join("\n\n"), "text");
       } else {
-        import_coc11.window.showMessage("Not committed yet");
+        import_coc12.window.showMessage("Not committed yet");
       }
     }
   }
   async diffDocument(force = false) {
     var _a;
-    let {nvim} = import_coc11.workspace;
+    let {nvim} = import_coc12.workspace;
     let revision = this.config.diffRevision;
     const {bufnr} = this.doc;
     const diffs = await this.repo.getDiff(this.relpath, this.doc.content, revision);
@@ -6861,7 +6966,7 @@ var GitBuffer = class {
       return;
     if (!this.config.enableGutters)
       return;
-    let {nvim} = import_coc11.workspace;
+    let {nvim} = import_coc12.workspace;
     let {bufnr} = this.doc;
     let {signPriority} = this.config;
     let signs = this.currentSigns;
@@ -6934,10 +7039,10 @@ var GitBuffer = class {
   async diffCached() {
     let res = await this.repo.safeRun(["diff", "--cached"]);
     if (!res.trim()) {
-      import_coc11.window.showMessage("Empty diff");
+      import_coc12.window.showMessage("Empty diff");
       return;
     }
-    let {nvim} = import_coc11.workspace;
+    let {nvim} = import_coc12.workspace;
     nvim.pauseNotification();
     nvim.command(`keepalt above new +setl\\ previewwindow`, true);
     nvim.call("append", [0, res.split(/\r?\n/)], true);
@@ -6948,44 +7053,44 @@ var GitBuffer = class {
     await nvim.resumeNotification();
   }
   async nextConflict() {
-    let {nvim} = import_coc11.workspace;
+    let {nvim} = import_coc12.workspace;
     if (!this.conflicts.length) {
-      import_coc11.window.showMessage("No conflicts detected", "warning");
+      import_coc12.window.showMessage("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});
+        await import_coc12.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});
+      await import_coc12.window.moveTo({line: Math.max(this.conflicts[0].start - 1, 0), character: 0});
     }
   }
   async prevConflict() {
-    let {nvim} = import_coc11.workspace;
+    let {nvim} = import_coc12.workspace;
     if (!this.conflicts.length) {
-      import_coc11.window.showMessage("No conflicts detected", "warning");
+      import_coc12.window.showMessage("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});
+        await import_coc12.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});
+      await import_coc12.window.moveTo({line: Math.max(this.conflicts[0].start - 1, 0), character: 0});
     }
   }
   async conflictKeepPart(part) {
-    const {nvim} = import_coc11.workspace;
+    const {nvim} = import_coc12.workspace;
     let conflicts = this.conflicts;
     if (!conflicts || conflicts.length == 0) {
-      import_coc11.window.showMessage("No conflicts detected");
+      import_coc12.window.showMessage("No conflicts detected");
       return;
     }
     let line = await nvim.call("line", ".");
@@ -7005,11 +7110,11 @@ var GitBuffer = class {
         }
       }
     }
-    import_coc11.window.showMessage("Not positioned on a conflict");
+    import_coc12.window.showMessage("Not positioned on a conflict");
   }
   async browser(action = "open", range, permalink = false) {
-    let {nvim} = import_coc11.workspace;
-    let config = import_coc11.workspace.getConfiguration("git");
+    let {nvim} = import_coc12.workspace;
+    let config = import_coc12.workspace.getConfiguration("git");
     let head = (await this.repo.safeRun(["rev-parse", "HEAD"])).trim();
     let branch = config.get("browserBranchName", "").trim();
     if (!branch.length) {
@@ -7028,7 +7133,7 @@ var GitBuffer = class {
     }
     let output = await this.repo.safeRun(["remote"]);
     if (!output.trim()) {
-      import_coc11.window.showMessage(`No remote found`, "warning");
+      import_coc12.window.showMessage(`No remote found`, "warning");
       return;
     }
     let names = output.trim().split(/\r?\n/);
@@ -7037,7 +7142,7 @@ var GitBuffer = class {
       if (names.includes(browserRemoteName)) {
         names = [browserRemoteName];
       } else {
-        import_coc11.window.showMessage("Configured git.browserRemoteName missing from remote list", "warning");
+        import_coc12.window.showMessage("Configured git.browserRemoteName missing from remote list", "warning");
         return;
       }
     }
@@ -7060,19 +7165,19 @@ var GitBuffer = class {
     }
     if (urls.length == 1) {
       if (action == "open") {
-        await import_coc11.workspace.openResource(urls[0]);
+        await import_coc12.workspace.openResource(urls[0]);
       } else {
         nvim.command(`let @+ = '${urls[0]}'`, true);
-        import_coc11.window.showMessage("Copied url to clipboard");
+        import_coc12.window.showMessage("Copied url to clipboard");
       }
     } else if (urls.length > 1) {
-      let idx = await import_coc11.window.showQuickpick(urls, "Select url:");
+      let idx = await import_coc12.window.showQuickpick(urls, "Select url:");
       if (idx >= 0) {
         if (action == "open") {
-          await import_coc11.workspace.openResource(urls[idx]);
+          await import_coc12.workspace.openResource(urls[idx]);
         } else {
           nvim.command(`let @+ = '${urls[idx]}'`, true);
-          import_coc11.window.showMessage("Copied url to clipboard");
+          import_coc12.window.showMessage("Copied url to clipboard");
         }
       }
     }
@@ -7080,10 +7185,10 @@ var GitBuffer = class {
   async showCommit() {
     let indexed = await this.repo.isIndexed(this.relpath);
     if (!indexed) {
-      import_coc11.window.showMessage(`"${this.relpath}" not indexed.`, "warning");
+      import_coc12.window.showMessage(`"${this.relpath}" not indexed.`, "warning");
       return;
     }
-    let nvim = import_coc11.workspace.nvim;
+    let nvim = import_coc12.workspace.nvim;
     let line = await nvim.eval('line(".")');
     let args = ["--no-pager", "blame", "-l", "--root", "-t", `-L${line},${line}`, this.relpath];
     let res = await this.repo.exec(args);
@@ -7092,7 +7197,7 @@ var GitBuffer = class {
       return;
     let commit = output.match(/^\S+/)[0];
     if (/^0+$/.test(commit)) {
-      import_coc11.window.showMessage("not committed yet!", "warning");
+      import_coc12.window.showMessage("not committed yet!", "warning");
       return;
     }
     let useFloating = this.config.showCommitInFloating;
@@ -7123,16 +7228,16 @@ var GitBuffer = class {
     }
   }
   async toggleFold() {
-    let {nvim} = import_coc11.workspace;
+    let {nvim} = import_coc12.workspace;
     let buf = this.doc.buffer;
     let win = await nvim.window;
     let bufnr = buf.id;
-    let doc = import_coc11.workspace.getDocument(bufnr);
+    let doc = import_coc12.workspace.getDocument(bufnr);
     if (!doc)
       return;
     let infos = this.currentSigns;
     if (!infos || infos.length == 0) {
-      import_coc11.window.showMessage("No changes", "warning");
+      import_coc12.window.showMessage("No changes", "warning");
       return;
     }
     let lnums = infos.map((o) => o.lnum);
@@ -7190,7 +7295,7 @@ var GitBuffer = class {
   }
   async toggleGutters(enabled) {
     this.config.enableGutters = enabled;
-    let {nvim} = import_coc11.workspace;
+    let {nvim} = import_coc12.workspace;
     if (!enabled) {
       nvim.call("sign_unplace", [signGroup, {buffer: this.doc.bufnr}], true);
     } else {
@@ -7275,7 +7380,7 @@ var GitBuffer = class {
     let buffer = this.doc.buffer;
     let currentHlGroup = this.config.conflict.currentHlGroup;
     let incomingHlGroup = this.config.conflict.incomingHlGroup;
-    let {nvim} = import_coc11.workspace;
+    let {nvim} = import_coc12.workspace;
     nvim.pauseNotification();
     buffer.clearNamespace(this.config.conflictSrcId, 0, -1);
     conflicts.map((conflict) => {
@@ -7296,12 +7401,12 @@ var GitBuffer = class {
     nvim.resumeNotification(false, true);
   }
   async showDoc(content, filetype = "diff") {
-    if (import_coc11.workspace.floatSupported) {
+    if (import_coc12.workspace.floatSupported) {
       let docs = [{content, filetype}];
       await this.floatFactory.show(docs);
     } else {
       const lines = content.split("\n");
-      import_coc11.workspace.nvim.call("coc#util#preview_info", [lines, "diff"], true);
+      import_coc12.workspace.nvim.call("coc#util#preview_info", [lines, "diff"], true);
     }
   }
   setBufferStatus(status) {
@@ -7309,7 +7414,7 @@ var GitBuffer = class {
     if (exists == status)
       return;
     this.gitStatus = status;
-    let {nvim} = import_coc11.workspace;
+    let {nvim} = import_coc12.workspace;
     let buffer = nvim.createBuffer(this.doc.bufnr);
     nvim.pauseNotification();
     buffer.setVar("coc_git_status", status, true);
@@ -7335,7 +7440,7 @@ var GitBuffer = class {
     return this.config.addGBlameToVirtualText || this.config.addGBlameToBufferVar;
   }
   dispose() {
-    let {nvim} = import_coc11.workspace;
+    let {nvim} = import_coc12.workspace;
     let {bufnr} = this.doc;
     let buffer = nvim.createBuffer(bufnr);
     buffer.setVar("coc_git_status", "", true);
@@ -7363,10 +7468,10 @@ var import_path7 = __toModule(require("path"));
 var GitService = class {
   constructor(gitInfo) {
     this.repos = new Map();
-    const outputChannel = this.outputChannel = import_coc12.window.createOutputChannel("git");
+    const outputChannel = this.outputChannel = import_coc13.window.createOutputChannel("git");
     this._git = new git_default(gitInfo, outputChannel);
     this._resolver = new resolver_default(this._git, outputChannel);
-    this.floatFactory = new import_coc12.FloatFactory(import_coc12.workspace.nvim);
+    this.floatFactory = new import_coc13.FloatFactory(import_coc13.workspace.nvim);
   }
   getRepoFromRoot(root) {
     if (this.repos.has(root)) {
@@ -7392,11 +7497,11 @@ var GitService = class {
     return new buffer_default(doc, config, relpath, repo, this.git, this.outputChannel, this.floatFactory);
   }
   async getCurrentRepo() {
-    let {nvim} = import_coc12.workspace;
+    let {nvim} = import_coc13.workspace;
     let [fullpath, buftype] = await nvim.eval('[expand("%:p"),&buftype]');
     if (!import_path7.default.isAbsolute(fullpath) || buftype != "")
       return void 0;
-    let root = await this.resolver.resolveGitRoot({uri: import_coc12.Uri.file(fullpath).toString(), schema: "file", buftype: ""});
+    let root = await this.resolver.resolveGitRoot({uri: import_coc13.Uri.file(fullpath).toString(), schema: "file", buftype: ""});
     if (root == null)
       return void 0;
     return this.getRepoFromRoot(root);
@@ -7420,15 +7525,15 @@ var GitService = class {
 var service_default = GitService;
 
 // src/source.ts
-var import_coc13 = __toModule(require("coc.nvim"));
-var import_safe3 = __toModule(require_safe());
+var import_coc14 = __toModule(require("coc.nvim"));
+var import_safe4 = __toModule(require_safe());
 function byteSlice(content, start, end) {
   let buf = Buffer.from(content, "utf8");
   return buf.slice(start, end).toString("utf8");
 }
 var issuesMap = new Map();
 function issuesFiletypes() {
-  return import_coc13.workspace.getConfiguration().get("coc.source.issues.filetypes");
+  return import_coc14.workspace.getConfiguration().get("coc.source.issues.filetypes");
 }
 function getOrganizationNameAndRepoNameFromGitHubRemoteUrl(remoteUrl) {
   try {
@@ -7467,7 +7572,7 @@ function renderWord(issue, issueFormat) {
 }
 function addSource(context, resolver) {
   let {subscriptions, logger} = context;
-  let statusItem = import_coc13.window.createStatusBarItem(0, {progress: true});
+  let statusItem = import_coc14.window.createStatusBarItem(0, {progress: true});
   statusItem.text = "loading issues";
   let statusItemCounter = 0;
   function onStartLoading() {
@@ -7510,7 +7615,7 @@ function addSource(context, resolver) {
       const pageUri = `${uri}&page=${pageIndex}`;
       pageIndex++;
       try {
-        let info = await import_coc13.fetch(pageUri, {headers: {"Private-Token": token}});
+        let info = await import_coc14.fetch(pageUri, {headers: {"Private-Token": token}});
         if (!info.length) {
           break;
         }
@@ -7546,7 +7651,7 @@ function addSource(context, resolver) {
       let page_uri = `${uri}&page=${page_idx}`;
       page_idx++;
       try {
-        let info = await import_coc13.fetch(page_uri, {headers});
+        let info = await import_coc14.fetch(page_uri, {headers});
         if (info.length == 0) {
           break;
         }
@@ -7571,7 +7676,7 @@ function addSource(context, resolver) {
     return issues;
   }
   async function loadIssues(root) {
-    let config = import_coc13.workspace.getConfiguration("git");
+    let config = import_coc14.workspace.getConfiguration("git");
     const issueSources = (await safeRun(`git config --get coc-git.issuesources`, {cwd: root}) || "").trim();
     if (issueSources) {
       return Array.prototype.concat.apply([], await Promise.all(issueSources.split(",").map((issueSource) => {
@@ -7614,14 +7719,14 @@ function addSource(context, resolver) {
       }
     }).catch(onError);
   };
-  for (let doc of import_coc13.workspace.documents) {
+  for (let doc of import_coc14.workspace.documents) {
     if (issuesFiletypes().includes(doc.filetype)) {
       loadIssuesFromDocument(doc);
     }
   }
-  import_coc13.workspace.onDidOpenTextDocument(async (e) => {
+  import_coc14.workspace.onDidOpenTextDocument(async (e) => {
     if (issuesFiletypes().includes(e.languageId)) {
-      let doc = import_coc13.workspace.getDocument(e.uri);
+      let doc = import_coc14.workspace.getDocument(e.uri);
       loadIssuesFromDocument(doc);
     }
   }, null, subscriptions);
@@ -7630,7 +7735,7 @@ function addSource(context, resolver) {
     async doComplete(opt) {
       let pre = byteSlice(opt.line, 0, opt.colnr - 1);
       if (pre && pre.endsWith("#")) {
-        const config = import_coc13.workspace.getConfiguration("git");
+        const config = import_coc14.workspace.getConfiguration("git");
         const issueFormat = config.get("issueFormat", "#%i");
         let issues = issuesMap.get(opt.bufnr);
         if (!issues || issues.length == 0)
@@ -7656,14 +7761,14 @@ function addSource(context, resolver) {
       };
     }
   };
-  subscriptions.push(import_coc13.sources.createSource(source));
+  subscriptions.push(import_coc14.sources.createSource(source));
   let list = {
     name: "issues",
     actions: [{
       name: "open",
       execute: async (item) => {
         let {url} = item.data;
-        await import_coc13.workspace.openResource(url);
+        await import_coc14.workspace.openResource(url);
       },
       multiple: false
     }, {
@@ -7673,7 +7778,7 @@ function addSource(context, resolver) {
         let {body, id} = item.data;
         let lines = body.split(/\r?\n/);
         let mod = context2.options.position == "top" ? "below" : "above";
-        let {nvim} = import_coc13.workspace;
+        let {nvim} = import_coc14.workspace;
         nvim.pauseNotification();
         nvim.command("pclose", true);
         nvim.command(`${mod} ${lines.length}sp +setl\\ previewwindow [issue ${id}]`, true);
@@ -7692,141 +7797,142 @@ function addSource(context, resolver) {
     description: "issues on github/gitlab",
     loadItems: async (context2) => {
       let buf = await context2.window.buffer;
-      let root = await resolver.resolveGitRoot(import_coc13.workspace.getDocument(buf.id));
+      let root = await resolver.resolveGitRoot(import_coc14.workspace.getDocument(buf.id));
       if (!root)
         return [];
       let issues = await loadIssues(root);
       return issues.map((o) => {
         return {
-          label: `${import_safe3.default.red("#" + o.id.toFixed(0))} ${o.title} (${import_safe3.default.green(o.createAt.toUTCString())}) <${import_safe3.default.blue(o.creator)}>`,
+          label: `${import_safe4.default.red("#" + o.id.toFixed(0))} ${o.title} (${import_safe4.default.green(o.createAt.toUTCString())}) <${import_safe4.default.blue(o.creator)}>`,
           data: {id: o.id, url: o.url, body: o.body}
         };
       });
     }
   };
-  subscriptions.push(import_coc13.listManager.registerList(list));
+  subscriptions.push(import_coc14.listManager.registerList(list));
 }
 
 // src/index.ts
 async function activate(context) {
-  const config = import_coc14.workspace.getConfiguration("git");
+  const config = import_coc15.workspace.getConfiguration("git");
   const {subscriptions} = context;
   let gitInfo;
   try {
     let pathHint = config.get("command");
     gitInfo = await findGit(pathHint, (path8) => context.logger.info(`Looking for git in: ${path8}`));
   } catch (e) {
-    import_coc14.window.showMessage("git command required for coc-git", "error");
+    import_coc15.window.showMessage("git command required for coc-git", "error");
     return;
   }
-  const virtualTextSrcId = await import_coc14.workspace.nvim.createNamespace("coc-git-virtual");
-  const conflictSrcId = await import_coc14.workspace.nvim.createNamespace("coc-git-conflicts");
-  const {nvim} = import_coc14.workspace;
+  const virtualTextSrcId = await import_coc15.workspace.nvim.createNamespace("coc-git-virtual");
+  const conflictSrcId = await import_coc15.workspace.nvim.createNamespace("coc-git-conflicts");
+  const {nvim} = import_coc15.workspace;
   const service = new service_default(gitInfo);
   const manager = new manager_default(nvim, service, virtualTextSrcId, conflictSrcId);
   subscriptions.push(manager);
   addSource(context, service.resolver);
-  subscriptions.push(import_coc14.commands.registerCommand("git.refresh", () => {
+  subscriptions.push(import_coc15.commands.registerCommand("git.refresh", () => {
     manager.refresh();
   }));
-  subscriptions.push(import_coc14.workspace.registerKeymap(["n"], "git-nextchunk", async () => {
+  subscriptions.push(import_coc15.workspace.registerKeymap(["n"], "git-nextchunk", async () => {
     await manager.nextChunk();
   }, {sync: false}));
-  subscriptions.push(import_coc14.workspace.registerKeymap(["n"], "git-prevchunk", async () => {
+  subscriptions.push(import_coc15.workspace.registerKeymap(["n"], "git-prevchunk", async () => {
     await manager.prevChunk();
   }, {sync: false}));
-  subscriptions.push(import_coc14.workspace.registerKeymap(["n"], "git-nextconflict", async () => {
+  subscriptions.push(import_coc15.workspace.registerKeymap(["n"], "git-nextconflict", async () => {
     await manager.nextConflict();
   }, {sync: false}));
-  subscriptions.push(import_coc14.workspace.registerKeymap(["n"], "git-prevconflict", async () => {
+  subscriptions.push(import_coc15.workspace.registerKeymap(["n"], "git-prevconflict", async () => {
     await manager.prevConflict();
   }, {sync: false}));
-  subscriptions.push(import_coc14.workspace.registerKeymap(["n"], "git-keepcurrent", async () => {
+  subscriptions.push(import_coc15.workspace.registerKeymap(["n"], "git-keepcurrent", async () => {
     await manager.keepCurrent();
   }, {sync: false}));
-  subscriptions.push(import_coc14.workspace.registerKeymap(["n"], "git-keepincoming", async () => {
+  subscriptions.push(import_coc15.workspace.registerKeymap(["n"], "git-keepincoming", async () => {
     await manager.keepIncoming();
   }, {sync: false}));
-  subscriptions.push(import_coc14.workspace.registerKeymap(["n"], "git-keepboth", async () => {
+  subscriptions.push(import_coc15.workspace.registerKeymap(["n"], "git-keepboth", async () => {
     await manager.keepBoth();
   }, {sync: false}));
-  subscriptions.push(import_coc14.workspace.registerKeymap(["n"], "git-chunkinfo", async () => {
+  subscriptions.push(import_coc15.workspace.registerKeymap(["n"], "git-chunkinfo", async () => {
     await manager.chunkInfo();
   }, {sync: false}));
-  subscriptions.push(import_coc14.workspace.registerKeymap(["n"], "git-commit", async () => {
+  subscriptions.push(import_coc15.workspace.registerKeymap(["n"], "git-commit", async () => {
     await manager.showCommit();
   }, {sync: false}));
-  subscriptions.push(import_coc14.workspace.registerKeymap(["n"], "git-showblamedoc", async () => {
+  subscriptions.push(import_coc15.workspace.registerKeymap(["n"], "git-showblamedoc", async () => {
     await manager.showBlameDoc();
   }, {sync: false}));
-  subscriptions.push(import_coc14.commands.registerCommand("git.keepCurrent", async () => {
+  subscriptions.push(import_coc15.commands.registerCommand("git.keepCurrent", async () => {
     await manager.keepCurrent();
   }));
-  subscriptions.push(import_coc14.commands.registerCommand("git.keepIncoming", async () => {
+  subscriptions.push(import_coc15.commands.registerCommand("git.keepIncoming", async () => {
     await manager.keepIncoming();
   }));
-  subscriptions.push(import_coc14.commands.registerCommand("git.keepBoth", async () => {
+  subscriptions.push(import_coc15.commands.registerCommand("git.keepBoth", async () => {
     await manager.keepBoth();
   }));
-  subscriptions.push(import_coc14.commands.registerCommand("git.chunkInfo", async () => {
+  subscriptions.push(import_coc15.commands.registerCommand("git.chunkInfo", async () => {
     await manager.chunkInfo();
   }));
-  subscriptions.push(import_coc14.commands.registerCommand("git.chunkStage", async () => {
+  subscriptions.push(import_coc15.commands.registerCommand("git.chunkStage", async () => {
     await manager.chunkStage();
   }));
-  subscriptions.push(import_coc14.commands.registerCommand("git.chunkUnstage", async () => {
+  subscriptions.push(import_coc15.commands.registerCommand("git.chunkUnstage", async () => {
     await manager.chunkUnstage();
   }));
-  subscriptions.push(import_coc14.commands.registerCommand("git.chunkUndo", async () => {
+  subscriptions.push(import_coc15.commands.registerCommand("git.chunkUndo", async () => {
     await manager.chunkUndo();
   }));
-  subscriptions.push(import_coc14.commands.registerCommand("git.showCommit", async () => {
+  subscriptions.push(import_coc15.commands.registerCommand("git.showCommit", async () => {
     await manager.showCommit();
   }));
-  subscriptions.push(import_coc14.commands.registerCommand("git.browserOpen", async () => {
+  subscriptions.push(import_coc15.commands.registerCommand("git.browserOpen", async () => {
     await manager.browser();
   }));
-  subscriptions.push(import_coc14.commands.registerCommand("git.copyUrl", async (...args) => {
+  subscriptions.push(import_coc15.commands.registerCommand("git.copyUrl", async (...args) => {
     await manager.browser("copy", args);
   }));
-  subscriptions.push(import_coc14.commands.registerCommand("git.copyPermalink", async (...args) => {
+  subscriptions.push(import_coc15.commands.registerCommand("git.copyPermalink", async (...args) => {
     await manager.browser("copy", args, true);
   }));
-  subscriptions.push(import_coc14.commands.registerCommand("git.push", async (...args) => {
+  subscriptions.push(import_coc15.commands.registerCommand("git.push", async (...args) => {
     await manager.push(args);
   }));
-  subscriptions.push(import_coc14.commands.registerCommand("git.diffCached", async () => {
+  subscriptions.push(import_coc15.commands.registerCommand("git.diffCached", async () => {
     await manager.diffCached();
   }));
-  subscriptions.push(import_coc14.commands.registerCommand("git.toggleGutters", async () => {
+  subscriptions.push(import_coc15.commands.registerCommand("git.toggleGutters", async () => {
     await manager.toggleGutters();
   }));
-  subscriptions.push(import_coc14.commands.registerCommand("git.foldUnchanged", async () => {
+  subscriptions.push(import_coc15.commands.registerCommand("git.foldUnchanged", async () => {
     await manager.toggleFold();
   }));
-  subscriptions.push(import_coc14.commands.registerCommand("git.showBlameDoc", async () => {
+  subscriptions.push(import_coc15.commands.registerCommand("git.showBlameDoc", async () => {
     await manager.showBlameDoc();
   }));
-  subscriptions.push(import_coc14.listManager.registerList(new gstatus_default(nvim, manager)));
-  subscriptions.push(import_coc14.listManager.registerList(new branches_default(nvim, manager)));
-  subscriptions.push(import_coc14.listManager.registerList(new commits_default(nvim, manager)));
-  subscriptions.push(import_coc14.listManager.registerList(new bcommits_default(nvim, manager)));
-  subscriptions.push(import_coc14.listManager.registerList(new gfiles_default(nvim, manager)));
-  subscriptions.push(import_coc14.languages.registerCompletionItemProvider("semantic-commit", "Commit", config.get("semanticCommit.filetypes"), {
+  subscriptions.push(import_coc15.listManager.registerList(new gstatus_default(nvim, manager)));
+  subscriptions.push(import_coc15.listManager.registerList(new branches_default(nvim, manager)));
+  subscriptions.push(import_coc15.listManager.registerList(new commits_default(nvim, manager)));
+  subscriptions.push(import_coc15.listManager.registerList(new bcommits_default(nvim, manager)));
+  subscriptions.push(import_coc15.listManager.registerList(new gfiles_default(nvim, manager)));
+  subscriptions.push(import_coc15.listManager.registerList(new gchunks_default(nvim, manager)));
+  subscriptions.push(import_coc15.languages.registerCompletionItemProvider("semantic-commit", "Commit", config.get("semanticCommit.filetypes"), {
     provideCompletionItems: async (document, position) => {
       if (position.line !== 0) {
         return [];
       }
-      const text = document.getText(import_coc14.Range.create(import_coc14.Position.create(position.line, 0), position));
+      const text = document.getText(import_coc15.Range.create(import_coc15.Position.create(position.line, 0), position));
       if (/^[a-z]*$/.test(text)) {
         const scope = config.get("semanticCommit.scope");
         const text2 = scope ? "(${1:scope}): ${2:commit}" : ": ${1:commit}";
         return DEFAULT_TYPES.map((o) => {
           return {
             label: o.value,
-            kind: import_coc14.CompletionItemKind.Snippet,
+            kind: import_coc15.CompletionItemKind.Snippet,
             documentation: {kind: "plaintext", value: o.name},
-            insertTextFormat: import_coc14.InsertTextFormat.Snippet,
+            insertTextFormat: import_coc15.InsertTextFormat.Snippet,
             insertText: o.value + text2 + "\n\n"
           };
         });
@@ -7834,13 +7940,13 @@ async function activate(context) {
       return [];
     }
   }));
-  subscriptions.push(import_coc14.workspace.registerKeymap(["o", "x"], "git-chunk-inner", async () => {
+  subscriptions.push(import_coc15.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_coc14.workspace.registerKeymap(["o", "x"], "git-chunk-outer", async () => {
+  subscriptions.push(import_coc15.workspace.registerKeymap(["o", "x"], "git-chunk-outer", async () => {
     let diff = await manager.getCurrentChunk();
     if (!diff)
       return;