coc-git 2.7.8 → 2.7.9

package/lib/index.js

@@ -5854,6 +5854,18 @@ var DocumentManager = class {
       nvim.command(`sign define CocGit${item} text=${text} texthl=CocGit${item}Sign`, true);
       nvim.command(`highlight default link CocGit${item}Sign ${hlGroup}`, true);
     }
+    const stagedItems = [
+      ["StagedAdded", "stagedAddedSign", "CocGitStagedAdd", "DiffAdd"],
+      ["StagedChanged", "stagedChangedSign", "CocGitStagedChange", "DiffChange"],
+      ["StagedRemoved", "stagedRemovedSign", "CocGitStagedDelete", "DiffDelete"],
+      ["Mixed", "mixedSign", "CocGitMixed", "WarningMsg"]
+    ];
+    for (let [item, section, defaultGroup, fallback] of stagedItems) {
+      let text = config.get(`${section}.text`, "");
+      let hlGroup = config.get(`${section}.hlGroup`, defaultGroup);
+      nvim.command(`sign define CocGit${item} text=${text} texthl=${hlGroup}`, true);
+      nvim.command(`highlight default link ${hlGroup} ${fallback}`, true);
+    }
     await nvim.resumeNotification();
   }
   loadConfiguration(e) {
@@ -5873,8 +5885,10 @@ var DocumentManager = class {
       blameUseRealTime: config.get("blameUseRealTime", false),
       enableGutters: config.get("enableGutters", true),
       realtimeGutters: config.get("realtimeGutters", true),
+      enableStagedGutters: config.get("enableStagedGutters", false),
       showCommitInFloating: config.get("showCommitInFloating", false),
       signPriority: config.get("signPriority", 10),
+      stagedSignPriority: config.get("stagedSignPriority", 9),
       pushArguments: (_a = config.get("pushArguments")) != null ? _a : [],
       splitWindowCommand: config.get("splitWindowCommand", "above sp"),
       changedSign: {
@@ -5897,6 +5911,22 @@ var DocumentManager = class {
         text: config.get("changeRemovedSign.text", "\u2243"),
         hlGroup: config.get("changeRemovedSign.hlGroup", "DiffChange")
       },
+      stagedAddedSign: {
+        text: config.get("stagedAddedSign.text", "\u2503"),
+        hlGroup: config.get("stagedAddedSign.hlGroup", "CocGitStagedAdd")
+      },
+      stagedChangedSign: {
+        text: config.get("stagedChangedSign.text", "\u2503"),
+        hlGroup: config.get("stagedChangedSign.hlGroup", "CocGitStagedChange")
+      },
+      stagedRemovedSign: {
+        text: config.get("stagedRemovedSign.text", "\u257B"),
+        hlGroup: config.get("stagedRemovedSign.hlGroup", "CocGitStagedDelete")
+      },
+      mixedSign: {
+        text: config.get("mixedSign.text", "\u250B"),
+        hlGroup: config.get("mixedSign.hlGroup", "CocGitMixed")
+      },
       conflict: {
         enabled: config.get("conflict.enabled", true),
         currentHlGroup: config.get("conflict.current.hlGroup", "DiffChange"),
@@ -5913,7 +5943,11 @@ var DocumentManager = class {
     this.config = Object.assign(this.config || {}, obj);
     if (e) {
       this.defined = false;
-      for (let buffer of this.buffers.values()) buffer.markConflictCheck();
+      for (let buffer of this.buffers.values()) {
+        buffer.markConflictCheck();
+        buffer.invalidateStagedCache();
+        buffer.diffDocument(true).catch((err) => this.service.log(`[Error] configuration refresh: ${err.message}`));
+      }
       this.defineSigns().catch((err) => this.service.log(`[Error] define signs: ${err.message}`));
     }
   }
@@ -6037,6 +6071,7 @@ var DocumentManager = class {
   }
   refresh() {
     for (let buf of this.buffers.values()) {
+      buf.invalidateStagedCache();
       buf.refresh();
     }
   }
@@ -6182,1469 +6217,1772 @@ register("zh_CN", zh_CN_default);
 
 // src/model/buffer.ts
 var import_url = require("url");
-var signGroup = "CocGit";
-var revPattern = "([0-9A-Za-z_.:/-]+)";
-var startPattern = new RegExp(`^<{7} (${revPattern})(:? .+)?$`);
-var sepPattern = new RegExp(`^={7}$`);
-var endPattern = new RegExp(`^>{7} (${revPattern})(:? .+)?$`);
-var commonPattern = /^\|{7}\smerged\scommon\sancestors/;
-function getPreviousConflict(conflicts, line) {
-  return conflicts.slice().reverse().find((conflict) => conflict.start < line);
+
+// src/model/repo.ts
+var import_fs2 = __toESM(require("fs"));
+var import_os = __toESM(require("os"));
+var import_path5 = __toESM(require("path"));
+var import_util2 = __toESM(require("util"));
+
+// node_modules/uuid/dist/esm/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
 }
-function chunkContainsLine(chunk, line) {
-  const end = chunk.add.count === 0 ? chunk.add.lnum : chunk.add.lnum + chunk.add.count - 1;
-  return chunk.add.lnum <= line && end >= line;
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
 }
-var GitBuffer = class {
-  constructor(doc, config, relpath, repo, git, channel, floatFactory, hasConflicts) {
-    this.doc = doc;
-    this.config = config;
-    this.relpath = relpath;
-    this.repo = repo;
+
+// node_modules/uuid/dist/esm/rng.js
+var import_crypto = require("crypto");
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    (0, import_crypto.randomFillSync)(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+
+// node_modules/uuid/dist/esm/native.js
+var import_crypto2 = require("crypto");
+var native_default = { randomUUID: import_crypto2.randomUUID };
+
+// node_modules/uuid/dist/esm/v4.js
+function v4(options, buf, offset) {
+  var _a, _b, _c;
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = (_c = (_b = options.random) != null ? _b : (_a = options.rng) == null ? void 0 : _a.call(options)) != null ? _c : rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
+// src/model/repo.ts
+var Repo = class {
+  constructor(git, channel, root) {
     this.git = git;
     this.channel = channel;
-    this.floatFactory = floatFactory;
-    this.hasConflicts = hasConflicts;
-    this.blameInfo = [];
-    this.diffs = [];
-    this.conflicts = [];
-    this.currentSigns = [];
-    this.gitStatus = "";
-    this.foldEnabled = false;
-    this._disposed = false;
-    this.mutex = new import_coc11.Mutex();
-    this.conflictCheckNeeded = hasConflicts;
-    this.refresh = (0, import_debounce2.default)(() => {
-      this._refresh().catch((e) => {
-        channel.append(`[Error] ${e.message}`);
-      });
-    }, 200);
-    this._refresh().catch((e) => channel.append(`[Error] ${e.message}`));
-  }
-  get cachedDiffs() {
-    return this.diffs;
+    this.root = root;
   }
-  markConflictCheck() {
-    this.conflictCheckNeeded = true;
+  /**
+   * Get staged info
+   */
+  async getStagedChunks(relpath) {
+    let args = ["-c", "core.quotepath=false", "--no-pager", "diff", "--no-ext-diff", "--no-renames", "-p", "-U0", "--no-color", "--staged"];
+    if (relpath) args.push("--", toUnixSlash(relpath));
+    const result = await this.exec(args);
+    if (!result.stdout) {
+      return {};
+    }
+    let res = {};
+    let idx = 0;
+    let lines = result.stdout.split(/\r?\n/);
+    let curr;
+    let fsPath;
+    while (idx < lines.length) {
+      let line = lines[idx];
+      if (fsPath && line.startsWith("@@")) {
+        curr = void 0;
+        let ms = line.match(/^@@\s+-(\d+),?(\d*)\s+\+(\d+),?(\d*)\s+@@/);
+        if (ms) {
+          curr = {
+            remove: { lnum: Number(ms[1]), count: ms[2] ? Number(ms[2]) : 1 },
+            add: { lnum: Number(ms[3]), count: ms[4] ? Number(ms[4]) : 1 },
+            lines: []
+          };
+          res[fsPath] = res[fsPath] || [];
+          res[fsPath].push(curr);
+        }
+      } else if (curr && /^[+\-]/.test(line)) {
+        curr.lines.push(line);
+      } else if (line.startsWith("diff --git")) {
+        const parsedPath = parseDiffPath(line);
+        if (relpath || parsedPath) {
+          fsPath = relpath ? toUnixSlash(relpath) : parsedPath;
+          curr = void 0;
+          idx += 4;
+          continue;
+        }
+      }
+      idx++;
+    }
+    return res;
   }
-  async _refresh() {
-    if (this._disposed) return;
-    this.refresh.clear();
-    let release = await this.mutex.acquire();
+  async getHEAD() {
     try {
-      if (this._disposed) return;
-      let result = await Promise.all([
-        this.diffDocument(),
-        this.loadBlames(),
-        this.parseConflicts()
-      ].map((promise) => promise.then(() => void 0, (error) => error)));
-      result.forEach((error) => {
-        if (error) this.channel.append(`[Error] refresh error ${error}`);
-      });
-    } finally {
-      release();
+      const result = await this.exec(["symbolic-ref", "--short", "HEAD"]);
+      if (!result.stdout) {
+        throw new Error("Not in a branch");
+      }
+      return result.stdout.trim();
+    } catch (err) {
+      const result = await this.exec(["rev-parse", "HEAD"]);
+      if (!result.stdout) {
+        throw new Error("Error parsing HEAD");
+      }
+      return result.stdout.trim();
     }
   }
-  getChunk(line) {
-    if (!this.diffs || this.diffs.length == 0) return void 0;
-    return this.diffs.find((ch) => {
-      let { start, added, removed, changeType } = ch;
-      if (line == 1 && start == 0 && ch.end == 0) {
-        return true;
-      }
-      let end = changeType === "changed" /* Change */ && added.count > removed.count ? ch.end + added.count - removed.count : ch.end;
-      if (start <= line && end >= line) {
-        return true;
+  async hasChanged() {
+    let result = await this.exec(["diff", "--name-status"]);
+    return result.stdout.trim().length > 0;
+  }
+  async getStaged() {
+    let result = await this.exec(["diff", "--staged", "--name-status"]);
+    if (!result.stdout) return [0, 0];
+    let lines = result.stdout.trim().split(/\r?\n/);
+    let conflicted = 0;
+    let staged = 0;
+    lines.forEach((line) => {
+      if (!line.length) return;
+      if (line.startsWith("U")) {
+        conflicted++;
+      } else {
+        staged++;
       }
-      return false;
     });
+    return [conflicted, staged];
   }
-  async chunkUndo() {
-    let line = await import_coc11.workspace.nvim.call("line", ".");
-    let diff = this.getChunk(line);
-    if (!diff) return;
-    let { start, lines, changeType } = diff;
-    let added = lines.filter((s) => s.startsWith("-")).map((s) => s.slice(1));
-    let removeCount = lines.filter((s) => s.startsWith("+")).length;
-    let buf = this.doc.buffer;
-    if (changeType == "delete" /* Delete */) {
-      await buf.setLines(added, { start, end: start, strictIndexing: false });
-    } else {
-      await buf.setLines(added, {
-        start: start - 1,
-        end: start - 1 + removeCount,
-        strictIndexing: false
+  async hasUntracked() {
+    let cp2 = this.git.stream(this.root, ["ls-files", "--others", "--exclude-standard", "--directory"]);
+    return new Promise((resolve) => {
+      let settled = false;
+      const finish = (value) => {
+        if (settled) return;
+        settled = true;
+        resolve(value);
+      };
+      cp2.stdout.on("data", () => {
+        cp2.kill("SIGKILL");
+        finish(true);
       });
+      cp2.on("exit", () => {
+        finish(false);
+      });
+      cp2.on("error", () => {
+        finish(false);
+      });
+    });
+  }
+  async getStatus(character, decorator) {
+    try {
+      let head = await this.getHEAD();
+      if (!head) return "";
+      let [changed, staged, untracked] = await Promise.all([this.hasChanged(), this.getStaged(), this.hasUntracked()]);
+      const { changedDecorator, conflictedDecorator, stagedDecorator, untrackedDecorator } = decorator;
+      let more = "";
+      if (changed) more += changedDecorator;
+      if (staged[0]) more += conflictedDecorator;
+      if (staged[1]) more += stagedDecorator;
+      if (untracked) more += untrackedDecorator;
+      return `${character ? character + " " : ""}${head}${more}`;
+    } catch (e) {
+      this.channel.appendLine("Error on git status");
+      this.channel.append(e.message);
+      return "";
     }
   }
-  async chunkStage() {
-    let relpath = toUnixSlash(this.relpath);
-    let line = await import_coc11.workspace.nvim.call("line", ".");
-    let diff = this.getChunk(line);
-    if (!diff) {
-      import_coc11.window.showErrorMessage("Not positioned in git chunk");
-      return;
-    }
-    let head;
-    if (diff.changeType === "add" /* Add */) {
-      head = `@@ -${diff.removed.start + 1},0 +${diff.removed.start + 1},${diff.added.count} @@`;
-    } else if (diff.changeType === "delete" /* Delete */) {
-      head = `@@ -${diff.removed.start},${diff.removed.count} +${diff.removed.start},0 @@`;
-    } else if (diff.changeType === "changed" /* Change */) {
-      head = `@@ -${diff.removed.start},${diff.removed.count} +${diff.removed.start},${diff.added.count} @@`;
-    }
-    const from = quoteGitPath(`a/${relpath}`);
-    const to = quoteGitPath(`b/${relpath}`);
-    const lines = [
-      `diff --git ${from} ${to}`,
-      `index 000000..000000 100644`,
-      `--- ${from}`,
-      `+++ ${to}`,
-      head
-    ];
-    lines.push(...diff.lines);
-    lines.push("");
+  async getDiff(relFilepath, content, revision = "", encoding = "utf8") {
+    if (relFilepath.startsWith(`.git${import_path5.default.sep}`)) return;
+    const base = await this.getFileContent(relFilepath, revision || ":", encoding);
+    return this.getDiffFromContents(base ? base + "\n" : "", content);
+  }
+  async getDiffFromContents(base, content) {
+    const stagedFile = import_path5.default.join(import_os.default.tmpdir(), `coc-${v4_default()}`);
+    const currentFile = import_path5.default.join(import_os.default.tmpdir(), `coc-${v4_default()}`);
+    let output;
     try {
-      await this.git.exec(this.repo.root, ["apply", "--cached", "--unidiff-zero", "-"], { input: lines.join("\n") });
-      this.refresh();
-    } catch (e) {
-      this.channel.appendLine(`[Error] ${e.message}`);
+      await import_util2.default.promisify(import_fs2.default.writeFile)(stagedFile, base, "utf8");
+      await import_util2.default.promisify(import_fs2.default.writeFile)(currentFile, content, "utf8");
+      const result = await this.exec([
+        "--no-pager",
+        "diff",
+        "--no-index",
+        "--no-ext-diff",
+        "-p",
+        "-U0",
+        "--no-color",
+        stagedFile,
+        currentFile
+      ], { allowedExitCodes: [1] });
+      output = result.stdout;
+    } finally {
+      await Promise.all([
+        import_util2.default.promisify(import_fs2.default.unlink)(stagedFile).catch(() => void 0),
+        import_util2.default.promisify(import_fs2.default.unlink)(currentFile).catch(() => void 0)
+      ]);
     }
+    if (!output) return [];
+    this.channel.appendLine("> git diff buffer contents");
+    const lines = output.replace(/\r?\n$/, "").split(/\r?\n/);
+    return parseDiff(lines);
   }
-  async chunkUnstage() {
-    var _a;
-    let { nvim } = import_coc11.workspace;
-    const { diffs } = this;
-    let line = await nvim.call("line", ".");
-    let adjust = 0;
-    let invalid = false;
-    for (let diff of diffs) {
-      if (diff.end >= line) {
-        if (diff.start <= line && diff.changeType != "delete" /* Delete */) {
-          import_coc11.window.showErrorMessage(`Current line contains unstaged change.`);
-          invalid = true;
-        }
-        break;
-      }
-      adjust -= diff.added.count;
-      adjust += diff.removed.count;
-    }
-    if (invalid) return;
-    line = line + adjust;
-    let stagedDiff = await this.repo.getStagedChunks(this.relpath);
-    let chunks = (_a = Object.values(stagedDiff)[0]) != null ? _a : [];
-    if (!chunks.length) {
-      import_coc11.window.showErrorMessage(`Staged chunk not found`);
-      return;
-    }
-    let chunk = chunks.find((o) => chunkContainsLine(o, line));
-    if (!chunk) {
-      import_coc11.window.showErrorMessage(`Unable to find staged chunk on current line`);
-      return;
-    }
-    this.channel.appendLine(`[Info] resolved chunk ${JSON.stringify(chunk, null, 2)}`);
-    let patch = createUnstagePatch(this.relpath, chunk);
-    if (!patch) return;
+  async getFileContent(relpath, revision, encoding = "utf8") {
     try {
-      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}`);
-      this.channel.appendLine(`[Error] ${e.message}`);
+      const object = revision.endsWith(":") ? revision : `${revision}:`;
+      const result = await this.exec(["--no-pager", "show", `${object}${toUnixSlash(relpath)}`], {
+        encoding,
+        log: false,
+        allowedExitCodes: [128]
+      });
+      if (result.exitCode !== 0) return "";
+      return result.stdout.replace(/\r?\n$/, "").split(/\r?\n/).join("\n");
+    } catch (_e) {
+      return "";
     }
   }
-  async nextChunk() {
-    const { diffs } = this;
-    let { nvim } = import_coc11.workspace;
-    if (!diffs || diffs.length == 0) return;
-    let line = await nvim.call("line", ".");
-    for (let diff of diffs) {
-      if (diff.start > line) {
-        await import_coc11.window.moveTo({ line: Math.max(diff.start - 1, 0), character: 0 });
-        return;
-      }
-    }
-    if (await nvim.getOption("wrapscan")) {
-      await import_coc11.window.moveTo({ line: Math.max(diffs[0].start - 1, 0), character: 0 });
+  async getIndexIdentity() {
+    try {
+      const gitPath = (await this.safeRun(["rev-parse", "--git-path", "index"])).trim();
+      if (!gitPath) return "";
+      const indexPath = import_path5.default.isAbsolute(gitPath) ? gitPath : import_path5.default.join(this.root, gitPath);
+      const stat = await import_util2.default.promisify(import_fs2.default.stat)(indexPath);
+      return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}`;
+    } catch (_e) {
+      return "";
     }
   }
-  async prevChunk() {
-    const { nvim } = import_coc11.workspace;
-    let { diffs } = this;
-    let line = await nvim.call("line", ".");
-    if (!diffs || diffs.length == 0) return;
-    for (let diff of diffs.slice().reverse()) {
-      if (diff.end < line) {
-        await import_coc11.window.moveTo({ line: Math.max(diff.start - 1, 0), character: 0 });
-        return;
+  async getHeadIdentity() {
+    return this.safeRun(["rev-parse", "--verify", "HEAD"]);
+  }
+  async getDiffAll(category) {
+    let diffGroups = /* @__PURE__ */ new Map();
+    let args = ["-c", "core.quotepath=false", "--no-pager", "diff", "--no-ext-diff", "--no-renames", "-p", "-U0", "--no-color"];
+    if (category === 0 /* All */) {
+      const head = await this.safeRun(["rev-parse", "--verify", "HEAD"]);
+      if (head) {
+        args.push("HEAD");
+      } else {
+        const emptyTree = await this.exec(["hash-object", "-t", "tree", "--stdin"], { input: "", log: false });
+        args.push(emptyTree.stdout.trim());
       }
+    } else if (category === 1 /* Staged */) {
+      args.push("--cached");
     }
-    if (await nvim.getOption("wrapscan")) {
-      await import_coc11.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 diff = this.getChunk(line);
-    if (diff) {
-      let content = diff.head + "\n" + diff.lines.join("\n");
-      await this.showDoc(content, "diff");
-    } else {
-      let chunks = [];
-      try {
-        let stagedDiff = await this.repo.getStagedChunks(this.relpath);
-        chunks = Object.values(stagedDiff)[0];
-      } catch (e) {
+    let output = (await this.exec(args)).stdout;
+    if (!output) return diffGroups;
+    const lines = output.replace(/\r?\n$/, "").split(/\r?\n/);
+    let lineGroups = /* @__PURE__ */ new Map();
+    let file = null;
+    for (const line of lines) {
+      if (line.startsWith("diff --git")) {
+        file = parseDiffPath(line) || null;
       }
-      let adjust = 0;
-      for (let diff2 of this.diffs) {
-        if (diff2.end >= line) {
-          break;
+      if (file) {
+        if (!lineGroups.has(file)) {
+          lineGroups.set(file, []);
         }
-        adjust -= diff2.added.count;
-        adjust += diff2.removed.count;
+        lineGroups.get(file).push(line);
       }
-      line = line + adjust;
-      let chunk = chunks.find((o) => chunkContainsLine(o, line));
-      if (chunk) {
-        let content = "Staged changes\n" + chunk.lines.join("\n");
-        await this.showDoc(content, "diff");
-      } else {
-        await this.showCommit(true);
+    }
+    for (const [file2, lines2] of lineGroups) {
+      let diffs = parseDiff(lines2);
+      if (diffs) {
+        diffGroups.set(file2, diffs);
       }
     }
+    return diffGroups;
   }
-  allChunkInfo() {
-    return this.diffs ? this.diffs.slice() : [];
+  async isIgnored(relativePath) {
+    let res = await this.exec(["check-ignore", "-q", "--", relativePath], { allowedExitCodes: [1] });
+    return res.exitCode === 0;
   }
-  async showBlameInfo(lnum) {
-    if (this._disposed) return;
-    let { nvim } = import_coc11.workspace;
-    let { virtualTextSrcId, addGBlameToBufferVar, addGBlameToVirtualText } = this.config;
-    if (!this.showBlame) return;
-    let infos = this.blameInfo;
-    if (!infos) return;
-    let blameText;
-    if (infos.length == 0) {
-      blameText = "File not indexed";
-    } else {
-      let info = infos.find((o) => lnum >= o.startLnum && lnum <= o.endLnum);
-      if (info && info.author && info.author != "Not Committed Yet") {
-        blameText = formatBlameText(info, this.config.blameFormat);
-      } else {
-        blameText = "Not committed yet";
-      }
-    }
-    let buffer = nvim.createBuffer(this.doc.bufnr);
-    let hide_blame = await nvim.getVar("coc_git_hide_blame_virtual_text");
-    if (hide_blame) {
-      buffer.clearNamespace(virtualTextSrcId);
-    } else {
-      if (addGBlameToBufferVar) {
-        nvim.pauseNotification();
-        buffer.setVar("coc_git_blame", blameText, true);
-        nvim.call("coc#util#do_autocmd", ["CocGitStatusChange"], true);
-        nvim.resumeNotification(false, true);
-      }
-      if (addGBlameToVirtualText) {
-        const prefix = this.config.virtualTextPrefix;
-        nvim.pauseNotification();
-        buffer.clearNamespace(virtualTextSrcId);
-        buffer.setVirtualText(virtualTextSrcId, lnum - 1, [[prefix + blameText, "CocCodeLens"]]);
-        nvim.resumeNotification(true, true);
-      }
-    }
+  async hasConflicts(relativePath) {
+    let indexed = await this.isIndexed(relativePath);
+    if (!indexed) return false;
+    let res = await this.exec(["diff", "--staged", "--name-status", "--", relativePath]);
+    return res.stdout.trim().startsWith("U");
   }
-  async showBlameDoc(lnum) {
-    let indexed = await this.repo.isIndexed(this.relpath);
-    if (!indexed) {
-      import_coc11.window.showWarningMessage("File not indexed");
-    } else if (await this.repo.isShallow()) {
-      import_coc11.window.showWarningMessage("Shallow repository, blame not available");
-    } else {
-      let infos = await this.getBlameInfo([lnum, lnum]);
-      let info = infos.find((o) => lnum >= o.startLnum && lnum <= o.endLnum);
-      if (info && info.author && info.author != "Not Committed Yet") {
-        let blameText = [];
-        blameText.push(`${info.author}, ${info.time}`);
-        blameText.push(`${info.summary}`);
-        blameText.push(`${info.sha.substring(0, 7)}`);
-        await this.showDoc(blameText.join("\n\n"), "text");
-      } else {
-        import_coc11.window.showWarningMessage("Not committed yet");
-      }
+  async isIndexed(relpath) {
+    let res = await this.exec(["ls-files", "--", relpath]);
+    return res.stdout && res.stdout.trim().length > 0;
+  }
+  async getUsername() {
+    if (typeof this.userName === "string") return this.userName;
+    try {
+      let res = await this.exec(["config", "user.name"]);
+      this.userName = res.stdout.trim();
+      return this.userName;
+    } catch (e) {
+      this.userName = "";
+      return "";
     }
   }
-  async diffDocument(force = false) {
-    let { nvim } = import_coc11.workspace;
-    let revision = this.config.diffRevision;
-    const { bufnr } = this.doc;
-    let content = this.doc.content;
-    let eol = this.doc.textDocument["eol"];
-    let encoding = await this.doc.buffer.getOption("fileencoding");
-    const diffs = await this.repo.getDiff(this.relpath, eol ? content : content + "\n", revision, encoding || "utf8");
-    if (diffs == null || this._disposed) return;
-    if (diffs.length === 0) {
-      this.currentSigns = [];
-      this.diffs = [];
-      this.setBufferStatus("");
-      if (this.config.enableGutters) {
-        nvim.call("sign_unplace", [signGroup, { buffer: bufnr }], true);
-        nvim.redrawVim();
-      }
-      return;
-    }
-    if (equals(diffs, this.diffs)) {
-      return;
-    }
-    this.diffs = diffs;
-    let added = 0;
-    let changed = 0;
-    let removed = 0;
-    let signs = [];
-    for (let diff of diffs) {
-      if (diff.changeType == "add" /* Add */) {
-        added += diff.added.count;
-      } else if (diff.changeType == "delete" /* Delete */) {
-        removed += diff.removed.count;
-      } else if (diff.changeType == "changed" /* Change */) {
-        let [add, remove] = [diff.added.count, diff.removed.count];
-        let min = Math.min(add, remove);
-        changed += min;
-        added += add - min;
-        removed += remove - min;
-      }
-      let { start, end } = diff;
-      for (let i = start; i <= end; i++) {
-        let topdelete = diff.changeType == "delete" /* Delete */ && i == 0;
-        let changedelete = diff.changeType == "changed" /* Change */ && diff.removed.count > diff.added.count && i == end;
-        signs.push({
-          changeType: topdelete ? "topdelete" : changedelete ? "changedelete" : diff.changeType,
-          lnum: topdelete ? 1 : i
-        });
-      }
-      if (diff.changeType == "changed" /* Change */) {
-        let [add, remove] = [diff.added.count, diff.removed.count];
-        if (add > remove) {
-          for (let i = 0; i < add - remove; i++) {
-            signs.push({
-              changeType: "add" /* Add */,
-              lnum: diff.end + 1 + i
-            });
-          }
-        }
-      }
-    }
-    let items = [];
-    if (added) items.push(`+${added}`);
-    if (changed) items.push(`~${changed}`);
-    if (removed) items.push(`-${removed}`);
-    let status = `  ${items.join(" ")} `;
-    this.setBufferStatus(status);
-    this.currentSigns = signs;
-    if (!this.config.realtimeGutters && !force) return;
-    this.updateGutters();
-  }
-  updateGutters() {
-    if (this._disposed) return;
-    if (!this.config.enableGutters) return;
-    let { nvim } = import_coc11.workspace;
-    let { bufnr } = this.doc;
-    let { signPriority } = this.config;
-    let signs = this.currentSigns;
-    nvim.pauseNotification();
-    nvim.call("sign_unplace", [signGroup, { buffer: bufnr }], true);
-    for (let sign of signs) {
-      let name = this.getSignName(sign.changeType);
-      nvim.call("sign_place", [0, signGroup, name, bufnr, { lnum: sign.lnum, priority: signPriority }], true);
+  async isShallow() {
+    try {
+      let res = await this.exec(["rev-parse", "--is-shallow-repository"]);
+      return res.stdout.trim() === "true";
+    } catch (e) {
+      return false;
     }
-    nvim.resumeNotification(true, true);
   }
-  async loadBlames() {
-    if (!this.showBlame) return;
-    let result = [];
-    let indexed = await this.repo.isIndexed(this.relpath);
-    if (indexed) result = await this.getBlameInfo();
-    if (this._disposed) return;
-    this.blameInfo = result;
+  async exec(args, options = {}) {
+    return await this.git.exec(this.root, args, options);
   }
-  async getBlameInfo(range) {
-    let { relpath } = this;
-    let root = this.repo.root;
-    let res = [];
-    const useRealTime = this.config.blameUseRealTime;
+  async safeRun(args, options = {}) {
     try {
-      let currentAuthor = await this.repo.getUsername();
-      const args = ["--no-pager", "blame", "-w", "-b", "-p", "--incremental", "--root", "--date", "relative", "--contents", "-"];
-      if (range) args.push("-L", range.join(","));
-      args.push("--", relpath);
-      let r = await this.git.exec(root, args, {
-        log: false,
-        input: this.doc.content
-      });
-      if (!r.stdout) return res;
-      let info;
-      const commits = /* @__PURE__ */ new Map();
-      for (let line of r.stdout.trim().split(/\r?\n/)) {
-        line = line.trim();
-        if (/^(author |committer )?External file \(--contents\)/.test(line)) {
-          line = "Not committed yet.";
-        }
-        let ms = line.match(/^([A-Za-z0-9]+)\s(\d+)\s(\d+)\s(\d+)/);
-        if (ms) {
-          let startLnum = parseInt(ms[3], 10);
-          info = { startLnum, sha: ms[1], endLnum: startLnum + parseInt(ms[4], 10) - 1, index: ms[2] };
-          if (!/^0+$/.test(ms[1])) {
-            let find = commits.get(ms[1]);
-            if (find) {
-              info.author = find.author;
-              info.time = find.time;
-              info.summary = find.summary;
-            } else {
-              commits.set(ms[1], info);
-            }
-          }
-          res.push(info);
-        } else if (info) {
-          if (line.startsWith("author ")) {
-            let author = line.replace(/^author/, "").trim();
-            info.author = author == currentAuthor ? "You" : author;
-          } else if (line.startsWith("author-time ")) {
-            let text = line.replace(/^author-time/, "").trim();
-            const timestamps = parseInt(text, 10) * 1e3;
-            info.time = useRealTime ? new Date(timestamps).toLocaleString() : format(timestamps, process.env.LANG);
-          } else if (line.startsWith("summary ")) {
-            let text = line.replace(/^summary/, "").trim();
-            info.summary = text;
-          }
-        }
-      }
-      return res;
+      let res = await this.exec(args, options);
+      return res ? res.stdout.replace(/\s*$/, "") : "";
     } catch (e) {
-      this.channel.appendLine(e.stack);
-    }
-    return res;
-  }
-  async diffCached() {
-    let res = await this.repo.safeRun(["diff", "--cached"]);
-    if (!res.trim()) {
-      import_coc11.window.showWarningMessage("Empty diff");
-      return;
+      return "";
     }
-    let { nvim } = import_coc11.workspace;
-    nvim.pauseNotification();
-    nvim.command(`keepalt above new +setl\\ previewwindow`, true);
-    nvim.call("append", [0, res.split(/\r?\n/)], true);
-    nvim.command("normal! Gdd", true);
-    nvim.command(`exe 1`, true);
-    nvim.command("setfiletype git", true);
-    nvim.command("setl buftype=nofile nomodifiable bufhidden=wipe nobuflisted", true);
-    await nvim.resumeNotification();
   }
-  async nextConflict() {
-    let { nvim } = import_coc11.workspace;
-    if (!this.conflicts.length) {
-      import_coc11.window.showWarningMessage("No conflicts detected");
-      return;
+};
+function readQuotedGitPath(input, start) {
+  if (input[start] !== '"') return void 0;
+  let value = "";
+  for (let index = start + 1; index < input.length; index++) {
+    const character = input[index];
+    if (character === '"') return { value, end: index + 1 };
+    if (character !== "\\") {
+      value += character;
+      continue;
     }
-    let line = await nvim.call("line", ".");
-    for (let conflict of this.conflicts) {
-      if (conflict.start > line) {
-        await import_coc11.window.moveTo({ line: Math.max(conflict.start - 1, 0), character: 0 });
-        return;
-      }
+    const escaped = input[++index];
+    if (escaped == null) return void 0;
+    const escapes = {
+      a: "\x07",
+      b: "\b",
+      t: "	",
+      n: "\n",
+      v: "\v",
+      f: "\f",
+      r: "\r",
+      '"': '"',
+      "\\": "\\"
+    };
+    if (escapes[escaped] != null) {
+      value += escapes[escaped];
+      continue;
     }
-    if (await nvim.getOption("wrapscan")) {
-      await import_coc11.window.moveTo({ line: Math.max(this.conflicts[0].start - 1, 0), character: 0 });
+    if (/[0-7]/.test(escaped)) {
+      let octal = escaped;
+      while (octal.length < 3 && /[0-7]/.test(input[index + 1] || "")) octal += input[++index];
+      value += String.fromCharCode(parseInt(octal, 8));
+      continue;
     }
+    value += escaped;
   }
-  async prevConflict() {
-    let { nvim } = import_coc11.workspace;
-    if (!this.conflicts.length) {
-      import_coc11.window.showWarningMessage("No conflicts detected", "warning");
-      return;
-    }
-    let line = await nvim.call("line", ".");
-    let conflict = getPreviousConflict(this.conflicts, line);
-    if (conflict) {
-      await import_coc11.window.moveTo({ line: Math.max(conflict.start - 1, 0), character: 0 });
-      return;
-    }
-    if (await nvim.getOption("wrapscan")) {
-      conflict = this.conflicts[this.conflicts.length - 1];
-      await import_coc11.window.moveTo({ line: Math.max(conflict.start - 1, 0), character: 0 });
-    }
+  return void 0;
+}
+function parseDiffPath(line) {
+  const prefix = "diff --git ";
+  if (!line.startsWith(prefix)) return void 0;
+  const value = line.slice(prefix.length);
+  if (value.startsWith('"')) {
+    const first = readQuotedGitPath(value, 0);
+    if (!first) return void 0;
+    const secondStart = value.indexOf('"', first.end);
+    const second = secondStart === -1 ? void 0 : readQuotedGitPath(value, secondStart);
+    if (!second || !first.value.startsWith("a/") || !second.value.startsWith("b/")) return void 0;
+    const firstPath = first.value.slice(2);
+    return firstPath === second.value.slice(2) ? firstPath : void 0;
   }
-  async conflictKeepPart(part) {
-    const { nvim } = import_coc11.workspace;
-    let conflicts = this.conflicts;
-    if (!conflicts || conflicts.length == 0) {
-      import_coc11.window.showWarningMessage("No conflicts detected");
-      return;
+  if (!value.startsWith("a/")) return void 0;
+  const paths = value.slice(2);
+  let separator = paths.indexOf(" b/");
+  while (separator !== -1) {
+    const firstPath = paths.slice(0, separator);
+    if (firstPath === paths.slice(separator + 3)) return firstPath;
+    separator = paths.indexOf(" b/", separator + 1);
+  }
+  return void 0;
+}
+var repo_default = Repo;
+function parseDiff(diffLines) {
+  const allLines = diffLines.slice(4);
+  const diffs = [];
+  let diff = null;
+  for (const line of allLines) {
+    if (!line.startsWith("@@")) {
+      if (diff) {
+        diff.lines.push(line);
+      }
+      continue;
     }
-    let line = await nvim.call("line", ".");
-    for (let conflict of conflicts) {
-      if (conflict.start <= line && conflict.end >= line) {
-        switch (part) {
-          case 0 /* Current */:
-            let start = conflict.common ? conflict.common : conflict.sep;
-            await nvim.command(`${start},${conflict.end}d | ${conflict.start}d`);
-            return;
-          case 1 /* Incoming */:
-            await nvim.command(`${conflict.end}d | ${conflict.start},${conflict.sep}d`);
-            return;
-          case 2 /* Both */:
-            if (conflict.common) {
-              await nvim.command(`${conflict.end}d | ${conflict.common},${conflict.sep}d | ${conflict.start}d`);
-            } else {
-              await nvim.command(`${conflict.end}d | ${conflict.sep}d | ${conflict.start}d`);
-            }
-            return;
-        }
-      }
+    let diffKey = line.split("@@", 2)[1].trim();
+    const [pres, nows] = diffKey.split(/\s+/).map((str) => str.slice(1).split(","));
+    const removed = {
+      start: parseInt(pres[0], 10),
+      count: parseInt(`${pres[1] || 1}`, 10)
+    };
+    const added = {
+      start: parseInt(nows[0], 10),
+      count: parseInt(`${nows[1] || 1}`, 10)
+    };
+    if (added.count === 0) {
+      diff = {
+        lines: [],
+        start: added.start,
+        end: added.start,
+        head: line,
+        removed,
+        added,
+        changeType: "delete" /* Delete */
+      };
+      diffs.push(diff);
+    } else if (removed.count === 0) {
+      diff = {
+        lines: [],
+        start: added.start,
+        end: added.start + added.count - 1,
+        head: line,
+        removed,
+        added,
+        changeType: "add" /* Add */
+      };
+      diffs.push(diff);
+    } else {
+      diff = {
+        lines: [],
+        start: added.start,
+        end: added.start + Math.min(added.count, removed.count) - 1,
+        head: line,
+        removed,
+        added,
+        changeType: "changed" /* Change */
+      };
+      diffs.push(diff);
     }
-    import_coc11.window.showWarningMessage("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 head = (await this.repo.safeRun(["rev-parse", "HEAD"])).trim();
-    let branch = config.get("browserBranchName", "").trim();
-    if (!branch.length) {
-      branch = (await this.repo.safeRun(["symbolic-ref", "--short", "-q", "HEAD"])).trim();
-    }
-    let lines = range && range.length == 2 ? [
-      range[0],
-      range[1]
-    ] : [await nvim.eval('line(".")')];
-    if (this.doc.filetype == "markdown") {
-      let line = await nvim.call("getline", ["."]);
-      if (line.startsWith("#")) {
-        let words = line.replace(/^#+\s*/, "").split(/\s+/);
-        lines = words.map((s) => s.toLowerCase()).join("-");
-      }
-    }
-    let output = await this.repo.safeRun(["remote"]);
-    if (!output.trim()) {
-      import_coc11.window.showWarningMessage(`No remote found`);
-      return;
+  return diffs;
+}
+
+// src/model/staged.ts
+function changeKind(diff) {
+  if (diff.changeType === "add") return "add";
+  if (diff.changeType === "delete") return diff.start === 0 ? "topDelete" : "delete";
+  return diff.removed.count > diff.added.count ? "changeDelete" : "change";
+}
+function changesFromDiffs(diffs, layer) {
+  return diffs.map((diff) => ({
+    kind: changeKind(diff),
+    layer,
+    line: diff.start,
+    endLine: diff.end,
+    sourceLine: diff.removed.start,
+    sourceEndLine: diff.removed.start + diff.removed.count - 1,
+    sourceCount: diff.removed.count,
+    targetCount: diff.added.count
+  }));
+}
+function createHunkMapping(indexLines, bufferLines, changes) {
+  const hunks = changes.filter((change) => change.sourceLine != null && change.sourceCount != null && change.targetCount != null).map((change) => ({
+    oldStart: change.sourceLine,
+    oldCount: change.sourceCount,
+    newStart: change.line,
+    newCount: change.targetCount
+  })).sort((a, b) => a.oldStart - b.oldStart || a.newStart - b.newStart);
+  if (hunks.length === 0) return void 0;
+  const indexToBuffer = Array(indexLines.length);
+  const insertionAnchors = /* @__PURE__ */ new Map();
+  let oldCursor = 1;
+  let newCursor = 1;
+  for (const hunk of hunks) {
+    if (hunk.oldStart < oldCursor) continue;
+    const unchanged = hunk.oldStart - oldCursor;
+    for (let index = 0; index < unchanged; index++) {
+      const oldLine = oldCursor + index;
+      const newLine = newCursor + index;
+      if (oldLine <= indexLines.length && newLine <= bufferLines.length) indexToBuffer[oldLine - 1] = newLine;
+    }
+    const anchor = Math.max(1, Math.min(bufferLines.length || 1, hunk.newStart || newCursor));
+    insertionAnchors.set(hunk.oldStart, anchor);
+    for (let index = 0; index < hunk.oldCount; index++) {
+      const oldLine = hunk.oldStart + index;
+      if (oldLine > indexLines.length) break;
+      if (index < hunk.newCount) {
+        const newLine = hunk.newStart + index;
+        if (newLine >= 1 && newLine <= bufferLines.length) indexToBuffer[oldLine - 1] = newLine;
+      }
+    }
+    oldCursor = hunk.oldStart + hunk.oldCount;
+    newCursor = hunk.newStart + hunk.newCount;
+  }
+  for (let index = oldCursor; index <= indexLines.length; index++) {
+    const newLine = newCursor + index - oldCursor;
+    if (newLine <= bufferLines.length) indexToBuffer[index - 1] = newLine;
+  }
+  return { indexToBuffer, insertionAnchors };
+}
+function createLineMapping(indexLines, bufferLines, unstagedChanges) {
+  const fromHunks = createHunkMapping(indexLines, bufferLines, unstagedChanges);
+  if (fromHunks) return fromHunks;
+  if (unstagedChanges.length === 0) {
+    return {
+      indexToBuffer: indexLines.map((_, index) => index + 1 <= bufferLines.length ? index + 1 : void 0),
+      insertionAnchors: /* @__PURE__ */ new Map()
+    };
+  }
+  const indexToBuffer = Array(indexLines.length);
+  const insertionAnchors = /* @__PURE__ */ new Map();
+  const rows = indexLines.length + 1;
+  const cols = bufferLines.length + 1;
+  const table = Array.from({ length: rows }, () => Array(cols).fill(0));
+  for (let i2 = indexLines.length - 1; i2 >= 0; i2--) {
+    for (let j2 = bufferLines.length - 1; j2 >= 0; j2--) {
+      table[i2][j2] = indexLines[i2] === bufferLines[j2] ? table[i2 + 1][j2 + 1] + 1 : Math.max(table[i2 + 1][j2], table[i2][j2 + 1]);
+    }
+  }
+  let i = 0;
+  let j = 0;
+  while (i < indexLines.length && j < bufferLines.length) {
+    if (indexLines[i] === bufferLines[j]) {
+      indexToBuffer[i] = j + 1;
+      i++;
+      j++;
+    } else if (table[i + 1][j] >= table[i][j + 1]) {
+      i++;
+    } else {
+      insertionAnchors.set(i + 1, j + 1);
+      j++;
     }
-    let names = output.trim().split(/\r?\n/);
-    let browserRemoteName = config.get("browserRemoteName", "").trim();
-    if (browserRemoteName.length > 0) {
-      if (names.includes(browserRemoteName)) {
-        names = [browserRemoteName];
-      } else {
-        import_coc11.window.showWarningMessage("Configured git.browserRemoteName missing from remote list");
-        return;
-      }
+  }
+  if (i < indexLines.length) insertionAnchors.set(i + 1, Math.max(1, Math.min(bufferLines.length || 1, j + 1)));
+  return { indexToBuffer, insertionAnchors };
+}
+function resolveMappedLine(line, mapping, bufferLineCount) {
+  const direct = line > 0 ? mapping.indexToBuffer[line - 1] : void 0;
+  if (direct != null) return direct;
+  const anchor = mapping.insertionAnchors.get(line);
+  if (anchor != null) return Math.max(1, Math.min(bufferLineCount || 1, anchor));
+  if (bufferLineCount === 0) return 1;
+  if (line <= 0) return 1;
+  for (let index = Math.min(line - 1, mapping.indexToBuffer.length - 1); index >= 0; index--) {
+    const mapped = mapping.indexToBuffer[index];
+    if (mapped != null) return Math.min(bufferLineCount, mapped + line - index - 1);
+  }
+  return Math.min(bufferLineCount, line);
+}
+function mapIndexChangesToBuffer(stagedChanges, mapping, bufferLineCount) {
+  return stagedChanges.map((change) => {
+    var _a;
+    const isDeletion = change.kind === "delete" || change.kind === "topDelete";
+    const sourceLine = isDeletion && change.sourceLine != null ? change.sourceLine : change.line;
+    const sourceEndLine = isDeletion && change.sourceEndLine != null ? change.sourceEndLine : (_a = change.endLine) != null ? _a : change.line;
+    const line = resolveMappedLine(sourceLine, mapping, bufferLineCount);
+    const endLine = Math.max(line, resolveMappedLine(sourceEndLine, mapping, bufferLineCount));
+    return { ...change, line, endLine };
+  });
+}
+function gutterSignsFromChanges(changes) {
+  var _a, _b, _c;
+  const result = [];
+  for (const change of changes) {
+    const start = change.line === 0 ? 1 : Math.max(1, change.line);
+    const end = Math.max(start, (_a = change.endLine) != null ? _a : start);
+    if (change.kind === "delete" || change.kind === "topDelete") {
+      result.push({ line: start, kind: change.kind, layer: change.layer });
+      continue;
     }
-    let urls = [];
-    for (let name of names) {
-      let uri = await this.repo.safeRun(["config", "--get", `remote.${name}.url`]);
-      if (!uri.length) continue;
-      let repoURL = getRepoUrl(uri);
-      if (!repoURL) continue;
-      let tmp;
-      try {
-        tmp = new import_url.URL(repoURL);
-      } catch (_e) {
-        continue;
-      }
-      let hostname = tmp.hostname;
-      let fix = "|";
-      try {
-        fix = config.get("urlFix")[hostname][permalink ? 1 : 0];
-      } catch (e) {
-      }
-      let url = getUrl(fix, repoURL, permalink ? head : branch || head, toUnixSlash(this.relpath), lines);
-      if (url) urls.push(url);
+    for (let line = start; line <= end; line++) {
+      result.push({ line, kind: line === end && change.kind === "changeDelete" ? "changeDelete" : change.kind, layer: change.layer });
     }
-    if (urls.length == 1) {
-      if (action == "open") {
-        await import_coc11.workspace.openResource(urls[0]);
-      } else {
-        nvim.call("setreg", ["+", urls[0]], true);
-        import_coc11.window.showInformationMessage("Copied url to clipboard");
-      }
-    } else if (urls.length > 1) {
-      let url = await import_coc11.window.showQuickPick(urls, { canPickMany: false, title: "Pick remote url" });
-      if (url) {
-        if (action == "open") {
-          await import_coc11.workspace.openResource(url);
-        } else {
-          nvim.call("setreg", ["+", url], true);
-          nvim.call("setreg", ["*", url], true);
-          import_coc11.window.showInformationMessage("Copied url to clipboard");
-        }
+    if (change.kind === "change" && ((_b = change.targetCount) != null ? _b : 0) > ((_c = change.sourceCount) != null ? _c : 0)) {
+      const extra = change.targetCount - change.sourceCount;
+      for (let index = 0; index < extra; index++) {
+        result.push({ line: end + 1 + index, kind: "add", layer: change.layer });
       }
     }
   }
-  // show commit of current line in split window
-  async showCommit(useFloating = false) {
-    let indexed = await this.repo.isIndexed(this.relpath);
-    if (!indexed) {
-      import_coc11.window.showWarningMessage(`"${this.relpath}" not indexed.`);
-      return;
-    }
-    let nvim = import_coc11.workspace.nvim;
-    let line = await nvim.eval('line(".")');
-    let args = ["--no-pager", "blame", "-w", "-l", "--root", "-t", `-L${line},${line}`, "--", this.relpath];
-    let res = await this.repo.exec(args);
-    let output = res.stdout.trim();
-    if (!output.length) return;
-    let commit = output.match(/^\S+/)[0];
-    if (/^0+$/.test(commit)) {
-      import_coc11.window.showWarningMessage("not committed yet!");
-      return;
+  return result;
+}
+function mergeGutterSigns(unstaged, staged) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const sign of [...staged, ...unstaged]) {
+    const current = merged.get(sign.line);
+    if (!current) {
+      merged.set(sign.line, sign);
+    } else if (current.layer !== sign.layer) {
+      merged.set(sign.line, { line: sign.line, kind: "mixed", layer: "mixed" });
+    } else if (current.layer === "unstaged" || sign.layer === "unstaged") {
+      merged.set(sign.line, sign.layer === "unstaged" ? sign : current);
+    }
+  }
+  return [...merged.values()].sort((a, b) => a.line - b.line);
+}
+
+// src/model/buffer.ts
+var signGroup = "CocGit";
+var revPattern = "([0-9A-Za-z_.:/-]+)";
+var startPattern = new RegExp(`^<{7} (${revPattern})(:? .+)?$`);
+var sepPattern = new RegExp(`^={7}$`);
+var endPattern = new RegExp(`^>{7} (${revPattern})(:? .+)?$`);
+var commonPattern = /^\|{7}\smerged\scommon\sancestors/;
+function getPreviousConflict(conflicts, line) {
+  return conflicts.slice().reverse().find((conflict) => conflict.start < line);
+}
+function chunkContainsLine(chunk, line) {
+  const end = chunk.add.count === 0 ? chunk.add.lnum : chunk.add.lnum + chunk.add.count - 1;
+  return chunk.add.lnum <= line && end >= line;
+}
+function findCommitLine(lines, relpath, targetLine) {
+  let matchesFile = false;
+  let currentLine;
+  for (let index = 0; index < lines.length; index++) {
+    let text = lines[index];
+    if (text.startsWith("diff --git ")) {
+      matchesFile = parseDiffPath(text) === relpath;
+      currentLine = void 0;
+      continue;
     }
-    if (!useFloating) useFloating = this.config.showCommitInFloating;
-    if (useFloating) {
-      let content = await this.repo.safeRun(["--no-pager", "show", commit]);
-      if (content == null) return;
-      await this.showDoc(content.trim());
-      return;
+    if (!matchesFile) continue;
+    let match = text.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+    if (match) {
+      currentLine = Number(match[1]);
+      continue;
     }
-    await nvim.command(`keepalt above ${this.config.splitWindowCommand}`);
-    let hasFugitive = await nvim.getVar("loaded_fugitive");
-    if (hasFugitive) {
-      await nvim.command(`Gedit ${commit}`);
-    } else {
-      let content = await this.repo.safeRun(["--no-pager", "show", commit]);
-      if (content == null) return;
-      let lines = content.trim().split("\n");
-      nvim.pauseNotification();
-      nvim.command(`edit +setl\\ buftype=nofile [commit ${commit}]`, true);
-      nvim.command("setl foldmethod=syntax nobuflisted bufhidden=wipe", true);
-      nvim.command("setf git", true);
-      nvim.call("append", [0, lines], true);
-      nvim.command("normal! Gdd", true);
-      nvim.command(`exe 1`, true);
-      await nvim.resumeNotification(false, true);
+    if (currentLine == null || !text.startsWith("+") && !text.startsWith(" ")) continue;
+    if (currentLine === targetLine) return index + 1;
+    currentLine++;
+  }
+  return void 0;
+}
+var GitBuffer = class {
+  constructor(doc, config, relpath, repo, git, channel, floatFactory, hasConflicts) {
+    this.doc = doc;
+    this.config = config;
+    this.relpath = relpath;
+    this.repo = repo;
+    this.git = git;
+    this.channel = channel;
+    this.floatFactory = floatFactory;
+    this.hasConflicts = hasConflicts;
+    this.blameInfo = [];
+    this.diffs = [];
+    this.conflicts = [];
+    this.currentSigns = [];
+    this.gitState = { staged: [], unstaged: [] };
+    this.gitStatus = "";
+    this.foldEnabled = false;
+    this._disposed = false;
+    this.mutex = new import_coc11.Mutex();
+    this.conflictCheckNeeded = hasConflicts;
+    this.refresh = (0, import_debounce2.default)(() => {
+      this._refresh().catch((e) => {
+        channel.append(`[Error] ${e.message}`);
+      });
+    }, 200);
+    this._refresh().catch((e) => channel.append(`[Error] ${e.message}`));
+  }
+  get cachedDiffs() {
+    return this.diffs;
+  }
+  invalidateStagedCache() {
+    this.stagedCache = void 0;
+  }
+  markConflictCheck() {
+    this.conflictCheckNeeded = true;
+  }
+  async _refresh() {
+    if (this._disposed) return;
+    this.refresh.clear();
+    let release = await this.mutex.acquire();
+    try {
+      if (this._disposed) return;
+      let result = await Promise.all([
+        this.diffDocument(),
+        this.loadBlames(),
+        this.parseConflicts()
+      ].map((promise) => promise.then(() => void 0, (error) => error)));
+      result.forEach((error) => {
+        if (error) this.channel.append(`[Error] refresh error ${error}`);
+      });
+    } finally {
+      release();
     }
   }
-  async toggleFold() {
-    let { nvim } = import_coc11.workspace;
+  getChunk(line) {
+    if (!this.diffs || this.diffs.length == 0) return void 0;
+    return this.diffs.find((ch) => {
+      let { start, added, removed, changeType } = ch;
+      if (line == 1 && start == 0 && ch.end == 0) {
+        return true;
+      }
+      let end = changeType === "changed" /* Change */ && added.count > removed.count ? ch.end + added.count - removed.count : ch.end;
+      if (start <= line && end >= line) {
+        return true;
+      }
+      return false;
+    });
+  }
+  async chunkUndo() {
+    let line = await import_coc11.workspace.nvim.call("line", ".");
+    let diff = this.getChunk(line);
+    if (!diff) return;
+    let { start, lines, changeType } = diff;
+    let added = lines.filter((s) => s.startsWith("-")).map((s) => s.slice(1));
+    let removeCount = lines.filter((s) => s.startsWith("+")).length;
     let buf = this.doc.buffer;
-    let win = await nvim.window;
-    let bufnr = buf.id;
-    let doc = import_coc11.workspace.getDocument(bufnr);
-    if (!doc) return;
-    let infos = this.currentSigns;
-    if (!infos || infos.length == 0) {
-      import_coc11.window.showWarningMessage("No changes");
+    if (changeType == "delete" /* Delete */) {
+      await buf.setLines(added, { start, end: start, strictIndexing: false });
+    } else {
+      await buf.setLines(added, {
+        start: start - 1,
+        end: start - 1 + removeCount,
+        strictIndexing: false
+      });
+    }
+  }
+  async chunkStage() {
+    let relpath = toUnixSlash(this.relpath);
+    let line = await import_coc11.workspace.nvim.call("line", ".");
+    let diff = this.getChunk(line);
+    if (!diff) {
+      import_coc11.window.showErrorMessage("Not positioned in git chunk");
       return;
     }
-    let changedLines = new Set(infos.map((o) => o.lnum));
-    let foldContext = this.config.foldContext;
-    let max = this.doc.lineCount;
-    let ranges = [];
-    let start = null;
-    const addRange = (from, to) => {
-      let s = plus(from, foldContext, max);
-      let e = minus(to, foldContext, 0);
-      if (e - s <= 0) return;
-      ranges.push([s, e]);
-    };
-    for (let i = 1; i <= doc.lineCount; i++) {
-      let fold = !changedLines.has(i);
-      if (fold && start == null) {
-        start = i;
-        continue;
-      }
-      if (start != null && !fold) {
-        addRange(start, i - 1);
-        start = null;
+    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 from = quoteGitPath(`a/${relpath}`);
+    const to = quoteGitPath(`b/${relpath}`);
+    const lines = [
+      `diff --git ${from} ${to}`,
+      `index 000000..000000 100644`,
+      `--- ${from}`,
+      `+++ ${to}`,
+      head
+    ];
+    lines.push(...diff.lines);
+    lines.push("");
+    try {
+      await this.git.exec(this.repo.root, ["apply", "--cached", "--unidiff-zero", "-"], { input: lines.join("\n") });
+      this.invalidateStagedCache();
+      this.refresh();
+    } catch (e) {
+      this.channel.appendLine(`[Error] ${e.message}`);
+    }
+  }
+  async chunkUnstage() {
+    var _a;
+    let { nvim } = import_coc11.workspace;
+    const { diffs } = this;
+    let line = await nvim.call("line", ".");
+    let adjust = 0;
+    let invalid = false;
+    for (let diff of diffs) {
+      if (diff.end >= line) {
+        if (diff.start <= line && diff.changeType != "delete" /* Delete */) {
+          import_coc11.window.showErrorMessage(`Current line contains unstaged change.`);
+          invalid = true;
+        }
+        break;
       }
-      if (start != null && fold && i == doc.lineCount) {
-        addRange(start, i);
+      adjust -= diff.added.count;
+      adjust += diff.removed.count;
+    }
+    if (invalid) return;
+    line = line + adjust;
+    let stagedDiff = await this.repo.getStagedChunks(this.relpath);
+    let chunks = (_a = Object.values(stagedDiff)[0]) != null ? _a : [];
+    if (!chunks.length) {
+      import_coc11.window.showErrorMessage(`Staged chunk not found`);
+      return;
+    }
+    let chunk = chunks.find((o) => chunkContainsLine(o, line));
+    if (!chunk) {
+      import_coc11.window.showErrorMessage(`Unable to find staged chunk on current line`);
+      return;
+    }
+    this.channel.appendLine(`[Info] resolved chunk ${JSON.stringify(chunk, null, 2)}`);
+    let patch = createUnstagePatch(this.relpath, chunk);
+    if (!patch) return;
+    try {
+      await this.git.exec(this.repo.root, ["apply", "--cached", "--unidiff-zero", "-"], { input: patch });
+      this.invalidateStagedCache();
+      this.refresh();
+    } catch (e) {
+      import_coc11.window.showErrorMessage(`Unable to apply patch: ${e.message}`);
+      this.channel.appendLine(`[Error] ${e.message}`);
+    }
+  }
+  async nextChunk() {
+    if (this.config.enableStagedGutters) {
+      await this.moveToNextChunk();
+      return;
+    }
+    const { diffs } = this;
+    let { nvim } = import_coc11.workspace;
+    if (!diffs || diffs.length == 0) return;
+    let line = await nvim.call("line", ".");
+    for (let diff of diffs) {
+      if (diff.start > line) {
+        await import_coc11.window.moveTo({ line: Math.max(diff.start - 1, 0), character: 0 });
+        return;
       }
     }
-    let enabled = this.foldEnabled;
-    if (enabled) {
-      this.foldEnabled = false;
-      let cursor = await nvim.eval('getpos(".")');
-      let lnums = ranges.map((o) => o[0]);
-      let settings = this.foldSettings;
-      nvim.pauseNotification();
-      for (let lnum of lnums) {
-        nvim.command(`${lnum}normal! zd`, true);
+    if (await nvim.getOption("wrapscan")) {
+      await import_coc11.window.moveTo({ line: Math.max(diffs[0].start - 1, 0), character: 0 });
+    }
+  }
+  async prevChunk() {
+    if (this.config.enableStagedGutters) {
+      await this.moveToPreviousChunk();
+      return;
+    }
+    const { nvim } = import_coc11.workspace;
+    let { diffs } = this;
+    let line = await nvim.call("line", ".");
+    if (!diffs || diffs.length == 0) return;
+    for (let diff of diffs.slice().reverse()) {
+      if (diff.end < line) {
+        await import_coc11.window.moveTo({ line: Math.max(diff.start - 1, 0), character: 0 });
+        return;
       }
-      win.setOption("foldmethod", settings.foldmethod, true);
-      win.setOption("foldenable", settings.foldenable, true);
-      win.setOption("foldlevel", settings.foldlevel, true);
-      nvim.call("setpos", [".", cursor], true);
-      await nvim.resumeNotification();
-    } else {
-      this.foldEnabled = true;
-      let [foldmethod, foldenable, foldlevel] = await nvim.eval("[&foldmethod,&foldenable,&foldlevel]");
-      this.foldSettings = {
-        foldmethod,
-        foldenable: foldenable !== 0,
-        foldlevel
-      };
-      nvim.pauseNotification();
-      win.setOption("foldmethod", "manual", true);
-      nvim.command("silent! normal! zE", true);
-      win.setOption("foldenable", true, true);
-      win.setOption("foldlevel", 0, true);
-      await nvim.resumeNotification();
-      nvim.pauseNotification();
-      for (let r of ranges) {
-        nvim.command(`${r[0]},${r[1]}fold`, true);
+    }
+    if (await nvim.getOption("wrapscan")) {
+      await import_coc11.window.moveTo({ line: Math.max(diffs[diffs.length - 1].start - 1, 0), character: 0 });
+    }
+  }
+  getNavigationChunks() {
+    const chunks = [
+      ...this.diffs.map((diff) => ({
+        start: Math.max(1, diff.start),
+        end: Math.max(1, diff.end)
+      })),
+      ...this.gitState.staged.map((change) => {
+        var _a;
+        return {
+          start: Math.max(1, change.line),
+          end: Math.max(1, (_a = change.endLine) != null ? _a : change.line)
+        };
+      })
+    ].sort((a, b) => a.start - b.start || a.end - b.end);
+    const result = [];
+    for (const chunk of chunks) {
+      const previous = result[result.length - 1];
+      if (previous && chunk.start <= previous.end) {
+        previous.end = Math.max(previous.end, chunk.end);
+      } else {
+        result.push({ ...chunk });
       }
-      await nvim.resumeNotification();
     }
+    return result;
   }
-  async toggleGutters(enabled) {
-    this.config.enableGutters = enabled;
-    let { nvim } = import_coc11.workspace;
-    if (!enabled) {
-      nvim.call("sign_unplace", [signGroup, { buffer: this.doc.bufnr }], true);
-      nvim.redrawVim();
-    } else {
-      this.diffs = [];
-      await this.diffDocument(true);
+  async moveToNextChunk() {
+    const chunks = this.getNavigationChunks();
+    const { nvim } = import_coc11.workspace;
+    if (chunks.length === 0) return;
+    const line = await nvim.call("line", ".");
+    for (const chunk of chunks) {
+      if (chunk.start > line) {
+        await import_coc11.window.moveTo({ line: Math.max(chunk.start - 1, 0), character: 0 });
+        return;
+      }
+    }
+    if (await nvim.getOption("wrapscan")) {
+      await import_coc11.window.moveTo({ line: Math.max(chunks[0].start - 1, 0), character: 0 });
     }
   }
-  async parseConflicts() {
-    if (!this.config.conflict.enabled) {
-      if (this.conflicts.length) {
-        this.conflicts = [];
-        await this.highlightConflicts([]);
+  async moveToPreviousChunk() {
+    const chunks = this.getNavigationChunks();
+    const { nvim } = import_coc11.workspace;
+    if (chunks.length === 0) return;
+    const line = await nvim.call("line", ".");
+    for (const chunk of chunks.slice().reverse()) {
+      if (chunk.end < line) {
+        await import_coc11.window.moveTo({ line: Math.max(chunk.start - 1, 0), character: 0 });
+        return;
       }
-      return;
     }
-    if (!this.hasConflicts && !this.conflictCheckNeeded) return;
-    this.conflictCheckNeeded = false;
-    this.hasConflicts = await this.repo.hasConflicts(this.relpath);
-    if (this._disposed) return;
-    if (!this.hasConflicts) {
-      this.conflicts = [];
-      await this.highlightConflicts([]);
-      return;
+    if (await nvim.getOption("wrapscan")) {
+      await import_coc11.window.moveTo({ line: Math.max(chunks[chunks.length - 1].start - 1, 0), character: 0 });
     }
-    const lines = this.doc.textDocument.lines;
-    let conflicts = [];
-    let conflict = null;
-    let state = 0 /* Initial */;
-    let mkStartConflict = (index, current) => ({
-      start: index + 1,
-      sep: 0,
-      end: 0,
-      current,
-      incoming: ""
-    });
-    lines.forEach((line, index) => {
-      switch (state) {
-        case 0 /* Initial */: {
-          const match = line.match(startPattern);
-          if (match) {
-            conflict = mkStartConflict(index, match[1]);
-            state = 1 /* MatchedStart */;
-          }
-          break;
-        }
-        case 2 /* MatchedCommon */:
-        case 1 /* MatchedStart */: {
-          let match = line.match(sepPattern);
-          if (match) {
-            conflict.sep = index + 1;
-            state = 3 /* MatchedSep */;
-          } else {
-            const startMatch = line.match(startPattern);
-            if (startMatch) {
-              conflict = mkStartConflict(index, startMatch[1]);
-              state = 1 /* MatchedStart */;
-            } else if (line.match(endPattern)) {
-              conflict = null;
-              state = 0 /* Initial */;
-            } else if (line.match(commonPattern)) {
-              conflict.common = index + 1;
-              state = 2 /* MatchedCommon */;
-            }
-          }
-          break;
-        }
-        case 3 /* MatchedSep */: {
-          const match = line.match(endPattern);
-          if (match) {
-            conflict.end = index + 1;
-            conflict.incoming = match[1];
-            conflicts.push(conflict);
-            conflict = null;
-            state = 0 /* Initial */;
-          } else {
-            const startMatch = line.match(startPattern);
-            if (startMatch) {
-              conflict = mkStartConflict(index, startMatch[1]);
-              state = 1 /* MatchedStart */;
-            } else if (line.match(sepPattern)) {
-              conflict = null;
-              state = 0 /* Initial */;
-            }
-          }
+  }
+  async chunkInfo() {
+    let line = await import_coc11.workspace.nvim.call("line", ".");
+    let diff = this.getChunk(line);
+    if (diff) {
+      let content = diff.head + "\n" + diff.lines.join("\n");
+      await this.showDoc(content, "diff");
+    } else {
+      let chunks = [];
+      try {
+        let stagedDiff = await this.repo.getStagedChunks(this.relpath);
+        chunks = Object.values(stagedDiff)[0];
+      } catch (e) {
+      }
+      let adjust = 0;
+      for (let diff2 of this.diffs) {
+        if (diff2.end >= line) {
           break;
         }
+        adjust -= diff2.added.count;
+        adjust += diff2.removed.count;
+      }
+      line = line + adjust;
+      let chunk = chunks.find((o) => chunkContainsLine(o, line));
+      if (chunk) {
+        let content = "Staged changes\n" + chunk.lines.join("\n");
+        await this.showDoc(content, "diff");
+      } else {
+        await this.showCommit(true);
       }
-    });
-    this.conflicts = conflicts;
-    await this.highlightConflicts(conflicts);
-    if (conflicts.length == 0) {
-      this.hasConflicts = false;
     }
   }
-  async highlightConflicts(conflicts) {
+  allChunkInfo() {
+    return this.diffs ? this.diffs.slice() : [];
+  }
+  async showBlameInfo(lnum) {
     if (this._disposed) return;
-    let buffer = this.doc.buffer;
-    let currentHlGroup = this.config.conflict.currentHlGroup;
-    let incomingHlGroup = this.config.conflict.incomingHlGroup;
-    let commonHlGroup = this.config.conflict.commonHlGroup;
     let { nvim } = import_coc11.workspace;
-    nvim.pauseNotification();
-    buffer.clearNamespace(this.config.conflictSrcId, 0, -1);
-    const srcId = this.config.conflictSrcId;
-    conflicts.map((conflict) => {
-      let currEnd = conflict.common ? conflict.common - 1 : conflict.sep - 1;
-      let currRange = import_coc11.Range.create(import_coc11.Position.create(conflict.start - 1, 0), import_coc11.Position.create(currEnd, 0));
-      let incomingRange = import_coc11.Range.create(import_coc11.Position.create(conflict.sep, 0), import_coc11.Position.create(conflict.end, 0));
-      buffer.highlightRanges(srcId, currentHlGroup, [currRange]);
-      buffer.highlightRanges(srcId, incomingHlGroup, [incomingRange]);
-      if (conflict.common) {
-        let range = import_coc11.Range.create(import_coc11.Position.create(conflict.common - 1, 0), import_coc11.Position.create(conflict.sep - 1, 0));
-        buffer.highlightRanges(srcId, commonHlGroup, [range]);
+    let { virtualTextSrcId, addGBlameToBufferVar, addGBlameToVirtualText } = this.config;
+    if (!this.showBlame) return;
+    let infos = this.blameInfo;
+    if (!infos) return;
+    let blameText;
+    if (infos.length == 0) {
+      blameText = "File not indexed";
+    } else {
+      let info = infos.find((o) => lnum >= o.startLnum && lnum <= o.endLnum);
+      if (info && info.author && info.author != "Not Committed Yet") {
+        blameText = formatBlameText(info, this.config.blameFormat);
+      } else {
+        blameText = "Not committed yet";
       }
-    });
-    nvim.resumeNotification(false, true);
+    }
+    let buffer = nvim.createBuffer(this.doc.bufnr);
+    let hide_blame = await nvim.getVar("coc_git_hide_blame_virtual_text");
+    if (hide_blame) {
+      buffer.clearNamespace(virtualTextSrcId);
+    } else {
+      if (addGBlameToBufferVar) {
+        nvim.pauseNotification();
+        buffer.setVar("coc_git_blame", blameText, true);
+        nvim.call("coc#util#do_autocmd", ["CocGitStatusChange"], true);
+        nvim.resumeNotification(false, true);
+      }
+      if (addGBlameToVirtualText) {
+        const prefix = this.config.virtualTextPrefix;
+        nvim.pauseNotification();
+        buffer.clearNamespace(virtualTextSrcId);
+        buffer.setVirtualText(virtualTextSrcId, lnum - 1, [[prefix + blameText, "CocCodeLens"]]);
+        nvim.resumeNotification(true, true);
+      }
+    }
   }
-  async showDoc(content, filetype = "diff") {
-    if (this.floatFactory) {
-      let docs = [{ content, filetype }];
-      await this.floatFactory.show(docs, this.config.floatConfig);
+  async showBlameDoc(lnum) {
+    let indexed = await this.repo.isIndexed(this.relpath);
+    if (!indexed) {
+      import_coc11.window.showWarningMessage("File not indexed");
+    } else if (await this.repo.isShallow()) {
+      import_coc11.window.showWarningMessage("Shallow repository, blame not available");
     } else {
-      const lines = content.split("\n");
-      import_coc11.workspace.nvim.call("coc#ui#preview_info", [lines, filetype], true);
+      let infos = await this.getBlameInfo([lnum, lnum]);
+      let info = infos.find((o) => lnum >= o.startLnum && lnum <= o.endLnum);
+      if (info && info.author && info.author != "Not Committed Yet") {
+        let blameText = [];
+        blameText.push(`${info.author}, ${info.time}`);
+        blameText.push(`${info.summary}`);
+        blameText.push(`${info.sha.substring(0, 7)}`);
+        await this.showDoc(blameText.join("\n\n"), "text");
+      } else {
+        import_coc11.window.showWarningMessage("Not committed yet");
+      }
     }
   }
-  setBufferStatus(status) {
-    let exists = this.gitStatus;
-    if (exists == status) return;
-    this.gitStatus = status;
+  async diffDocument(force = false) {
     let { nvim } = import_coc11.workspace;
-    let buffer = nvim.createBuffer(this.doc.bufnr);
-    nvim.pauseNotification();
-    buffer.setVar("coc_git_status", status, true);
-    nvim.callTimer("coc#util#do_autocmd", ["CocGitStatusChange"], true);
-    nvim.resumeNotification(false, true);
-  }
-  getSignName(changeType) {
-    switch (changeType) {
-      case "delete" /* Delete */:
-        return "CocGitRemoved";
-      case "add" /* Add */:
-        return "CocGitAdded";
-      case "changed" /* Change */:
-        return "CocGitChanged";
-      case "topdelete":
-        return "CocGitTopRemoved";
-      case "changedelete":
-        return "CocGitChangeRemoved";
+    let revision = this.config.diffRevision;
+    const { bufnr } = this.doc;
+    let content = this.doc.content;
+    let eol = this.doc.textDocument["eol"];
+    let encoding = await this.doc.buffer.getOption("fileencoding");
+    const diffs = await this.repo.getDiff(this.relpath, eol ? content : content + "\n", revision, encoding || "utf8");
+    if (diffs == null || this._disposed) return;
+    const unstaged = changesFromDiffs(diffs, "unstaged");
+    let staged = [];
+    let stagedLines = [];
+    if (this.config.enableStagedGutters) {
+      const cached = await this.getStagedChanges(encoding || "utf8");
+      if (cached) {
+        staged = cached.changes;
+        stagedLines = cached.indexLines;
+      }
     }
-    return "";
+    if (this._disposed) return;
+    const oldState = this.gitState;
+    const mapping = createLineMapping(stagedLines, this.doc.textDocument.lines, unstaged);
+    const mappedStaged = staged.length ? mapIndexChangesToBuffer(staged, mapping, this.doc.textDocument.lines.length) : [];
+    const unstagedSigns = gutterSignsFromChanges(unstaged);
+    const stagedSigns = gutterSignsFromChanges(mappedStaged);
+    const currentSigns = mergeGutterSigns(unstagedSigns, this.config.enableStagedGutters ? stagedSigns : []);
+    this.diffs = diffs;
+    this.gitState = { staged: mappedStaged, unstaged };
+    if (equals(oldState, this.gitState) && !force) return;
+    let added = 0;
+    let changed = 0;
+    let removed = 0;
+    for (let diff of diffs) {
+      if (diff.changeType == "add" /* Add */) {
+        added += diff.added.count;
+      } else if (diff.changeType == "delete" /* Delete */) {
+        removed += diff.removed.count;
+      } else if (diff.changeType == "changed" /* Change */) {
+        let [add, remove] = [diff.added.count, diff.removed.count];
+        let min = Math.min(add, remove);
+        changed += min;
+        added += add - min;
+        removed += remove - min;
+      }
+    }
+    let items = [];
+    if (added) items.push(`+${added}`);
+    if (changed) items.push(`~${changed}`);
+    if (removed) items.push(`-${removed}`);
+    let status = `  ${items.join(" ")} `;
+    this.setBufferStatus(status);
+    this.currentSigns = currentSigns;
+    if (this.currentSigns.length === 0) {
+      if (this.config.enableGutters) {
+        nvim.call("sign_unplace", [signGroup, { buffer: bufnr }], true);
+        nvim.redrawVim();
+      }
+      return;
+    }
+    if (!this.config.realtimeGutters && !force) return;
+    this.updateGutters();
   }
-  get showBlame() {
-    return this.config.addGBlameToVirtualText || this.config.addGBlameToBufferVar;
+  async getStagedChanges(encoding) {
+    const [indexIdentity, headIdentity] = await Promise.all([
+      this.repo.getIndexIdentity(),
+      this.repo.getHeadIdentity()
+    ]);
+    if (this.stagedCache && this.stagedCache.indexIdentity === indexIdentity && this.stagedCache.headIdentity === headIdentity) {
+      return { changes: this.stagedCache.stagedInIndex, indexLines: this.stagedCache.indexLines };
+    }
+    const [head, index] = await Promise.all([
+      this.repo.getFileContent(this.relpath, "HEAD:", encoding),
+      this.repo.getFileContent(this.relpath, ":", encoding)
+    ]);
+    const stagedDiffs = await this.repo.getDiffFromContents(head ? head + "\n" : "", index ? index + "\n" : "");
+    const stagedInIndex = changesFromDiffs(stagedDiffs, "staged");
+    const headLines = head ? head.split("\n") : [];
+    const indexLines = index ? index.split("\n") : [];
+    this.stagedCache = { indexIdentity, headIdentity, headLines, indexLines, stagedInIndex };
+    return { changes: stagedInIndex, indexLines };
   }
-  dispose() {
+  updateGutters() {
     if (this._disposed) return;
-    this._disposed = true;
+    if (!this.config.enableGutters) return;
     let { nvim } = import_coc11.workspace;
     let { bufnr } = this.doc;
-    let buffer = nvim.createBuffer(bufnr);
+    let { signPriority, stagedSignPriority } = this.config;
+    let signs = this.currentSigns;
     nvim.pauseNotification();
-    buffer.setVar("coc_git_status", "", true);
-    buffer.clearNamespace(this.config.conflictSrcId, 0, -1);
     nvim.call("sign_unplace", [signGroup, { buffer: bufnr }], true);
-    this.refresh.clear();
-    if (this.config.addGBlameToBufferVar) {
-      buffer.setVar("coc_git_blame", "", true);
-    }
-    if (this.config.addGBlameToVirtualText) {
-      buffer.clearNamespace(this.config.virtualTextSrcId);
+    for (let sign of signs) {
+      let name = this.getSignName(sign.kind, sign.layer);
+      const priority = sign.layer === "staged" ? stagedSignPriority : signPriority;
+      nvim.call("sign_place", [0, signGroup, name, bufnr, { lnum: sign.line, priority }], true);
     }
-    nvim.resumeNotification(false, true);
-    this.foldEnabled = false;
-  }
-};
-function plus(val, count, max) {
-  if (!count) return val;
-  val = val + count;
-  return Math.min(max, val);
-}
-function minus(val, count, min) {
-  if (!count) return val;
-  val = val - count;
-  return Math.max(min, val);
-}
-
-// src/model/git.ts
-var cp = __toESM(require("child_process"));
-var import_coc12 = require("coc.nvim");
-var import_iconv_lite = __toESM(require_lib());
-var import_path5 = __toESM(require("path"));
-var Git = class {
-  constructor(gitInfo, channel) {
-    this.gitInfo = gitInfo;
-    this.channel = channel;
+    nvim.resumeNotification(true, true);
   }
-  get path() {
-    return this.gitInfo.path;
+  async loadBlames() {
+    if (!this.showBlame) return;
+    let result = [];
+    let indexed = await this.repo.isIndexed(this.relpath);
+    if (indexed) result = await this.getBlameInfo();
+    if (this._disposed) return;
+    this.blameInfo = result;
   }
-  async getRepositoryRoot(repositoryPath) {
-    const result = await this.exec(repositoryPath, ["rev-parse", "--show-toplevel"]);
-    let repoRootPath = import_path5.default.normalize(result.stdout.trim());
-    if (process.platform === "win32" && repoRootPath.startsWith("\\") && !process.env.SHELL) {
-      repoRootPath = repoRootPath.replace(/^\\([^\\]*)\\/, "$1:\\");
+  async getBlameInfo(range) {
+    let { relpath } = this;
+    let root = this.repo.root;
+    let res = [];
+    const useRealTime = this.config.blameUseRealTime;
+    try {
+      let currentAuthor = await this.repo.getUsername();
+      const args = ["--no-pager", "blame", "-w", "-b", "-p", "--incremental", "--root", "--date", "relative", "--contents", "-"];
+      if (range) args.push("-L", range.join(","));
+      args.push("--", relpath);
+      let r = await this.git.exec(root, args, {
+        log: false,
+        input: this.doc.content
+      });
+      if (!r.stdout) return res;
+      let info;
+      const commits = /* @__PURE__ */ new Map();
+      for (let line of r.stdout.trim().split(/\r?\n/)) {
+        line = line.trim();
+        if (/^(author |committer )?External file \(--contents\)/.test(line)) {
+          line = "Not committed yet.";
+        }
+        let ms = line.match(/^([A-Za-z0-9]+)\s(\d+)\s(\d+)\s(\d+)/);
+        if (ms) {
+          let startLnum = parseInt(ms[3], 10);
+          info = { startLnum, sha: ms[1], endLnum: startLnum + parseInt(ms[4], 10) - 1, index: ms[2] };
+          if (!/^0+$/.test(ms[1])) {
+            let find = commits.get(ms[1]);
+            if (find) {
+              info.author = find.author;
+              info.time = find.time;
+              info.summary = find.summary;
+            } else {
+              commits.set(ms[1], info);
+            }
+          }
+          res.push(info);
+        } else if (info) {
+          if (line.startsWith("author ")) {
+            let author = line.replace(/^author/, "").trim();
+            info.author = author == currentAuthor ? "You" : author;
+          } else if (line.startsWith("author-time ")) {
+            let text = line.replace(/^author-time/, "").trim();
+            const timestamps = parseInt(text, 10) * 1e3;
+            info.time = useRealTime ? new Date(timestamps).toLocaleString() : format(timestamps, process.env.LANG);
+          } else if (line.startsWith("summary ")) {
+            let text = line.replace(/^summary/, "").trim();
+            info.summary = text;
+          }
+        }
+      }
+      return res;
+    } catch (e) {
+      this.channel.appendLine(e.stack);
     }
-    return repoRootPath;
-  }
-  async exec(cwd, args, options = {}) {
-    options = Object.assign({ cwd }, options || {});
-    return await this._exec(args, options);
-  }
-  stream(cwd, args, options = {}) {
-    options = Object.assign({ cwd }, options || {});
-    return this.spawn(args, options);
+    return res;
   }
-  async _exec(args, options = {}) {
-    var _a, _b, _c, _d;
-    if ((_a = options.cancellationToken) == null ? void 0 : _a.isCancellationRequested) {
-      throw new Error("Cancelled");
+  async diffCached() {
+    let res = await this.repo.safeRun(["diff", "--cached"]);
+    if (!res.trim()) {
+      import_coc11.window.showWarningMessage("Empty diff");
+      return;
     }
-    const child = this.spawn(args, options);
-    if (options.input !== void 0) {
-      (_b = child.stdin) == null ? void 0 : _b.on("error", () => {
-      });
-      (_c = child.stdin) == null ? void 0 : _c.end(options.input, "utf8");
+    let { nvim } = import_coc11.workspace;
+    nvim.pauseNotification();
+    nvim.command(`keepalt above new +setl\\ previewwindow`, true);
+    nvim.call("append", [0, res.split(/\r?\n/)], true);
+    nvim.command("normal! Gdd", true);
+    nvim.command(`exe 1`, true);
+    nvim.command("setfiletype git", true);
+    nvim.command("setl buftype=nofile nomodifiable bufhidden=wipe nobuflisted", true);
+    await nvim.resumeNotification();
+  }
+  async nextConflict() {
+    let { nvim } = import_coc11.workspace;
+    if (!this.conflicts.length) {
+      import_coc11.window.showWarningMessage("No conflicts detected");
+      return;
     }
-    const bufferResult = await exec2(child, options.cancellationToken);
-    if (options.log !== false && bufferResult.stderr.length > 0) {
-      this.log(`${bufferResult.stderr}
-`);
+    let line = await nvim.call("line", ".");
+    for (let conflict of this.conflicts) {
+      if (conflict.start > line) {
+        await import_coc11.window.moveTo({ line: Math.max(conflict.start - 1, 0), character: 0 });
+        return;
+      }
     }
-    let encoding = options.encoding || "utf8";
-    encoding = import_iconv_lite.default.encodingExists(encoding) ? encoding : "utf8";
-    const result = {
-      exitCode: bufferResult.exitCode,
-      stdout: import_iconv_lite.default.decode(bufferResult.stdout, encoding),
-      stderr: bufferResult.stderr
-    };
-    if (bufferResult.exitCode && !((_d = options.allowedExitCodes) == null ? void 0 : _d.includes(bufferResult.exitCode))) {
-      this.channel.appendLine(`Error ${result.exitCode} on: 'git ${args.join(" ")}' in ${options.cwd}`);
-      this.channel.append(result.stderr);
-      this.channel.append(result.stdout);
-      return Promise.reject(new Error("Failed to execute git"));
+    if (await nvim.getOption("wrapscan")) {
+      await import_coc11.window.moveTo({ line: Math.max(this.conflicts[0].start - 1, 0), character: 0 });
     }
-    return result;
   }
-  spawn(args, options = {}) {
-    const { input, encoding: _encoding, log: _log, cancellationToken: _cancellationToken, allowedExitCodes: _allowedExitCodes, ...spawnOptions } = options;
-    if (!spawnOptions.stdio && input === void 0) {
-      spawnOptions.stdio = ["ignore", null, null];
+  async prevConflict() {
+    let { nvim } = import_coc11.workspace;
+    if (!this.conflicts.length) {
+      import_coc11.window.showWarningMessage("No conflicts detected", "warning");
+      return;
     }
-    spawnOptions.env = Object.assign({}, process.env, spawnOptions.env || {}, {
-      LC_ALL: "en_US.UTF-8",
-      LANG: "en_US.UTF-8"
-    });
-    if (options.log !== false) {
-      this.log(`> git ${args.join(" ")}
-`);
+    let line = await nvim.call("line", ".");
+    let conflict = getPreviousConflict(this.conflicts, line);
+    if (conflict) {
+      await import_coc11.window.moveTo({ line: Math.max(conflict.start - 1, 0), character: 0 });
+      return;
+    }
+    if (await nvim.getOption("wrapscan")) {
+      conflict = this.conflicts[this.conflicts.length - 1];
+      await import_coc11.window.moveTo({ line: Math.max(conflict.start - 1, 0), character: 0 });
     }
-    return cp.spawn(this.gitInfo.path, args, spawnOptions);
-  }
-  log(output) {
-    this.channel.append(output);
-  }
-};
-var git_default = Git;
-async function exec2(child, cancellationToken) {
-  if (!child.stdout || !child.stderr) {
-    throw new Error("Failed to get stdout or stderr from git process.");
-  }
-  if (cancellationToken && cancellationToken.isCancellationRequested) {
-    throw new Error("Cancelled");
   }
-  const disposables = [];
-  const once = (ee, name, fn) => {
-    ee.once(name, fn);
-    disposables.push(import_coc12.Disposable.create(() => ee.removeListener(name, fn)));
-  };
-  const on = (ee, name, fn) => {
-    ee.on(name, fn);
-    disposables.push(import_coc12.Disposable.create(() => ee.removeListener(name, fn)));
-  };
-  let result = Promise.all([
-    new Promise((c, e) => {
-      once(child, "error", cpErrorHandler(e));
-      once(child, "exit", (code) => c(code != null ? code : -1));
-    }),
-    new Promise((c) => {
-      const buffers = [];
-      on(child.stdout, "data", (b) => buffers.push(b));
-      once(child.stdout, "close", () => c(Buffer.concat(buffers)));
-    }),
-    new Promise((c) => {
-      const buffers = [];
-      on(child.stderr, "data", (b) => buffers.push(b));
-      once(child.stderr, "close", () => c(Buffer.concat(buffers).toString("utf8")));
-    })
-  ]);
-  if (cancellationToken) {
-    const cancellationPromise = new Promise((_, e) => {
-      const disposable = onceEvent(cancellationToken.onCancellationRequested)(() => {
-        try {
-          child.kill();
-        } catch (err) {
+  async conflictKeepPart(part) {
+    const { nvim } = import_coc11.workspace;
+    let conflicts = this.conflicts;
+    if (!conflicts || conflicts.length == 0) {
+      import_coc11.window.showWarningMessage("No conflicts detected");
+      return;
+    }
+    let line = await nvim.call("line", ".");
+    for (let conflict of conflicts) {
+      if (conflict.start <= line && conflict.end >= line) {
+        switch (part) {
+          case 0 /* Current */:
+            let start = conflict.common ? conflict.common : conflict.sep;
+            await nvim.command(`${start},${conflict.end}d | ${conflict.start}d`);
+            return;
+          case 1 /* Incoming */:
+            await nvim.command(`${conflict.end}d | ${conflict.start},${conflict.sep}d`);
+            return;
+          case 2 /* Both */:
+            if (conflict.common) {
+              await nvim.command(`${conflict.end}d | ${conflict.common},${conflict.sep}d | ${conflict.start}d`);
+            } else {
+              await nvim.command(`${conflict.end}d | ${conflict.sep}d | ${conflict.start}d`);
+            }
+            return;
         }
-        e(new Error("Cancelled"));
-      });
-      disposables.push(disposable);
-    });
-    result = Promise.race([result, cancellationPromise]);
-  }
-  try {
-    const [exitCode, stdout, stderr] = await result;
-    return { exitCode, stdout, stderr };
-  } finally {
-    (0, import_coc12.disposeAll)(disposables);
-  }
-}
-
-// src/model/repo.ts
-var import_fs2 = __toESM(require("fs"));
-var import_os = __toESM(require("os"));
-var import_path6 = __toESM(require("path"));
-var import_util5 = __toESM(require("util"));
-
-// node_modules/uuid/dist/esm/stringify.js
-var byteToHex = [];
-for (let i = 0; i < 256; ++i) {
-  byteToHex.push((i + 256).toString(16).slice(1));
-}
-function unsafeStringify(arr, offset = 0) {
-  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
-}
-
-// node_modules/uuid/dist/esm/rng.js
-var import_crypto = require("crypto");
-var rnds8Pool = new Uint8Array(256);
-var poolPtr = rnds8Pool.length;
-function rng() {
-  if (poolPtr > rnds8Pool.length - 16) {
-    (0, import_crypto.randomFillSync)(rnds8Pool);
-    poolPtr = 0;
+      }
+    }
+    import_coc11.window.showWarningMessage("Not positioned on a conflict");
   }
-  return rnds8Pool.slice(poolPtr, poolPtr += 16);
-}
-
-// node_modules/uuid/dist/esm/native.js
-var import_crypto2 = require("crypto");
-var native_default = { randomUUID: import_crypto2.randomUUID };
-
-// node_modules/uuid/dist/esm/v4.js
-function v4(options, buf, offset) {
-  var _a, _b, _c;
-  if (native_default.randomUUID && !buf && !options) {
-    return native_default.randomUUID();
+  async browser(action = "open", range, permalink = false) {
+    let { nvim } = import_coc11.workspace;
+    let config = import_coc11.workspace.getConfiguration("git");
+    let head = (await this.repo.safeRun(["rev-parse", "HEAD"])).trim();
+    let branch = config.get("browserBranchName", "").trim();
+    if (!branch.length) {
+      branch = (await this.repo.safeRun(["symbolic-ref", "--short", "-q", "HEAD"])).trim();
+    }
+    let lines = range && range.length == 2 ? [
+      range[0],
+      range[1]
+    ] : [await nvim.eval('line(".")')];
+    if (this.doc.filetype == "markdown") {
+      let line = await nvim.call("getline", ["."]);
+      if (line.startsWith("#")) {
+        let words = line.replace(/^#+\s*/, "").split(/\s+/);
+        lines = words.map((s) => s.toLowerCase()).join("-");
+      }
+    }
+    let output = await this.repo.safeRun(["remote"]);
+    if (!output.trim()) {
+      import_coc11.window.showWarningMessage(`No remote found`);
+      return;
+    }
+    let names = output.trim().split(/\r?\n/);
+    let browserRemoteName = config.get("browserRemoteName", "").trim();
+    if (browserRemoteName.length > 0) {
+      if (names.includes(browserRemoteName)) {
+        names = [browserRemoteName];
+      } else {
+        import_coc11.window.showWarningMessage("Configured git.browserRemoteName missing from remote list");
+        return;
+      }
+    }
+    let urls = [];
+    for (let name of names) {
+      let uri = await this.repo.safeRun(["config", "--get", `remote.${name}.url`]);
+      if (!uri.length) continue;
+      let repoURL = getRepoUrl(uri);
+      if (!repoURL) continue;
+      let tmp;
+      try {
+        tmp = new import_url.URL(repoURL);
+      } catch (_e) {
+        continue;
+      }
+      let hostname = tmp.hostname;
+      let fix = "|";
+      try {
+        fix = config.get("urlFix")[hostname][permalink ? 1 : 0];
+      } catch (e) {
+      }
+      let url = getUrl(fix, repoURL, permalink ? head : branch || head, toUnixSlash(this.relpath), lines);
+      if (url) urls.push(url);
+    }
+    if (urls.length == 1) {
+      if (action == "open") {
+        await import_coc11.workspace.openResource(urls[0]);
+      } else {
+        nvim.call("setreg", ["+", urls[0]], true);
+        import_coc11.window.showInformationMessage("Copied url to clipboard");
+      }
+    } else if (urls.length > 1) {
+      let url = await import_coc11.window.showQuickPick(urls, { canPickMany: false, title: "Pick remote url" });
+      if (url) {
+        if (action == "open") {
+          await import_coc11.workspace.openResource(url);
+        } else {
+          nvim.call("setreg", ["+", url], true);
+          nvim.call("setreg", ["*", url], true);
+          import_coc11.window.showInformationMessage("Copied url to clipboard");
+        }
+      }
+    }
   }
-  options = options || {};
-  const rnds = (_c = (_b = options.random) != null ? _b : (_a = options.rng) == null ? void 0 : _a.call(options)) != null ? _c : rng();
-  if (rnds.length < 16) {
-    throw new Error("Random bytes length must be >= 16");
+  // show commit of current line in split window
+  async showCommit(useFloating = false) {
+    var _a;
+    let indexed = await this.repo.isIndexed(this.relpath);
+    if (!indexed) {
+      import_coc11.window.showWarningMessage(`"${this.relpath}" not indexed.`);
+      return;
+    }
+    let nvim = import_coc11.workspace.nvim;
+    let line = await nvim.eval('line(".")');
+    let args = ["--no-pager", "blame", "-w", "--porcelain", "--root", `-L${line},${line}`, "--", this.relpath];
+    let res = await this.repo.exec(args);
+    let output = res.stdout.trim();
+    if (!output.length) return;
+    let match = output.match(/^(\S+)\s+(\d+)/);
+    if (!match) return;
+    let commit = match[1];
+    let commitLine = Number(match[2]);
+    if (/^0+$/.test(commit)) {
+      import_coc11.window.showWarningMessage("not committed yet!");
+      return;
+    }
+    if (!useFloating) useFloating = this.config.showCommitInFloating;
+    if (useFloating) {
+      let content = await this.repo.safeRun(["--no-pager", "show", commit]);
+      if (content == null) return;
+      await this.showDoc(content.trim());
+      return;
+    }
+    await nvim.command(`keepalt above ${this.config.splitWindowCommand}`);
+    let hasFugitive = await nvim.eval('get(g:, "loaded_fugitive", 0)');
+    if (hasFugitive) {
+      await nvim.command(`Gedit ${commit}`);
+      let lines = await nvim.call("getline", [1, "$"]);
+      let target = findCommitLine(lines, this.relpath, commitLine);
+      if (target) await nvim.call("cursor", [target, 1]);
+    } else {
+      let content = await this.repo.safeRun(["--no-pager", "show", commit]);
+      if (content == null) return;
+      let lines = content.trim().split("\n");
+      let target = (_a = findCommitLine(lines, this.relpath, commitLine)) != null ? _a : 1;
+      nvim.pauseNotification();
+      nvim.command(`edit +setl\\ buftype=nofile [commit ${commit}]`, true);
+      nvim.command("setl foldmethod=syntax nobuflisted bufhidden=wipe", true);
+      nvim.command("setf git", true);
+      nvim.call("append", [0, lines], true);
+      nvim.command("normal! Gdd", true);
+      nvim.command(`exe ${target}`, true);
+      await nvim.resumeNotification(false, true);
+    }
   }
-  rnds[6] = rnds[6] & 15 | 64;
-  rnds[8] = rnds[8] & 63 | 128;
-  if (buf) {
-    offset = offset || 0;
-    if (offset < 0 || offset + 16 > buf.length) {
-      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+  async toggleFold() {
+    let { nvim } = import_coc11.workspace;
+    let buf = this.doc.buffer;
+    let win = await nvim.window;
+    let bufnr = buf.id;
+    let doc = import_coc11.workspace.getDocument(bufnr);
+    if (!doc) return;
+    let infos = this.currentSigns;
+    if (!infos || infos.length == 0) {
+      import_coc11.window.showWarningMessage("No changes");
+      return;
     }
-    for (let i = 0; i < 16; ++i) {
-      buf[offset + i] = rnds[i];
+    let changedLines = new Set(infos.map((o) => o.line));
+    let foldContext = this.config.foldContext;
+    let max = this.doc.lineCount;
+    let ranges = [];
+    let start = null;
+    const addRange = (from, to) => {
+      let s = plus(from, foldContext, max);
+      let e = minus(to, foldContext, 0);
+      if (e - s <= 0) return;
+      ranges.push([s, e]);
+    };
+    for (let i = 1; i <= doc.lineCount; i++) {
+      let fold = !changedLines.has(i);
+      if (fold && start == null) {
+        start = i;
+        continue;
+      }
+      if (start != null && !fold) {
+        addRange(start, i - 1);
+        start = null;
+      }
+      if (start != null && fold && i == doc.lineCount) {
+        addRange(start, i);
+      }
+    }
+    let enabled = this.foldEnabled;
+    if (enabled) {
+      this.foldEnabled = false;
+      let cursor = await nvim.eval('getpos(".")');
+      let lnums = ranges.map((o) => o[0]);
+      let settings = this.foldSettings;
+      nvim.pauseNotification();
+      for (let lnum of lnums) {
+        nvim.command(`${lnum}normal! zd`, true);
+      }
+      win.setOption("foldmethod", settings.foldmethod, true);
+      win.setOption("foldenable", settings.foldenable, true);
+      win.setOption("foldlevel", settings.foldlevel, true);
+      nvim.call("setpos", [".", cursor], true);
+      await nvim.resumeNotification();
+    } else {
+      this.foldEnabled = true;
+      let [foldmethod, foldenable, foldlevel] = await nvim.eval("[&foldmethod,&foldenable,&foldlevel]");
+      this.foldSettings = {
+        foldmethod,
+        foldenable: foldenable !== 0,
+        foldlevel
+      };
+      nvim.pauseNotification();
+      win.setOption("foldmethod", "manual", true);
+      nvim.command("silent! normal! zE", true);
+      win.setOption("foldenable", true, true);
+      win.setOption("foldlevel", 0, true);
+      await nvim.resumeNotification();
+      nvim.pauseNotification();
+      for (let r of ranges) {
+        nvim.command(`${r[0]},${r[1]}fold`, true);
+      }
+      await nvim.resumeNotification();
     }
-    return buf;
   }
-  return unsafeStringify(rnds);
-}
-var v4_default = v4;
-
-// src/model/repo.ts
-var Repo = class {
-  constructor(git, channel, root) {
-    this.git = git;
-    this.channel = channel;
-    this.root = root;
+  async toggleGutters(enabled) {
+    this.config.enableGutters = enabled;
+    let { nvim } = import_coc11.workspace;
+    if (!enabled) {
+      nvim.call("sign_unplace", [signGroup, { buffer: this.doc.bufnr }], true);
+      nvim.redrawVim();
+    } else {
+      this.diffs = [];
+      await this.diffDocument(true);
+    }
   }
-  /**
-   * Get staged info
-   */
-  async getStagedChunks(relpath) {
-    let args = ["-c", "core.quotepath=false", "--no-pager", "diff", "--no-ext-diff", "--no-renames", "-p", "-U0", "--no-color", "--staged"];
-    if (relpath) args.push("--", toUnixSlash(relpath));
-    const result = await this.exec(args);
-    if (!result.stdout) {
-      return {};
+  async parseConflicts() {
+    if (!this.config.conflict.enabled) {
+      if (this.conflicts.length) {
+        this.conflicts = [];
+        await this.highlightConflicts([]);
+      }
+      return;
     }
-    let res = {};
-    let idx = 0;
-    let lines = result.stdout.split(/\r?\n/);
-    let curr;
-    let fsPath;
-    while (idx < lines.length) {
-      let line = lines[idx];
-      if (fsPath && line.startsWith("@@")) {
-        curr = void 0;
-        let ms = line.match(/^@@\s+-(\d+),?(\d*)\s+\+(\d+),?(\d*)\s+@@/);
-        if (ms) {
-          curr = {
-            remove: { lnum: Number(ms[1]), count: ms[2] ? Number(ms[2]) : 1 },
-            add: { lnum: Number(ms[3]), count: ms[4] ? Number(ms[4]) : 1 },
-            lines: []
-          };
-          res[fsPath] = res[fsPath] || [];
-          res[fsPath].push(curr);
+    if (!this.hasConflicts && !this.conflictCheckNeeded) return;
+    this.conflictCheckNeeded = false;
+    this.hasConflicts = await this.repo.hasConflicts(this.relpath);
+    if (this._disposed) return;
+    if (!this.hasConflicts) {
+      this.conflicts = [];
+      await this.highlightConflicts([]);
+      return;
+    }
+    const lines = this.doc.textDocument.lines;
+    let conflicts = [];
+    let conflict = null;
+    let state = 0 /* Initial */;
+    let mkStartConflict = (index, current) => ({
+      start: index + 1,
+      sep: 0,
+      end: 0,
+      current,
+      incoming: ""
+    });
+    lines.forEach((line, index) => {
+      switch (state) {
+        case 0 /* Initial */: {
+          const match = line.match(startPattern);
+          if (match) {
+            conflict = mkStartConflict(index, match[1]);
+            state = 1 /* MatchedStart */;
+          }
+          break;
+        }
+        case 2 /* MatchedCommon */:
+        case 1 /* MatchedStart */: {
+          let match = line.match(sepPattern);
+          if (match) {
+            conflict.sep = index + 1;
+            state = 3 /* MatchedSep */;
+          } else {
+            const startMatch = line.match(startPattern);
+            if (startMatch) {
+              conflict = mkStartConflict(index, startMatch[1]);
+              state = 1 /* MatchedStart */;
+            } else if (line.match(endPattern)) {
+              conflict = null;
+              state = 0 /* Initial */;
+            } else if (line.match(commonPattern)) {
+              conflict.common = index + 1;
+              state = 2 /* MatchedCommon */;
+            }
+          }
+          break;
         }
-      } else if (curr && /^[+\-]/.test(line)) {
-        curr.lines.push(line);
-      } else if (line.startsWith("diff --git")) {
-        const parsedPath = parseDiffPath(line);
-        if (relpath || parsedPath) {
-          fsPath = relpath ? toUnixSlash(relpath) : parsedPath;
-          curr = void 0;
-          idx += 4;
-          continue;
+        case 3 /* MatchedSep */: {
+          const match = line.match(endPattern);
+          if (match) {
+            conflict.end = index + 1;
+            conflict.incoming = match[1];
+            conflicts.push(conflict);
+            conflict = null;
+            state = 0 /* Initial */;
+          } else {
+            const startMatch = line.match(startPattern);
+            if (startMatch) {
+              conflict = mkStartConflict(index, startMatch[1]);
+              state = 1 /* MatchedStart */;
+            } else if (line.match(sepPattern)) {
+              conflict = null;
+              state = 0 /* Initial */;
+            }
+          }
+          break;
         }
       }
-      idx++;
-    }
-    return res;
-  }
-  async getHEAD() {
-    try {
-      const result = await this.exec(["symbolic-ref", "--short", "HEAD"]);
-      if (!result.stdout) {
-        throw new Error("Not in a branch");
-      }
-      return result.stdout.trim();
-    } catch (err) {
-      const result = await this.exec(["rev-parse", "HEAD"]);
-      if (!result.stdout) {
-        throw new Error("Error parsing HEAD");
-      }
-      return result.stdout.trim();
+    });
+    this.conflicts = conflicts;
+    await this.highlightConflicts(conflicts);
+    if (conflicts.length == 0) {
+      this.hasConflicts = false;
     }
   }
-  async hasChanged() {
-    let result = await this.exec(["diff", "--name-status"]);
-    return result.stdout.trim().length > 0;
-  }
-  async getStaged() {
-    let result = await this.exec(["diff", "--staged", "--name-status"]);
-    if (!result.stdout) return [0, 0];
-    let lines = result.stdout.trim().split(/\r?\n/);
-    let conflicted = 0;
-    let staged = 0;
-    lines.forEach((line) => {
-      if (!line.length) return;
-      if (line.startsWith("U")) {
-        conflicted++;
-      } else {
-        staged++;
+  async highlightConflicts(conflicts) {
+    if (this._disposed) return;
+    let buffer = this.doc.buffer;
+    let currentHlGroup = this.config.conflict.currentHlGroup;
+    let incomingHlGroup = this.config.conflict.incomingHlGroup;
+    let commonHlGroup = this.config.conflict.commonHlGroup;
+    let { nvim } = import_coc11.workspace;
+    nvim.pauseNotification();
+    buffer.clearNamespace(this.config.conflictSrcId, 0, -1);
+    const srcId = this.config.conflictSrcId;
+    conflicts.map((conflict) => {
+      let currEnd = conflict.common ? conflict.common - 1 : conflict.sep - 1;
+      let currRange = import_coc11.Range.create(import_coc11.Position.create(conflict.start - 1, 0), import_coc11.Position.create(currEnd, 0));
+      let incomingRange = import_coc11.Range.create(import_coc11.Position.create(conflict.sep, 0), import_coc11.Position.create(conflict.end, 0));
+      buffer.highlightRanges(srcId, currentHlGroup, [currRange]);
+      buffer.highlightRanges(srcId, incomingHlGroup, [incomingRange]);
+      if (conflict.common) {
+        let range = import_coc11.Range.create(import_coc11.Position.create(conflict.common - 1, 0), import_coc11.Position.create(conflict.sep - 1, 0));
+        buffer.highlightRanges(srcId, commonHlGroup, [range]);
       }
     });
-    return [conflicted, staged];
-  }
-  async hasUntracked() {
-    let cp2 = this.git.stream(this.root, ["ls-files", "--others", "--exclude-standard", "--directory"]);
-    return new Promise((resolve) => {
-      let settled = false;
-      const finish = (value) => {
-        if (settled) return;
-        settled = true;
-        resolve(value);
-      };
-      cp2.stdout.on("data", () => {
-        cp2.kill("SIGKILL");
-        finish(true);
-      });
-      cp2.on("exit", () => {
-        finish(false);
-      });
-      cp2.on("error", () => {
-        finish(false);
-      });
-    });
+    nvim.resumeNotification(false, true);
   }
-  async getStatus(character, decorator) {
-    try {
-      let head = await this.getHEAD();
-      if (!head) return "";
-      let [changed, staged, untracked] = await Promise.all([this.hasChanged(), this.getStaged(), this.hasUntracked()]);
-      const { changedDecorator, conflictedDecorator, stagedDecorator, untrackedDecorator } = decorator;
-      let more = "";
-      if (changed) more += changedDecorator;
-      if (staged[0]) more += conflictedDecorator;
-      if (staged[1]) more += stagedDecorator;
-      if (untracked) more += untrackedDecorator;
-      return `${character ? character + " " : ""}${head}${more}`;
-    } catch (e) {
-      this.channel.appendLine("Error on git status");
-      this.channel.append(e.message);
-      return "";
+  async showDoc(content, filetype = "diff") {
+    if (this.floatFactory) {
+      let docs = [{ content, filetype }];
+      await this.floatFactory.show(docs, this.config.floatConfig);
+    } else {
+      const lines = content.split("\n");
+      import_coc11.workspace.nvim.call("coc#ui#preview_info", [lines, filetype], true);
     }
   }
-  async getDiff(relFilepath, content, revision = "", encoding = "utf8") {
-    if (relFilepath.startsWith(`.git${import_path6.default.sep}`)) return;
-    let staged;
-    try {
-      let indexed = await this.isIndexed(relFilepath);
-      if (!indexed) return;
-      let res = await this.exec(["--no-pager", "show", `${revision}:${toUnixSlash(relFilepath)}`], { encoding });
-      staged = res.stdout.replace(/\r?\n$/, "").split(/\r?\n/).join("\n");
-    } catch (e) {
-      this.channel.append(e.stack);
-      return;
-    }
-    const stagedFile = import_path6.default.join(import_os.default.tmpdir(), `coc-${v4_default()}`);
-    const currentFile = import_path6.default.join(import_os.default.tmpdir(), `coc-${v4_default()}`);
-    let output;
-    try {
-      await import_util5.default.promisify(import_fs2.default.writeFile)(stagedFile, staged + "\n", "utf8");
-      await import_util5.default.promisify(import_fs2.default.writeFile)(currentFile, content, "utf8");
-      const result = await this.exec([
-        "--no-pager",
-        "diff",
-        "--no-index",
-        "--no-ext-diff",
-        "-p",
-        "-U0",
-        "--no-color",
-        stagedFile,
-        currentFile
-      ], { allowedExitCodes: [1] });
-      output = result.stdout;
-    } finally {
-      await Promise.all([
-        import_util5.default.promisify(import_fs2.default.unlink)(stagedFile).catch(() => void 0),
-        import_util5.default.promisify(import_fs2.default.unlink)(currentFile).catch(() => void 0)
-      ]);
-    }
-    if (!output) return [];
-    this.channel.appendLine(`> git diff ${relFilepath}`);
-    const lines = output.replace(/\r?\n$/, "").split(/\r?\n/);
-    return parseDiff(lines);
+  setBufferStatus(status) {
+    let exists = this.gitStatus;
+    if (exists == status) return;
+    this.gitStatus = status;
+    let { nvim } = import_coc11.workspace;
+    let buffer = nvim.createBuffer(this.doc.bufnr);
+    nvim.pauseNotification();
+    buffer.setVar("coc_git_status", status, true);
+    nvim.callTimer("coc#util#do_autocmd", ["CocGitStatusChange"], true);
+    nvim.resumeNotification(false, true);
   }
-  async getDiffAll(category) {
-    let diffGroups = /* @__PURE__ */ new Map();
-    let args = ["-c", "core.quotepath=false", "--no-pager", "diff", "--no-ext-diff", "--no-renames", "-p", "-U0", "--no-color"];
-    if (category === 0 /* All */) {
-      const head = await this.safeRun(["rev-parse", "--verify", "HEAD"]);
-      if (head) {
-        args.push("HEAD");
-      } else {
-        const emptyTree = await this.exec(["hash-object", "-t", "tree", "--stdin"], { input: "", log: false });
-        args.push(emptyTree.stdout.trim());
-      }
-    } else if (category === 1 /* Staged */) {
-      args.push("--cached");
+  getSignName(kind, layer) {
+    if (layer === "staged") {
+      switch (kind) {
+        case "add":
+          return "CocGitStagedAdded";
+        case "change":
+          return "CocGitStagedChanged";
+        case "delete":
+        case "topDelete":
+        case "changeDelete":
+          return "CocGitStagedRemoved";
+      }
+    }
+    if (kind === "mixed") return "CocGitMixed";
+    switch (kind) {
+      case "delete":
+        return "CocGitRemoved";
+      case "add":
+        return "CocGitAdded";
+      case "change":
+        return "CocGitChanged";
+      case "topDelete":
+        return "CocGitTopRemoved";
+      case "changeDelete":
+        return "CocGitChangeRemoved";
     }
-    let output = (await this.exec(args)).stdout;
-    if (!output) return diffGroups;
-    const lines = output.replace(/\r?\n$/, "").split(/\r?\n/);
-    let lineGroups = /* @__PURE__ */ new Map();
-    let file = null;
-    for (const line of lines) {
-      if (line.startsWith("diff --git")) {
-        file = parseDiffPath(line) || null;
-      }
-      if (file) {
-        if (!lineGroups.has(file)) {
-          lineGroups.set(file, []);
-        }
-        lineGroups.get(file).push(line);
-      }
+    return "";
+  }
+  get showBlame() {
+    return this.config.addGBlameToVirtualText || this.config.addGBlameToBufferVar;
+  }
+  dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    let { nvim } = import_coc11.workspace;
+    let { bufnr } = this.doc;
+    let buffer = nvim.createBuffer(bufnr);
+    nvim.pauseNotification();
+    buffer.setVar("coc_git_status", "", true);
+    buffer.clearNamespace(this.config.conflictSrcId, 0, -1);
+    nvim.call("sign_unplace", [signGroup, { buffer: bufnr }], true);
+    this.invalidateStagedCache();
+    this.refresh.clear();
+    if (this.config.addGBlameToBufferVar) {
+      buffer.setVar("coc_git_blame", "", true);
     }
-    for (const [file2, lines2] of lineGroups) {
-      let diffs = parseDiff(lines2);
-      if (diffs) {
-        diffGroups.set(file2, diffs);
-      }
+    if (this.config.addGBlameToVirtualText) {
+      buffer.clearNamespace(this.config.virtualTextSrcId);
     }
-    return diffGroups;
-  }
-  async isIgnored(relativePath) {
-    let res = await this.exec(["check-ignore", "-q", "--", relativePath], { allowedExitCodes: [1] });
-    return res.exitCode === 0;
+    nvim.resumeNotification(false, true);
+    this.foldEnabled = false;
   }
-  async hasConflicts(relativePath) {
-    let indexed = await this.isIndexed(relativePath);
-    if (!indexed) return false;
-    let res = await this.exec(["diff", "--staged", "--name-status", "--", relativePath]);
-    return res.stdout.trim().startsWith("U");
+};
+function plus(val, count, max) {
+  if (!count) return val;
+  val = val + count;
+  return Math.min(max, val);
+}
+function minus(val, count, min) {
+  if (!count) return val;
+  val = val - count;
+  return Math.max(min, val);
+}
+
+// src/model/git.ts
+var cp = __toESM(require("child_process"));
+var import_coc12 = require("coc.nvim");
+var import_iconv_lite = __toESM(require_lib());
+var import_path6 = __toESM(require("path"));
+var Git = class {
+  constructor(gitInfo, channel) {
+    this.gitInfo = gitInfo;
+    this.channel = channel;
   }
-  async isIndexed(relpath) {
-    let res = await this.exec(["ls-files", "--", relpath]);
-    return res.stdout && res.stdout.trim().length > 0;
+  get path() {
+    return this.gitInfo.path;
   }
-  async getUsername() {
-    if (typeof this.userName === "string") return this.userName;
-    try {
-      let res = await this.exec(["config", "user.name"]);
-      this.userName = res.stdout.trim();
-      return this.userName;
-    } catch (e) {
-      this.userName = "";
-      return "";
+  async getRepositoryRoot(repositoryPath) {
+    const result = await this.exec(repositoryPath, ["rev-parse", "--show-toplevel"]);
+    let repoRootPath = import_path6.default.normalize(result.stdout.trim());
+    if (process.platform === "win32" && repoRootPath.startsWith("\\") && !process.env.SHELL) {
+      repoRootPath = repoRootPath.replace(/^\\([^\\]*)\\/, "$1:\\");
     }
+    return repoRootPath;
   }
-  async isShallow() {
-    try {
-      let res = await this.exec(["rev-parse", "--is-shallow-repository"]);
-      return res.stdout.trim() === "true";
-    } catch (e) {
-      return false;
-    }
+  async exec(cwd, args, options = {}) {
+    options = Object.assign({ cwd }, options || {});
+    return await this._exec(args, options);
   }
-  async exec(args, options = {}) {
-    return await this.git.exec(this.root, args, options);
+  stream(cwd, args, options = {}) {
+    options = Object.assign({ cwd }, options || {});
+    return this.spawn(args, options);
   }
-  async safeRun(args, options = {}) {
-    try {
-      let res = await this.exec(args, options);
-      return res ? res.stdout.replace(/\s*$/, "") : "";
-    } catch (e) {
-      return "";
+  async _exec(args, options = {}) {
+    var _a, _b, _c, _d;
+    if ((_a = options.cancellationToken) == null ? void 0 : _a.isCancellationRequested) {
+      throw new Error("Cancelled");
     }
-  }
-};
-function readQuotedGitPath(input, start) {
-  if (input[start] !== '"') return void 0;
-  let value = "";
-  for (let index = start + 1; index < input.length; index++) {
-    const character = input[index];
-    if (character === '"') return { value, end: index + 1 };
-    if (character !== "\\") {
-      value += character;
-      continue;
+    const child = this.spawn(args, options);
+    if (options.input !== void 0) {
+      (_b = child.stdin) == null ? void 0 : _b.on("error", () => {
+      });
+      (_c = child.stdin) == null ? void 0 : _c.end(options.input, "utf8");
     }
-    const escaped = input[++index];
-    if (escaped == null) return void 0;
-    const escapes = {
-      a: "\x07",
-      b: "\b",
-      t: "	",
-      n: "\n",
-      v: "\v",
-      f: "\f",
-      r: "\r",
-      '"': '"',
-      "\\": "\\"
+    const bufferResult = await exec2(child, options.cancellationToken);
+    if (options.log !== false && bufferResult.stderr.length > 0) {
+      this.log(`${bufferResult.stderr}
+`);
+    }
+    let encoding = options.encoding || "utf8";
+    encoding = import_iconv_lite.default.encodingExists(encoding) ? encoding : "utf8";
+    const result = {
+      exitCode: bufferResult.exitCode,
+      stdout: import_iconv_lite.default.decode(bufferResult.stdout, encoding),
+      stderr: bufferResult.stderr
     };
-    if (escapes[escaped] != null) {
-      value += escapes[escaped];
-      continue;
+    if (bufferResult.exitCode && !((_d = options.allowedExitCodes) == null ? void 0 : _d.includes(bufferResult.exitCode))) {
+      this.channel.appendLine(`Error ${result.exitCode} on: 'git ${args.join(" ")}' in ${options.cwd}`);
+      this.channel.append(result.stderr);
+      this.channel.append(result.stdout);
+      return Promise.reject(new Error("Failed to execute git"));
     }
-    if (/[0-7]/.test(escaped)) {
-      let octal = escaped;
-      while (octal.length < 3 && /[0-7]/.test(input[index + 1] || "")) octal += input[++index];
-      value += String.fromCharCode(parseInt(octal, 8));
-      continue;
+    return result;
+  }
+  spawn(args, options = {}) {
+    const { input, encoding: _encoding, log: _log, cancellationToken: _cancellationToken, allowedExitCodes: _allowedExitCodes, ...spawnOptions } = options;
+    if (!spawnOptions.stdio && input === void 0) {
+      spawnOptions.stdio = ["ignore", null, null];
     }
-    value += escaped;
+    spawnOptions.env = Object.assign({}, process.env, spawnOptions.env || {}, {
+      LC_ALL: "en_US.UTF-8",
+      LANG: "en_US.UTF-8"
+    });
+    if (options.log !== false) {
+      this.log(`> git ${args.join(" ")}
+`);
+    }
+    return cp.spawn(this.gitInfo.path, args, spawnOptions);
   }
-  return void 0;
-}
-function parseDiffPath(line) {
-  const prefix = "diff --git ";
-  if (!line.startsWith(prefix)) return void 0;
-  const value = line.slice(prefix.length);
-  if (value.startsWith('"')) {
-    const first = readQuotedGitPath(value, 0);
-    if (!first) return void 0;
-    const secondStart = value.indexOf('"', first.end);
-    const second = secondStart === -1 ? void 0 : readQuotedGitPath(value, secondStart);
-    if (!second || !first.value.startsWith("a/") || !second.value.startsWith("b/")) return void 0;
-    const firstPath = first.value.slice(2);
-    return firstPath === second.value.slice(2) ? firstPath : void 0;
+  log(output) {
+    this.channel.append(output);
   }
-  if (!value.startsWith("a/")) return void 0;
-  const paths = value.slice(2);
-  let separator = paths.indexOf(" b/");
-  while (separator !== -1) {
-    const firstPath = paths.slice(0, separator);
-    if (firstPath === paths.slice(separator + 3)) return firstPath;
-    separator = paths.indexOf(" b/", separator + 1);
+};
+var git_default = Git;
+async function exec2(child, cancellationToken) {
+  if (!child.stdout || !child.stderr) {
+    throw new Error("Failed to get stdout or stderr from git process.");
   }
-  return void 0;
-}
-var repo_default = Repo;
-function parseDiff(diffLines) {
-  const allLines = diffLines.slice(4);
-  const diffs = [];
-  let diff = null;
-  for (const line of allLines) {
-    if (!line.startsWith("@@")) {
-      if (diff) {
-        diff.lines.push(line);
-      }
-      continue;
-    }
-    let diffKey = line.split("@@", 2)[1].trim();
-    const [pres, nows] = diffKey.split(/\s+/).map((str) => str.slice(1).split(","));
-    const removed = {
-      start: parseInt(pres[0], 10),
-      count: parseInt(`${pres[1] || 1}`, 10)
-    };
-    const added = {
-      start: parseInt(nows[0], 10),
-      count: parseInt(`${nows[1] || 1}`, 10)
-    };
-    if (added.count === 0) {
-      diff = {
-        lines: [],
-        start: added.start,
-        end: added.start,
-        head: line,
-        removed,
-        added,
-        changeType: "delete" /* Delete */
-      };
-      diffs.push(diff);
-    } else if (removed.count === 0) {
-      diff = {
-        lines: [],
-        start: added.start,
-        end: added.start + added.count - 1,
-        head: line,
-        removed,
-        added,
-        changeType: "add" /* Add */
-      };
-      diffs.push(diff);
-    } else {
-      diff = {
-        lines: [],
-        start: added.start,
-        end: added.start + Math.min(added.count, removed.count) - 1,
-        head: line,
-        removed,
-        added,
-        changeType: "changed" /* Change */
-      };
-      diffs.push(diff);
-    }
+  if (cancellationToken && cancellationToken.isCancellationRequested) {
+    throw new Error("Cancelled");
+  }
+  const disposables = [];
+  const once = (ee, name, fn) => {
+    ee.once(name, fn);
+    disposables.push(import_coc12.Disposable.create(() => ee.removeListener(name, fn)));
+  };
+  const on = (ee, name, fn) => {
+    ee.on(name, fn);
+    disposables.push(import_coc12.Disposable.create(() => ee.removeListener(name, fn)));
+  };
+  let result = Promise.all([
+    new Promise((c, e) => {
+      once(child, "error", cpErrorHandler(e));
+      once(child, "exit", (code) => c(code != null ? code : -1));
+    }),
+    new Promise((c) => {
+      const buffers = [];
+      on(child.stdout, "data", (b) => buffers.push(b));
+      once(child.stdout, "close", () => c(Buffer.concat(buffers)));
+    }),
+    new Promise((c) => {
+      const buffers = [];
+      on(child.stderr, "data", (b) => buffers.push(b));
+      once(child.stderr, "close", () => c(Buffer.concat(buffers).toString("utf8")));
+    })
+  ]);
+  if (cancellationToken) {
+    const cancellationPromise = new Promise((_, e) => {
+      const disposable = onceEvent(cancellationToken.onCancellationRequested)(() => {
+        try {
+          child.kill();
+        } catch (err) {
+        }
+        e(new Error("Cancelled"));
+      });
+      disposables.push(disposable);
+    });
+    result = Promise.race([result, cancellationPromise]);
+  }
+  try {
+    const [exitCode, stdout, stderr] = await result;
+    return { exitCode, stdout, stderr };
+  } finally {
+    (0, import_coc12.disposeAll)(disposables);
   }
-  return diffs;
 }
 
 // src/model/resolver.ts
@@ -8284,4 +8622,3 @@ async function activate(context) {
   activate,
   formatBlameText
 });
-//# sourceMappingURL=index.js.map