@gitkraken/core-gitlens 0.6.0 → 0.7.0

package/dist/git-cli/providers/diff.js

@@ -1,858 +1,651 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+import { first } from "../../utils/iterable.js";
+import { getScopedLogger } from "../../utils/logger.scoped.js";
+import { debug } from "../../utils/decorators/log.js";
+import { fromUri, toFsPath } from "../../utils/uri.js";
+import { normalizePath, splitPath } from "../../utils/path.js";
+import { rootSha, uncommittedStaged } from "../../git/models/revision.js";
+import { getRevisionRangeParts, isRevisionRange, isUncommitted, isUncommittedStaged } from "../../git/utils/revision.utils.js";
+import __decorate from "../../_virtual/@oxc-project+runtime/helpers/esm/decorate.js";
+import { GitError, GitErrors, gitConfigsDiff, gitConfigsLog } from "../exec/git.js";
+import { fnv1aHash } from "../../utils/hash.js";
+import { parseGitApplyFiles, parseGitDiff, parseGitDiffNumStatFiles, parseGitDiffShortStat, parseGitFileDiff } from "../../git/parsers/diffParser.js";
+import { getShaAndFileRangeLogParser, getShaAndFileSummaryLogParser } from "../parsers/logParser.js";
+import { encodeGitLensRevisionUriAuthority } from "../../git/utils/uriAuthority.js";
+import * as l10n from "@vscode/l10n";
+//#region ../git-cli/src/providers/diff.ts
+var DiffGitSubProvider = class {
+	context;
+	git;
+	cache;
+	provider;
+	constructor(context, git, cache, provider) {
+		this.context = context;
+		this.git = git;
+		this.cache = cache;
+		this.provider = provider;
+	}
+	async getChangedFilesCount(repoPath, to, from, options, _cancellation) {
+		const scope = getScopedLogger();
+		const args = [];
+		if (to != null) {
+			if (isRevisionRange(to) && from == null) args.push(to);
+			else prepareToFromDiffArgs(to, from, args);
+		}
+		try {
+			const result = await this.git.run({
+				cwd: repoPath,
+				configs: gitConfigsDiff
+			}, "diff", "--shortstat", "--no-ext-diff", ...args, "--", ...options?.uris?.map((p) => this.provider.getRelativePath(p, repoPath)) ?? []);
+			const stat = result.stdout ? parseGitDiffShortStat(result.stdout) : void 0;
+			if (options?.includeUntracked && !options.uris?.length && isWorkingTreeComparison(to, from)) {
+				const untracked = await this.provider.status?.getUntrackedFiles?.(repoPath) ?? [];
+				if (untracked.length) return {
+					files: (stat?.files ?? 0) + untracked.length,
+					additions: stat?.additions ?? 0,
+					deletions: stat?.deletions ?? 0
+				};
+			}
+			return stat;
+		} catch (ex) {
+			const msg = ex?.toString() ?? "";
+			if (GitErrors.noMergeBase.test(msg) || GitErrors.badRevision.test(msg)) return;
+			scope?.error(ex);
+			throw ex;
+		}
+	}
+	async getDiff(repoPath, to, from, options, _cancellation) {
+		const scope = getScopedLogger();
+		const args = [`-U${options?.context ?? 3}`];
+		if (to != null && isRevisionRange(to)) {
+			const parts = getRevisionRangeParts(to);
+			if (parts != null) {
+				to = parts.right ?? "";
+				from = parts.left;
+				options = {
+					...options,
+					notation: parts.notation
+				};
+			}
+		}
+		from = prepareToFromDiffArgs(to, from, args, options?.notation);
+		let paths;
+		if (options?.uris) {
+			paths = new Set(options.uris.map((p) => this.provider.getRelativePath(p, repoPath)));
+			args.push("--", ...paths);
+		}
+		let result;
+		try {
+			result = await this.git.run({
+				cwd: repoPath,
+				configs: gitConfigsDiff,
+				errors: "throw",
+				env: options?.index?.env
+			}, "diff", ...args, args.includes("--") ? void 0 : "--");
+		} catch (ex) {
+			scope?.error(ex);
+			return;
+		}
+		return {
+			contents: result.stdout,
+			from,
+			to,
+			notation: options?.notation
+		};
+	}
+	async getParsedDiff(repoPath, to, from, options, cancellation) {
+		const diff = await this.getDiff(repoPath, to, from, options, cancellation);
+		if (!diff?.contents) return void 0;
+		return parseGitDiff(diff.contents);
+	}
+	async getDiffFiles(repoPath, contents, _cancellation) {
+		const result = await this.git.run({
+			cwd: repoPath,
+			configs: gitConfigsLog,
+			stdin: contents
+		}, "apply", "--numstat", "--summary", "-z", "-");
+		if (!result.stdout) return void 0;
+		return { files: parseGitApplyFiles(result.stdout, repoPath) };
+	}
+	async getDiffStatus(repoPath, ref1OrRange, ref2, options) {
+		try {
+			const similarityThreshold = options?.similarityThreshold ?? this.context.config?.commits.similarityThreshold;
+			const configs = options?.renameLimit != null ? [
+				...gitConfigsDiff,
+				"-c",
+				`diff.renameLimit=${options.renameLimit}`
+			] : gitConfigsDiff;
+			const result = await this.git.run({
+				cwd: repoPath,
+				configs
+			}, "diff", "--numstat", "--summary", `-M${similarityThreshold == null ? "" : `${similarityThreshold}%`}`, "--no-ext-diff", "-z", options?.filters?.length ? `--diff-filter=${options.filters.join("")}` : void 0, ref1OrRange ? ref1OrRange : void 0, ref2 ? ref2 : void 0, "--", options?.path ? options.path : void 0);
+			const files = result.stdout ? parseGitDiffNumStatFiles(result.stdout, repoPath) ?? [] : [];
+			if (options?.includeUntracked && ref2 == null && typeof ref1OrRange === "string" && !isRevisionRange(ref1OrRange) && !isUncommittedStaged(ref1OrRange) && filtersAllowUntracked(options.filters) && !isNonExactPathspec(options.path)) {
+				const untracked = await this.provider.status?.getUntrackedFiles?.(repoPath) ?? [];
+				if (untracked.length) {
+					const seen = new Set(files.map((f) => f.path));
+					for (const file of untracked) {
+						if (seen.has(file.path)) continue;
+						if (options.path && options.path !== file.path) continue;
+						files.push(file);
+					}
+				}
+			}
+			return files.length ? files : void 0;
+		} catch (_ex) {
+			return;
+		}
+	}
+	async getDiffTool(repoPath) {
+		return await this.provider.config.getConfig?.(repoPath, "diff.guitool", { runGitLocally: true }) ?? this.provider.config.getConfig?.(repoPath, "diff.tool", { runGitLocally: true });
+	}
+	async getNextComparisonUris(repoPath, pathOrUri, rev, skip = 0, options, _cancellation) {
+		if (!rev) return void 0;
+		const scope = getScopedLogger();
+		let relativePath = this.provider.getRelativePath(pathOrUri, repoPath);
+		if (isUncommittedStaged(rev)) return {
+			current: createRevisionUri(this.provider, repoPath, relativePath, rev),
+			next: createRevisionUri(this.provider, repoPath, relativePath, void 0)
+		};
+		else if (isUncommitted(rev)) return;
+		try {
+			const parser = getShaAndFileSummaryLogParser();
+			const args = ["log", ...parser.arguments];
+			const ordering = options?.ordering ?? this.context.config?.commits.ordering;
+			if (ordering) args.push(`--${ordering}-order`);
+			args.push("--reverse");
+			if (rev !== "0000000000000000000000000000000000000000-") args.push("--ancestry-path", `${rev}..HEAD`);
+			args.push("--follow", "--", relativePath);
+			const result = await this.git.run({
+				cwd: repoPath,
+				configs: gitConfigsLog,
+				priority: "background"
+			}, ...args);
+			let currentSha;
+			let currentPath;
+			if (skip === 0) {
+				currentSha = rev;
+				currentPath = relativePath;
+			} else skip--;
+			let nextSha;
+			let nextPath;
+			let file;
+			for (const commit of parser.parse(result.stdout)) {
+				const path = relativePath;
+				file = commit.files.find((f) => f.path === path || f.originalPath === path);
+				if (file?.path && file.path !== relativePath) relativePath = file.path;
+				if (skip > 0) {
+					skip--;
+					continue;
+				}
+				if (currentSha == null) {
+					currentSha = commit.sha;
+					currentPath = file?.path ?? relativePath;
+				} else if (nextSha == null) {
+					nextSha = commit.sha;
+					nextPath = file?.path ?? relativePath;
+					break;
+				}
+			}
+			if (currentSha == null || currentPath == null) {
+				const status = await this.provider.status?.getStatusForFile?.(repoPath, relativePath);
+				if (status != null) {
+					if (status.indexStatus != null) {
+						currentSha = uncommittedStaged;
+						currentPath = status.originalPath ?? status.path;
+						nextSha = "";
+						nextPath = status.path;
+					} else return;
+				} else return;
+			}
+			if (nextSha == null || nextPath == null) {
+				const status = await this.provider.status?.getStatusForFile?.(repoPath, relativePath);
+				if (status != null) {
+					if (status.indexStatus != null) {
+						nextSha = uncommittedStaged;
+						nextPath = status.originalPath ?? status.path;
+					} else {
+						nextSha = "";
+						nextPath = status.path;
+					}
+				} else {
+					nextSha = "";
+					nextPath = relativePath;
+				}
+			}
+			return {
+				current: createRevisionUri(this.provider, repoPath, currentPath, currentSha || void 0),
+				next: createRevisionUri(this.provider, repoPath, nextPath ?? currentPath, (nextSha ?? "0000000000000000000000000000000000000000-") || void 0)
+			};
+		} catch (ex) {
+			scope?.error(ex);
+			throw ex;
+		}
+	}
+	async getPreviousComparisonUris(repoPath, pathOrUri, rev, skip = 0, unsaved, options, _cancellation) {
+		if (rev === "0000000000000000000000000000000000000000-") return void 0;
+		const scope = getScopedLogger();
+		if (rev === "0000000000000000000000000000000000000000") rev = void 0;
+		let relativePath = this.provider.getRelativePath(pathOrUri, repoPath);
+		let skipPrev = 0;
+		let revs = [];
+		if (!rev) {
+			revs = [["", relativePath]];
+			const status = await this.provider.status?.getStatusForFile?.(repoPath, pathOrUri);
+			if (status != null) {
+				if (status.indexStatus != null) revs.push([uncommittedStaged, status.originalPath ?? status.path]);
+				revs.push(["HEAD", status.originalPath ?? status.path]);
+				if (status.workingTreeStatus == null && !unsaved) {
+					if (skip === 0 || status.indexStatus == null) skipPrev++;
+				}
+			} else {
+				revs.push(["HEAD", relativePath]);
+				if (!unsaved) skipPrev++;
+			}
+		} else if (isUncommittedStaged(rev)) {
+			const status = await this.provider.status?.getStatusForFile?.(repoPath, pathOrUri);
+			if (status != null) revs = [[uncommittedStaged, status.originalPath ?? status.path], ["HEAD", status.originalPath ?? status.path]];
+			else {
+				revs = [["HEAD", relativePath]];
+				if (skip > 0) skip--;
+			}
+		}
+		let currentSha;
+		let currentPath;
+		if (revs.length) {
+			skip++;
+			while (revs.length && skip > 0) {
+				skip--;
+				[rev, relativePath] = revs.shift();
+			}
+			if (rev !== "HEAD") {
+				currentSha = rev;
+				currentPath = relativePath;
+				skipPrev++;
+				while (revs.length && skipPrev > 0) {
+					skipPrev--;
+					[rev, relativePath] = revs.shift();
+				}
+				if (skipPrev > 0) skip += skipPrev;
+				if (rev !== "HEAD" && skip === 0) return {
+					current: createRevisionUri(this.provider, repoPath, currentPath, currentSha),
+					previous: createRevisionUri(this.provider, repoPath, relativePath, rev)
+				};
+			}
+		}
+		try {
+			const parser = getShaAndFileSummaryLogParser();
+			const args = [
+				"log",
+				...parser.arguments,
+				`-n${skip + 2}`
+			];
+			const ordering = options?.ordering ?? this.context.config?.commits.ordering;
+			if (ordering) args.push(`--${ordering}-order`);
+			args.push("--follow", rev, "--", relativePath);
+			const result = await this.git.run({
+				cwd: repoPath,
+				configs: gitConfigsLog,
+				caching: {
+					cache: this.cache.gitResults,
+					options: { accessTTL: 3e5 }
+				}
+			}, ...args);
+			let previousSha;
+			let previousPath;
+			let file;
+			for (const commit of parser.parse(result.stdout)) {
+				const path = relativePath;
+				file = commit.files.find((f) => f.path === path || f.originalPath === path);
+				if (file?.originalPath && file.originalPath !== relativePath) relativePath = file.originalPath;
+				if (skip > 0) {
+					skip--;
+					continue;
+				}
+				if (currentSha == null) {
+					currentSha = commit.sha;
+					currentPath = file?.path ?? relativePath;
+				} else if (previousSha == null) {
+					if (commit.sha === rev) continue;
+					previousSha = commit.sha;
+					previousPath = file?.path ?? relativePath;
+					break;
+				}
+			}
+			if (currentSha == null || currentPath == null) return void 0;
+			return {
+				current: createRevisionUri(this.provider, repoPath, currentPath, currentSha || void 0),
+				previous: createRevisionUri(this.provider, repoPath, previousPath ?? currentPath, previousSha ?? "0000000000000000000000000000000000000000-")
+			};
+		} catch (ex) {
+			scope?.error(ex);
+			throw ex;
+		}
+	}
+	async getPreviousComparisonUrisForRange(repoPath, pathOrUri, rev, range, options, _cancellation) {
+		if (rev === "0000000000000000000000000000000000000000-") return void 0;
+		const scope = getScopedLogger();
+		if (rev === "0000000000000000000000000000000000000000") rev = void 0;
+		let currentSha;
+		let currentPath;
+		let relativePath = this.provider.getRelativePath(pathOrUri, repoPath);
+		const skipFirstRev = options?.skipFirstRev ?? true;
+		if (!rev) {
+			const status = await this.provider.status?.getStatusForFile?.(repoPath, pathOrUri);
+			if (status != null) {
+				if (status.indexStatus != null) {
+					if (status.workingTreeStatus != null && !skipFirstRev) return {
+						current: createRevisionUri(this.provider, repoPath, relativePath, void 0),
+						previous: createRevisionUri(this.provider, repoPath, relativePath, uncommittedStaged),
+						range
+					};
+					currentSha = uncommittedStaged;
+					currentPath = status.originalPath ?? status.path;
+					if (status.originalPath != null) relativePath = status.originalPath;
+					rev = uncommittedStaged;
+				} else if (status.workingTreeStatus != null && !skipFirstRev) {
+					currentSha = "";
+					currentPath = relativePath;
+					rev = "";
+				}
+			}
+		} else if (!skipFirstRev) {
+			currentSha = rev;
+			currentPath = relativePath;
+		}
+		try {
+			const parser = getShaAndFileRangeLogParser();
+			const args = [
+				"log",
+				...parser.arguments,
+				"-n2"
+			];
+			const ordering = options?.ordering ?? this.context.config?.commits.ordering;
+			if (ordering) args.push(`--${ordering}-order`);
+			if (rev && !isUncommittedStaged(rev)) args.push(rev);
+			args.push(`-L${range.startLine},${range.endLine}:${relativePath}`);
+			let result;
+			try {
+				result = await this.git.run({
+					cwd: repoPath,
+					configs: gitConfigsLog
+				}, ...args);
+			} catch (ex) {
+				if (rev && !isUncommittedStaged(rev)) throw ex;
+				const match = GitErrors.invalidLineCount.exec(ex?.toString() ?? "");
+				if (match == null) throw ex;
+				const line = parseInt(match[1], 10);
+				if (isNaN(line)) throw ex;
+				const index = args.findIndex((a) => a.startsWith("-L"));
+				if (index === -1) throw ex;
+				range = {
+					startLine: Math.min(range.startLine, line),
+					startCharacter: range.startCharacter,
+					endLine: Math.min(range.endLine, line),
+					endCharacter: range.endCharacter,
+					active: range.active
+				};
+				args.splice(index, 1, `-L${range.startLine},${range.endLine}:${relativePath}`);
+				result = await this.git.run({
+					cwd: repoPath,
+					configs: gitConfigsLog
+				}, ...args);
+			}
+			let currentRange;
+			let previousSha;
+			let previousPath;
+			let file;
+			for (const commit of parser.parse(result.stdout)) {
+				const path = relativePath;
+				file = commit.files.find((f) => f.path === path || f.originalPath === path);
+				if (file == null && commit.files.length === 1) {
+					file = commit.files[0];
+					relativePath = file.path;
+				}
+				if (file?.originalPath && file.originalPath !== relativePath) relativePath = file.originalPath;
+				if (currentSha == null) {
+					currentSha = commit.sha;
+					currentPath = file?.path ?? relativePath;
+					currentRange = file?.range != null ? {
+						...file.range,
+						startCharacter: 1,
+						endCharacter: 1
+					} : void 0;
+				} else if (previousSha == null) {
+					if (commit.sha === rev) continue;
+					previousSha = commit.sha;
+					previousPath = file?.path ?? relativePath;
+					break;
+				}
+			}
+			if (currentSha == null || currentPath == null) return void 0;
+			if (previousSha == null && currentSha) previousSha = await this.provider.refs.validateReference(repoPath, `${currentSha}^`) ?? "0000000000000000000000000000000000000000-";
+			return {
+				current: createRevisionUri(this.provider, repoPath, currentPath, currentSha || void 0),
+				previous: createRevisionUri(this.provider, repoPath, previousPath ?? currentPath, previousSha ?? "0000000000000000000000000000000000000000-"),
+				range: currentRange ?? range
+			};
+		} catch (ex) {
+			scope?.error(ex);
+			throw ex;
+		}
+	}
+	/** Returns raw diff output for a file between two revisions. */
+	async diff(repoPath, fileName, ref1, ref2, options) {
+		const params = [
+			"diff",
+			"--no-ext-diff",
+			"--minimal"
+		];
+		if (options?.linesOfContext != null) params.push(`-U${options.linesOfContext}`);
+		if (options?.renames) params.push(`-M${options.similarityThreshold == null ? "" : `${options.similarityThreshold}%`}`);
+		if (options?.filters != null && options.filters.length !== 0) params.push(`--diff-filter=${options.filters.join("")}`);
+		if (ref1) {
+			if (ref1.endsWith("^3^")) ref1 = rootSha;
+			params.push(isUncommittedStaged(ref1) ? "--staged" : ref1);
+		}
+		if (ref2) params.push(isUncommittedStaged(ref2) ? "--staged" : ref2);
+		try {
+			return await this.git.run({
+				cwd: repoPath,
+				configs: gitConfigsDiff,
+				encoding: options?.encoding
+			}, ...params, "--", fileName);
+		} catch (ex) {
+			const match = GitErrors.badRevision.exec(ex.message);
+			if (match !== null) {
+				const [, ref] = match;
+				if (ref === ref1 && ref?.endsWith("^")) return this.diff(repoPath, fileName, rootSha, ref2, options);
+			}
+			throw ex;
+		}
+	}
+	/** Returns raw diff output comparing a file's revision with given contents via stdin. */
+	async diffContents(repoPath, fileName, ref, contents, options) {
+		const params = [
+			"diff",
+			`-M${options?.similarityThreshold == null ? "" : `${options.similarityThreshold}%`}`,
+			"--no-ext-diff",
+			"-U0",
+			"--minimal"
+		];
+		if (options?.filters != null && options.filters.length !== 0) params.push(`--diff-filter=${options.filters.join("")}`);
+		params.push("--no-index");
+		try {
+			return (await this.git.run({
+				cwd: repoPath,
+				configs: gitConfigsDiff,
+				encoding: options?.encoding,
+				stdin: contents
+			}, ...params, "--", fileName, "-")).stdout;
+		} catch (ex) {
+			if (ex instanceof GitError && ex.stdout) return ex.stdout;
+			const match = GitErrors.badRevision.exec(ex.message);
+			if (match !== null) {
+				const [, matchedRef] = match;
+				if (matchedRef === ref && matchedRef?.endsWith("^")) return this.diffContents(repoPath, fileName, rootSha, contents, options);
+			}
+			throw ex;
+		}
+	}
+	/** Returns parsed diff hunks for a file between two revisions. */
+	getDiffForFile(repoPath, fileName, ref1, ref2, options) {
+		const cacheKey = `${normalizePath(fileName)}:${ref1 ?? ""}:${ref2 ?? ""}`;
+		return this.cache.diff.getOrCreate(repoPath, cacheKey, () => this.getDiffForFileCore(repoPath, fileName, ref1, ref2, options), { errorTTL: 6e4 });
+	}
+	async getDiffForFileCore(repoPath, fileName, ref1, ref2, options) {
+		const result = await this.diff(repoPath, fileName, ref1, ref2, {
+			encoding: options?.encoding,
+			filters: [
+				"M",
+				"R",
+				"C"
+			],
+			linesOfContext: 0,
+			renames: true,
+			similarityThreshold: this.context.config?.commits.similarityThreshold
+		});
+		return parseGitFileDiff(result.stdout);
+	}
+	/** Returns parsed diff hunks comparing a file's revision with given contents via stdin. */
+	getDiffForFileContents(repoPath, fileName, ref, contents, options) {
+		const cacheKey = `${normalizePath(fileName)}:${ref}:~${fnv1aHash(contents)}`;
+		return this.cache.diff.getOrCreate(repoPath, cacheKey, () => this.getDiffForFileContentsCore(repoPath, fileName, ref, contents, options), { errorTTL: 6e4 });
+	}
+	async getDiffForFileContentsCore(repoPath, fileName, ref, contents, options) {
+		const data = await this.diffContents(repoPath, fileName, ref, contents, {
+			encoding: options?.encoding,
+			filters: [
+				"M",
+				"R",
+				"C"
+			],
+			similarityThreshold: this.context.config?.commits.similarityThreshold
+		});
+		return parseGitFileDiff(data);
+	}
+	/** Finds the most recent commit where the given path was copied, renamed, or deleted. */
+	async findPathStatusChanged(repoPath, pathspec, rev, options) {
+		return findPathStatusChanged(this.git, repoPath, pathspec, rev, options);
+	}
+	async openDiffTool(repoPath, pathOrUri, options) {
+		const scope = getScopedLogger();
+		const [relativePath, root] = splitPath(toFsPath(pathOrUri), repoPath);
+		try {
+			let tool = options?.tool;
+			if (!tool) {
+				const scope = getScopedLogger();
+				tool = await this.getDiffTool(root);
+				if (tool == null) throw new Error("No diff tool found");
+				scope?.debug(`Using tool=${tool}`);
+			}
+			await this.git.run({ cwd: root }, "difftool", "--no-prompt", `--tool=${tool}`, options?.staged ? "--staged" : void 0, options?.ref1 ? options.ref1 : void 0, options?.ref2 ? options.ref2 : void 0, "--", relativePath);
+		} catch (ex) {
+			const msg = ex?.toString() ?? "";
+			if (ex instanceof Error && ex.message === "No diff tool found" || /Unknown .+? tool/.test(msg)) throw new Error(l10n.t("Unable to open changes because the specified diff tool cannot be found or no Git diff tool is configured"), { cause: ex });
+			scope?.error(ex);
+			throw ex;
+		}
+	}
+	async openDirectoryCompare(repoPath, ref1, ref2, tool) {
+		const scope = getScopedLogger();
+		try {
+			if (!tool) {
+				const scope = getScopedLogger();
+				tool = await this.getDiffTool(repoPath);
+				if (tool == null) throw new Error("No diff tool found");
+				scope?.debug(`Using tool=${tool}`);
+			}
+			await this.git.run({ cwd: repoPath }, "difftool", "--dir-diff", `--tool=${tool}`, ref1, ref2);
+		} catch (ex) {
+			const msg = ex?.toString() ?? "";
+			if (ex instanceof Error && ex.message === "No diff tool found" || /Unknown .+? tool/.test(msg)) throw new Error(l10n.t("Unable to open directory compare because the specified diff tool cannot be found or no Git diff tool is configured"), { cause: ex });
+			scope?.error(ex);
+			throw ex;
+		}
+	}
 };
-import { deletedOrMissing, rootSha, uncommitted, uncommittedStaged } from '../../git/models/revision.js';
-import { parseGitApplyFiles, parseGitDiff, parseGitDiffNumStatFiles, parseGitDiffShortStat, parseGitFileDiff, } from '../../git/parsers/diffParser.js';
-import { getRevisionRangeParts, isRevisionRange, isUncommitted, isUncommittedStaged, } from '../../git/utils/revision.utils.js';
-import { encodeGitLensRevisionUriAuthority } from '../../git/utils/uriAuthority.js';
-import { debug } from '../../utils/decorators/log.js';
-import { fnv1aHash } from '../../utils/hash.js';
-import { first } from '../../utils/iterable.js';
-import { getScopedLogger } from '../../utils/logger.scoped.js';
-import { normalizePath, splitPath } from '../../utils/path.js';
-import { fromUri, toFsPath } from '../../utils/uri.js';
-import { gitConfigsDiff, gitConfigsLog, GitError, GitErrors } from '../exec/git.js';
-import { getShaAndFileRangeLogParser, getShaAndFileSummaryLogParser } from '../parsers/logParser.js';
-export class DiffGitSubProvider {
-    context;
-    git;
-    cache;
-    provider;
-    constructor(context, git, cache, provider) {
-        this.context = context;
-        this.git = git;
-        this.cache = cache;
-        this.provider = provider;
-    }
-    async getChangedFilesCount(repoPath, to, from, options, _cancellation) {
-        const scope = getScopedLogger();
-        const args = [];
-        if (to != null) {
-            // Handle revision ranges specially if there is no `from`, otherwise `prepareToFromDiffArgs` will duplicate the range
-            if (isRevisionRange(to) && from == null) {
-                args.push(to);
-            }
-            else {
-                prepareToFromDiffArgs(to, from, args);
-            }
-        }
-        try {
-            const result = await this.git.run({ cwd: repoPath, configs: gitConfigsDiff }, 'diff', '--shortstat', '--no-ext-diff', ...args, '--', ...(options?.uris?.map(p => this.provider.getRelativePath(p, repoPath)) ?? []));
-            const stat = result.stdout ? parseGitDiffShortStat(result.stdout) : undefined;
-            // Merge in untracked files when the comparison involves the working tree.
-            // Skip when a pathspec filter is active — mixing a path-filtered diff count with an
-            // unfiltered untracked count would silently produce wrong totals.
-            if (options?.includeUntracked && !options.uris?.length && isWorkingTreeComparison(to, from)) {
-                const untracked = (await this.provider.status?.getUntrackedFiles?.(repoPath)) ?? [];
-                if (untracked.length) {
-                    return {
-                        files: (stat?.files ?? 0) + untracked.length,
-                        additions: stat?.additions ?? 0,
-                        deletions: stat?.deletions ?? 0,
-                    };
-                }
-            }
-            return stat;
-        }
-        catch (ex) {
-            const msg = ex?.toString() ?? '';
-            if (GitErrors.noMergeBase.test(msg) || GitErrors.badRevision.test(msg)) {
-                return undefined;
-            }
-            scope?.error(ex);
-            throw ex;
-        }
-    }
-    async getDiff(repoPath, to, from, options, _cancellation) {
-        const scope = getScopedLogger();
-        const args = [`-U${options?.context ?? 3}`];
-        if (to != null && isRevisionRange(to)) {
-            const parts = getRevisionRangeParts(to);
-            if (parts != null) {
-                to = parts.right ?? '';
-                from = parts.left;
-                options = { ...options, notation: parts.notation };
-            }
-        }
-        from = prepareToFromDiffArgs(to, from, args, options?.notation);
-        let paths;
-        if (options?.uris) {
-            paths = new Set(options.uris.map(p => this.provider.getRelativePath(p, repoPath)));
-            args.push('--', ...paths);
-        }
-        let result;
-        try {
-            result = await this.git.run({ cwd: repoPath, configs: gitConfigsDiff, errors: 'throw', env: options?.index?.env }, 'diff', ...args, args.includes('--') ? undefined : '--');
-        }
-        catch (ex) {
-            scope?.error(ex);
-            return undefined;
-        }
-        const diff = { contents: result.stdout, from: from, to: to, notation: options?.notation };
-        return diff;
-    }
-    async getParsedDiff(repoPath, to, from, options, cancellation) {
-        const diff = await this.getDiff(repoPath, to, from, options, cancellation);
-        if (!diff?.contents)
-            return undefined;
-        return parseGitDiff(diff.contents);
-    }
-    async getDiffFiles(repoPath, contents, _cancellation) {
-        const result = await this.git.run({ cwd: repoPath, configs: gitConfigsLog, stdin: contents }, 'apply', '--numstat', '--summary', '-z', '-');
-        if (!result.stdout)
-            return undefined;
-        const files = parseGitApplyFiles(result.stdout, repoPath);
-        return {
-            files: files,
-        };
-    }
-    async getDiffStatus(repoPath, ref1OrRange, ref2, options) {
-        try {
-            const similarityThreshold = options?.similarityThreshold ?? this.context.config?.commits.similarityThreshold;
-            const configs = options?.renameLimit != null
-                ? [...gitConfigsDiff, '-c', `diff.renameLimit=${options.renameLimit}`]
-                : gitConfigsDiff;
-            const result = await this.git.run({ cwd: repoPath, configs: configs }, 'diff', '--numstat', '--summary', `-M${similarityThreshold == null ? '' : `${similarityThreshold}%`}`, '--no-ext-diff', '-z', options?.filters?.length ? `--diff-filter=${options.filters.join('')}` : undefined, ref1OrRange ? ref1OrRange : undefined, ref2 ? ref2 : undefined, '--', options?.path ? options.path : undefined);
-            const files = result.stdout ? (parseGitDiffNumStatFiles(result.stdout, repoPath) ?? []) : [];
-            // Merge in untracked files when the comparison involves the working tree.
-            // Skip when `filters` excludes additions (untracked entries are semantically 'A'/added),
-            // or when `path` is a non-exact pathspec we can't reliably match against the untracked list.
-            if (options?.includeUntracked &&
-                ref2 == null &&
-                typeof ref1OrRange === 'string' &&
-                !isRevisionRange(ref1OrRange) &&
-                !isUncommittedStaged(ref1OrRange) &&
-                filtersAllowUntracked(options.filters) &&
-                !isNonExactPathspec(options.path)) {
-                const untracked = (await this.provider.status?.getUntrackedFiles?.(repoPath)) ?? [];
-                if (untracked.length) {
-                    const seen = new Set(files.map(f => f.path));
-                    for (const file of untracked) {
-                        if (seen.has(file.path))
-                            continue;
-                        if (options.path && options.path !== file.path)
-                            continue;
-                        files.push(file);
-                    }
-                }
-            }
-            return files.length ? files : undefined;
-        }
-        catch (_ex) {
-            return undefined;
-        }
-    }
-    async getDiffTool(repoPath) {
-        return ((await this.provider.config.getConfig?.(repoPath, 'diff.guitool', { runGitLocally: true })) ??
-            this.provider.config.getConfig?.(repoPath, 'diff.tool', { runGitLocally: true }));
-    }
-    async getNextComparisonUris(repoPath, pathOrUri, rev, skip = 0, options, _cancellation) {
-        // If we have no revision there is no next commit
-        if (!rev)
-            return undefined;
-        const scope = getScopedLogger();
-        let relativePath = this.provider.getRelativePath(pathOrUri, repoPath);
-        if (isUncommittedStaged(rev)) {
-            return {
-                current: createRevisionUri(this.provider, repoPath, relativePath, rev),
-                next: createRevisionUri(this.provider, repoPath, relativePath, undefined),
-            };
-        }
-        else if (isUncommitted(rev)) {
-            return undefined;
-        }
-        try {
-            const parser = getShaAndFileSummaryLogParser();
-            const args = ['log', ...parser.arguments];
-            const ordering = options?.ordering ?? this.context.config?.commits.ordering;
-            if (ordering) {
-                args.push(`--${ordering}-order`);
-            }
-            args.push(
-            // Use reverse to get the next commits (oldest to newest instead of newest to oldest)
-            '--reverse');
-            if (rev !== deletedOrMissing) {
-                args.push(
-                // Ancestry path to ensure we only follow the path from the given revision to HEAD
-                '--ancestry-path', 
-                // Range from the given revision to HEAD
-                `${rev}..HEAD`);
-            }
-            // Follow file history and specify the file path
-            args.push('--follow', '--', relativePath);
-            // Unbounded --follow walk over file history can be slow on long histories — queue as background
-            // so it doesn't compete with interactive work.
-            const result = await this.git.run({ cwd: repoPath, configs: gitConfigsLog, priority: 'background' }, ...args);
-            let currentSha;
-            let currentPath;
-            if (skip === 0) {
-                currentSha = rev;
-                currentPath = relativePath;
-            }
-            else {
-                skip--;
-            }
-            let nextSha;
-            let nextPath;
-            let file;
-            for (const commit of parser.parse(result.stdout)) {
-                const path = relativePath;
-                file = commit.files.find(f => f.path === path || f.originalPath === path);
-                // Keep track of the file changing paths
-                if (file?.path && file.path !== relativePath) {
-                    relativePath = file.path;
-                }
-                if (skip > 0) {
-                    skip--;
-                    continue;
-                }
-                if (currentSha == null) {
-                    currentSha = commit.sha;
-                    currentPath = file?.path ?? relativePath;
-                }
-                else if (nextSha == null) {
-                    // if (commit.sha === rev) continue;
-                    nextSha = commit.sha;
-                    nextPath = file?.path ?? relativePath;
-                    break;
-                }
-            }
-            if (currentSha == null || currentPath == null) {
-                const status = await this.provider.status?.getStatusForFile?.(repoPath, relativePath);
-                if (status != null) {
-                    if (status.indexStatus != null) {
-                        currentSha = uncommittedStaged;
-                        currentPath = status.originalPath ?? status.path;
-                        nextSha = '';
-                        nextPath = status.path;
-                    }
-                    else {
-                        return undefined;
-                    }
-                }
-                else {
-                    return undefined;
-                }
-            }
-            if (nextSha == null || nextPath == null) {
-                const status = await this.provider.status?.getStatusForFile?.(repoPath, relativePath);
-                if (status != null) {
-                    if (status.indexStatus != null) {
-                        nextSha = uncommittedStaged;
-                        nextPath = status.originalPath ?? status.path;
-                    }
-                    else {
-                        nextSha = '';
-                        nextPath = status.path;
-                    }
-                }
-                else {
-                    nextSha = '';
-                    nextPath = relativePath;
-                }
-            }
-            return {
-                current: createRevisionUri(this.provider, repoPath, currentPath, currentSha || undefined),
-                next: createRevisionUri(this.provider, repoPath, nextPath ?? currentPath, (nextSha ?? deletedOrMissing) || undefined),
-            };
-        }
-        catch (ex) {
-            scope?.error(ex);
-            throw ex;
-        }
-    }
-    async getPreviousComparisonUris(repoPath, pathOrUri, rev, skip = 0, unsaved, options, _cancellation) {
-        if (rev === deletedOrMissing)
-            return undefined;
-        const scope = getScopedLogger();
-        if (rev === uncommitted) {
-            rev = undefined;
-        }
-        /* Rules:
-         * Starting from working tree (rev is empty or undefined):
-         *   1. Check file status:
-         *      1.1. If file has both staged and working (or unsaved) changes:
-         *          - If skip=0: diff working with staged
-         *          - If skip>0: skip through revs starting at HEAD
-         *
-         *      1.2. If file has only staged changes:
-         *          - If skip=0: diff working with HEAD
-         *          - If skip>0: skip through revs starting at HEAD
-         *
-         *      1.3. If file has only working changes:
-         *          - If skip=0: diff working with HEAD
-         *          - If skip>0: skip through revs starting at HEAD
-         *
-         *      1.4. If file has no changes (or no status found):
-         *          - If skip=0: diff working with HEAD~1
-         *          - If skip>0: skip through revs starting at HEAD~1
-         *
-         * Starting from staged (rev is uncommittedStaged):
-         *   1. Check file status:
-         *      1.1. If status exists:
-         *          - If skip=0: diff staged with HEAD
-         *          - If skip>0: skip through revs starting at HEAD
-         *
-         *      1.2. If status doesn't exist:
-         *          - If skip=0: diff HEAD with HEAD~1
-         *          - If skip>0: skip through revs starting at HEAD
-         *
-         * Starting from a commit (rev is a SHA):
-         *   - If skip=0: diff SHA with SHA^
-         *   - If skip>0: skip through revs starting at SHA
-         */
-        let relativePath = this.provider.getRelativePath(pathOrUri, repoPath);
-        let skipPrev = 0;
-        let revs = [];
-        if (!rev) {
-            revs = [['', relativePath]];
-            const status = await this.provider.status?.getStatusForFile?.(repoPath, pathOrUri);
-            if (status != null) {
-                if (status.indexStatus != null) {
-                    revs.push([uncommittedStaged, status.originalPath ?? status.path]);
-                }
-                revs.push(['HEAD', status.originalPath ?? status.path]);
-                if (status.workingTreeStatus == null && !unsaved) {
-                    if (skip === 0 || status.indexStatus == null) {
-                        // Skip over the HEAD commit to get a diff, because working and HEAD are the same
-                        skipPrev++;
-                    }
-                }
-            }
-            else {
-                revs.push(['HEAD', relativePath]);
-                if (!unsaved) {
-                    // Skip over the HEAD commit to get a diff, because working and HEAD are the same
-                    skipPrev++;
-                }
-            }
-        }
-        else if (isUncommittedStaged(rev)) {
-            const status = await this.provider.status?.getStatusForFile?.(repoPath, pathOrUri);
-            if (status != null) {
-                revs = [
-                    [uncommittedStaged, status.originalPath ?? status.path],
-                    ['HEAD', status.originalPath ?? status.path],
-                ];
-            }
-            else {
-                // Even though we supposedly started at staged, there is no staged version
-                revs = [['HEAD', relativePath]];
-                if (skip > 0) {
-                    skip--;
-                }
-            }
-        }
-        let currentSha;
-        let currentPath;
-        if (revs.length) {
-            skip++;
-            while (revs.length && skip > 0) {
-                skip--;
-                [rev, relativePath] = revs.shift();
-            }
-            if (rev !== 'HEAD') {
-                currentSha = rev;
-                currentPath = relativePath;
-                skipPrev++;
-                while (revs.length && skipPrev > 0) {
-                    skipPrev--;
-                    [rev, relativePath] = revs.shift();
-                }
-                if (skipPrev > 0) {
-                    skip += skipPrev;
-                }
-                if (rev !== 'HEAD' && skip === 0) {
-                    return {
-                        current: createRevisionUri(this.provider, repoPath, currentPath, currentSha),
-                        previous: createRevisionUri(this.provider, repoPath, relativePath, rev),
-                    };
-                }
-            }
-        }
-        try {
-            const parser = getShaAndFileSummaryLogParser();
-            const args = ['log', ...parser.arguments, `-n${skip + 2}`]; // Don't use --skip as it doesn't work with --follow
-            const ordering = options?.ordering ?? this.context.config?.commits.ordering;
-            if (ordering) {
-                args.push(`--${ordering}-order`);
-            }
-            args.push('--follow', rev, '--', relativePath);
-            const result = await this.git.run({
-                cwd: repoPath,
-                configs: gitConfigsLog,
-                caching: { cache: this.cache.gitResults, options: { accessTTL: 5 * 60 * 1000 } },
-            }, ...args);
-            let previousSha;
-            let previousPath;
-            let file;
-            for (const commit of parser.parse(result.stdout)) {
-                const path = relativePath;
-                file = commit.files.find(f => f.path === path || f.originalPath === path);
-                // Keep track of the file changing paths
-                if (file?.originalPath && file.originalPath !== relativePath) {
-                    relativePath = file.originalPath;
-                }
-                if (skip > 0) {
-                    skip--;
-                    continue;
-                }
-                if (currentSha == null) {
-                    currentSha = commit.sha;
-                    currentPath = file?.path ?? relativePath;
-                }
-                else if (previousSha == null) {
-                    if (commit.sha === rev)
-                        continue;
-                    previousSha = commit.sha;
-                    previousPath = file?.path ?? relativePath;
-                    break;
-                }
-            }
-            if (currentSha == null || currentPath == null)
-                return undefined;
-            return {
-                current: createRevisionUri(this.provider, repoPath, currentPath, currentSha || undefined),
-                previous: createRevisionUri(this.provider, repoPath, previousPath ?? currentPath, previousSha ?? deletedOrMissing),
-            };
-        }
-        catch (ex) {
-            scope?.error(ex);
-            throw ex;
-        }
-    }
-    async getPreviousComparisonUrisForRange(repoPath, pathOrUri, rev, range, options, _cancellation) {
-        if (rev === deletedOrMissing)
-            return undefined;
-        const scope = getScopedLogger();
-        if (rev === uncommitted) {
-            rev = undefined;
-        }
-        let currentSha;
-        let currentPath;
-        let relativePath = this.provider.getRelativePath(pathOrUri, repoPath);
-        const skipFirstRev = options?.skipFirstRev ?? true;
-        // If we are at the working tree (i.e. no ref), we need to dig deeper to figure out where to go
-        if (!rev) {
-            const status = await this.provider.status?.getStatusForFile?.(repoPath, pathOrUri);
-            if (status != null) {
-                if (status.indexStatus != null) {
-                    if (status.workingTreeStatus != null && !skipFirstRev) {
-                        return {
-                            current: createRevisionUri(this.provider, repoPath, relativePath, undefined),
-                            previous: createRevisionUri(this.provider, repoPath, relativePath, uncommittedStaged),
-                            range: range,
-                        };
-                    }
-                    currentSha = uncommittedStaged;
-                    currentPath = status.originalPath ?? status.path;
-                    if (status.originalPath != null) {
-                        relativePath = status.originalPath;
-                    }
-                    rev = uncommittedStaged;
-                }
-                else if (status.workingTreeStatus != null && !skipFirstRev) {
-                    currentSha = '';
-                    currentPath = relativePath;
-                    rev = '';
-                }
-            }
-        }
-        else if (!skipFirstRev) {
-            currentSha = rev;
-            currentPath = relativePath;
-        }
-        try {
-            const parser = getShaAndFileRangeLogParser();
-            const args = ['log', ...parser.arguments, '-n2']; // Don't use --skip as it doesn't work with --follow
-            const ordering = options?.ordering ?? this.context.config?.commits.ordering;
-            if (ordering) {
-                args.push(`--${ordering}-order`);
-            }
-            if (rev && !isUncommittedStaged(rev)) {
-                args.push(rev);
-            }
-            args.push(`-L${range.startLine},${range.endLine}:${relativePath}`);
-            let result;
-            try {
-                result = await this.git.run({ cwd: repoPath, configs: gitConfigsLog }, ...args);
-            }
-            catch (ex) {
-                if (rev && !isUncommittedStaged(rev))
-                    throw ex;
-                // If the line count is invalid reset to a valid range
-                const match = GitErrors.invalidLineCount.exec(ex?.toString() ?? '');
-                if (match == null)
-                    throw ex;
-                const line = parseInt(match[1], 10);
-                if (isNaN(line))
-                    throw ex;
-                const index = args.findIndex(a => a.startsWith('-L'));
-                if (index === -1)
-                    throw ex;
-                range = {
-                    startLine: Math.min(range.startLine, line),
-                    startCharacter: range.startCharacter,
-                    endLine: Math.min(range.endLine, line),
-                    endCharacter: range.endCharacter,
-                    active: range.active,
-                };
-                args.splice(index, 1, `-L${range.startLine},${range.endLine}:${relativePath}`);
-                result = await this.git.run({ cwd: repoPath, configs: gitConfigsLog }, ...args);
-            }
-            let currentRange;
-            let previousSha;
-            let previousPath;
-            let file;
-            for (const commit of parser.parse(result.stdout)) {
-                const path = relativePath;
-                file = commit.files.find(f => f.path === path || f.originalPath === path);
-                // If we couldn't find the file, but there is only one file in the commit, use that one and assume the filename changed
-                if (file == null && commit.files.length === 1) {
-                    file = commit.files[0];
-                    relativePath = file.path;
-                }
-                // Keep track of the file changing paths
-                if (file?.originalPath && file.originalPath !== relativePath) {
-                    relativePath = file.originalPath;
-                }
-                if (currentSha == null) {
-                    currentSha = commit.sha;
-                    currentPath = file?.path ?? relativePath;
-                    currentRange =
-                        file?.range != null ? { ...file.range, startCharacter: 1, endCharacter: 1 } : undefined;
-                }
-                else if (previousSha == null) {
-                    if (commit.sha === rev)
-                        continue;
-                    previousSha = commit.sha;
-                    previousPath = file?.path ?? relativePath;
-                    break;
-                }
-            }
-            if (currentSha == null || currentPath == null)
-                return undefined;
-            // If we have no previous SHA but have a real current SHA, resolve the parent commit.
-            // This handles the case where a line is newly added — the line has no prior history,
-            // but the file likely existed at the parent commit
-            if (previousSha == null && currentSha) {
-                previousSha =
-                    (await this.provider.refs.validateReference(repoPath, `${currentSha}^`)) ?? deletedOrMissing;
-            }
-            return {
-                current: createRevisionUri(this.provider, repoPath, currentPath, currentSha || undefined),
-                previous: createRevisionUri(this.provider, repoPath, previousPath ?? currentPath, previousSha ?? deletedOrMissing),
-                range: currentRange ?? range,
-            };
-        }
-        catch (ex) {
-            scope?.error(ex);
-            throw ex;
-        }
-    }
-    /** Returns raw diff output for a file between two revisions. */
-    async diff(repoPath, fileName, ref1, ref2, options) {
-        const params = ['diff', '--no-ext-diff', '--minimal'];
-        if (options?.linesOfContext != null) {
-            params.push(`-U${options.linesOfContext}`);
-        }
-        if (options?.renames) {
-            params.push(`-M${options.similarityThreshold == null ? '' : `${options.similarityThreshold}%`}`);
-        }
-        if (options?.filters != null && options.filters.length !== 0) {
-            params.push(`--diff-filter=${options.filters.join('')}`);
-        }
-        if (ref1) {
-            // <sha>^3 signals an untracked file in a stash and if we are trying to find its parent, use the root sha
-            if (ref1.endsWith('^3^')) {
-                ref1 = rootSha;
-            }
-            params.push(isUncommittedStaged(ref1) ? '--staged' : ref1);
-        }
-        if (ref2) {
-            params.push(isUncommittedStaged(ref2) ? '--staged' : ref2);
-        }
-        try {
-            return await this.git.run({ cwd: repoPath, configs: gitConfigsDiff, encoding: options?.encoding }, ...params, '--', fileName);
-        }
-        catch (ex) {
-            const match = GitErrors.badRevision.exec(ex.message);
-            if (match !== null) {
-                const [, ref] = match;
-                // If the bad ref is trying to find a parent ref, assume we hit to the last commit, so try again using the root sha
-                if (ref === ref1 && ref?.endsWith('^')) {
-                    return this.diff(repoPath, fileName, rootSha, ref2, options);
-                }
-            }
-            throw ex;
-        }
-    }
-    /** Returns raw diff output comparing a file's revision with given contents via stdin. */
-    async diffContents(repoPath, fileName, ref, contents, options) {
-        const params = [
-            'diff',
-            `-M${options?.similarityThreshold == null ? '' : `${options.similarityThreshold}%`}`,
-            '--no-ext-diff',
-            '-U0',
-            '--minimal',
-        ];
-        if (options?.filters != null && options.filters.length !== 0) {
-            params.push(`--diff-filter=${options.filters.join('')}`);
-        }
-        params.push('--no-index');
-        try {
-            const result = await this.git.run({
-                cwd: repoPath,
-                configs: gitConfigsDiff,
-                encoding: options?.encoding,
-                stdin: contents,
-            }, ...params, '--', fileName, 
-            // Pipe the contents to stdin
-            '-');
-            return result.stdout;
-        }
-        catch (ex) {
-            if (ex instanceof GitError && ex.stdout) {
-                return ex.stdout;
-            }
-            const match = GitErrors.badRevision.exec(ex.message);
-            if (match !== null) {
-                const [, matchedRef] = match;
-                // If the bad ref is trying to find a parent ref, assume we hit to the last commit, so try again using the root sha
-                if (matchedRef === ref && matchedRef?.endsWith('^')) {
-                    return this.diffContents(repoPath, fileName, rootSha, contents, options);
-                }
-            }
-            throw ex;
-        }
-    }
-    /** Returns parsed diff hunks for a file between two revisions. */
-    getDiffForFile(repoPath, fileName, ref1, ref2, options) {
-        const cacheKey = `${normalizePath(fileName)}:${ref1 ?? ''}:${ref2 ?? ''}`;
-        return this.cache.diff.getOrCreate(repoPath, cacheKey, () => this.getDiffForFileCore(repoPath, fileName, ref1, ref2, options), { errorTTL: 1000 * 60 });
-    }
-    async getDiffForFileCore(repoPath, fileName, ref1, ref2, options) {
-        // Include renames (R) and copies (C) so content diffs on renamed files still surface;
-        // --diff-filter runs after `-M` rename detection, so 'M' alone would drop valid rename diffs.
-        const result = await this.diff(repoPath, fileName, ref1, ref2, {
-            encoding: options?.encoding,
-            filters: ['M', 'R', 'C'],
-            linesOfContext: 0,
-            renames: true,
-            similarityThreshold: this.context.config?.commits.similarityThreshold,
-        });
-        return parseGitFileDiff(result.stdout);
-    }
-    /** Returns parsed diff hunks comparing a file's revision with given contents via stdin. */
-    getDiffForFileContents(repoPath, fileName, ref, contents, options) {
-        const cacheKey = `${normalizePath(fileName)}:${ref}:~${fnv1aHash(contents)}`;
-        return this.cache.diff.getOrCreate(repoPath, cacheKey, () => this.getDiffForFileContentsCore(repoPath, fileName, ref, contents, options), { errorTTL: 1000 * 60 });
-    }
-    async getDiffForFileContentsCore(repoPath, fileName, ref, contents, options) {
-        const data = await this.diffContents(repoPath, fileName, ref, contents, {
-            encoding: options?.encoding,
-            filters: ['M', 'R', 'C'],
-            similarityThreshold: this.context.config?.commits.similarityThreshold,
-        });
-        return parseGitFileDiff(data);
-    }
-    /** Finds the most recent commit where the given path was copied, renamed, or deleted. */
-    async findPathStatusChanged(repoPath, pathspec, rev, options) {
-        return findPathStatusChanged(this.git, repoPath, pathspec, rev, options);
-    }
-    async openDiffTool(repoPath, pathOrUri, options) {
-        const scope = getScopedLogger();
-        const [relativePath, root] = splitPath(toFsPath(pathOrUri), repoPath);
-        try {
-            let tool = options?.tool;
-            if (!tool) {
-                const scope = getScopedLogger();
-                tool = await this.getDiffTool(root);
-                if (tool == null)
-                    throw new Error('No diff tool found');
-                scope?.debug(`Using tool=${tool}`);
-            }
-            await this.git.run({ cwd: root }, 'difftool', '--no-prompt', `--tool=${tool}`, options?.staged ? '--staged' : undefined, options?.ref1 ? options.ref1 : undefined, options?.ref2 ? options.ref2 : undefined, '--', relativePath);
-        }
-        catch (ex) {
-            const msg = ex?.toString() ?? '';
-            if (msg === 'No diff tool found' || /Unknown .+? tool/.test(msg)) {
-                throw new Error('Unable to open changes because the specified diff tool cannot be found or no Git diff tool is configured', { cause: ex });
-            }
-            scope?.error(ex);
-            throw ex;
-        }
-    }
-    async openDirectoryCompare(repoPath, ref1, ref2, tool) {
-        const scope = getScopedLogger();
-        try {
-            if (!tool) {
-                const scope = getScopedLogger();
-                tool = await this.getDiffTool(repoPath);
-                if (tool == null)
-                    throw new Error('No diff tool found');
-                scope?.debug(`Using tool=${tool}`);
-            }
-            await this.git.run({ cwd: repoPath }, 'difftool', '--dir-diff', `--tool=${tool}`, ref1, ref2);
-        }
-        catch (ex) {
-            const msg = ex?.toString() ?? '';
-            if (msg === 'No diff tool found' || /Unknown .+? tool/.test(msg)) {
-                throw new Error('Unable to open directory compare because the specified diff tool cannot be found or no Git diff tool is configured', { cause: ex });
-            }
-            scope?.error(ex);
-            throw ex;
-        }
-    }
-}
-__decorate([
-    debug()
-], DiffGitSubProvider.prototype, "getChangedFilesCount", null);
-__decorate([
-    debug()
-], DiffGitSubProvider.prototype, "getDiff", null);
-__decorate([
-    debug()
-], DiffGitSubProvider.prototype, "getParsedDiff", null);
-__decorate([
-    debug({ args: repoPath => ({ repoPath: repoPath }) })
-], DiffGitSubProvider.prototype, "getDiffFiles", null);
-__decorate([
-    debug()
-], DiffGitSubProvider.prototype, "getDiffStatus", null);
-__decorate([
-    debug()
-], DiffGitSubProvider.prototype, "getDiffTool", null);
-__decorate([
-    debug()
-], DiffGitSubProvider.prototype, "getNextComparisonUris", null);
-__decorate([
-    debug()
-], DiffGitSubProvider.prototype, "getPreviousComparisonUris", null);
-__decorate([
-    debug()
-], DiffGitSubProvider.prototype, "getPreviousComparisonUrisForRange", null);
-__decorate([
-    debug()
-], DiffGitSubProvider.prototype, "getDiffForFile", null);
-__decorate([
-    debug()
-], DiffGitSubProvider.prototype, "getDiffForFileContents", null);
-__decorate([
-    debug()
-], DiffGitSubProvider.prototype, "findPathStatusChanged", null);
-__decorate([
-    debug()
-], DiffGitSubProvider.prototype, "openDiffTool", null);
-__decorate([
-    debug()
-], DiffGitSubProvider.prototype, "openDirectoryCompare", null);
-// Returns true when no --diff-filter is active or when it includes additions ('A' or '*').
-// Untracked files are semantically "added" — if a caller restricts filters to e.g. ['M'],
-// honor that and omit untracked.
+__decorate([debug()], DiffGitSubProvider.prototype, "getChangedFilesCount", null);
+__decorate([debug()], DiffGitSubProvider.prototype, "getDiff", null);
+__decorate([debug()], DiffGitSubProvider.prototype, "getParsedDiff", null);
+__decorate([debug({ args: (repoPath) => ({ repoPath }) })], DiffGitSubProvider.prototype, "getDiffFiles", null);
+__decorate([debug()], DiffGitSubProvider.prototype, "getDiffStatus", null);
+__decorate([debug()], DiffGitSubProvider.prototype, "getDiffTool", null);
+__decorate([debug()], DiffGitSubProvider.prototype, "getNextComparisonUris", null);
+__decorate([debug()], DiffGitSubProvider.prototype, "getPreviousComparisonUris", null);
+__decorate([debug()], DiffGitSubProvider.prototype, "getPreviousComparisonUrisForRange", null);
+__decorate([debug()], DiffGitSubProvider.prototype, "getDiffForFile", null);
+__decorate([debug()], DiffGitSubProvider.prototype, "getDiffForFileContents", null);
+__decorate([debug()], DiffGitSubProvider.prototype, "findPathStatusChanged", null);
+__decorate([debug()], DiffGitSubProvider.prototype, "openDiffTool", null);
+__decorate([debug()], DiffGitSubProvider.prototype, "openDirectoryCompare", null);
 function filtersAllowUntracked(filters) {
-    if (!filters?.length)
-        return true;
-    return filters.includes('A') || filters.includes('*');
+	if (!filters?.length) return true;
+	return filters.includes("A") || filters.includes("*");
 }
-// Returns true when the path is a git pathspec we can't match with simple equality
-// (directory prefix, glob, or magic pathspec). In that case, skip the untracked merge
-// rather than risk excluding legitimate matches or including wrong ones.
 function isNonExactPathspec(path) {
-    if (!path)
-        return false;
-    return path.endsWith('/') || /[*?[\]]|^:/.test(path);
+	if (!path) return false;
+	return path.endsWith("/") || /[*?[\]]|^:/.test(path);
 }
-// Returns true when the `git diff` invocation shape includes the working tree
-// (i.e. `git diff`, `git diff HEAD`, or `git diff <ref>` with no `from`), and
-// therefore untracked files are a meaningful addition to the result.
 function isWorkingTreeComparison(to, from) {
-    if (to == null)
-        return true;
-    if (isRevisionRange(to) || isUncommittedStaged(to))
-        return false;
-    // `to === uncommitted` always targets the working tree (`prepareToFromDiffArgs` sets
-    // `from = 'HEAD'` when omitted, or diffs against the caller-supplied `from`).
-    if (isUncommitted(to))
-        return true;
-    // `git diff <from>` — `to === ''` means the caller explicitly asked for working tree vs `from`
-    if (to === '')
-        return from == null || !isUncommittedStaged(from);
-    // `getChangedFilesCount` uses `prepareToFromDiffArgs`, which translates `to` (with no `from`)
-    // to `${to}^ ${to}` UNLESS `to` is HEAD or empty.
-    if (to.toUpperCase() === 'HEAD' && from == null)
-        return true;
-    return false;
+	if (to == null) return true;
+	if (isRevisionRange(to) || isUncommittedStaged(to)) return false;
+	if (isUncommitted(to)) return true;
+	if (to === "") return from == null || !isUncommittedStaged(from);
+	if (to.toUpperCase() === "HEAD" && from == null) return true;
+	return false;
 }
 function prepareToFromDiffArgs(to, from, args, notation) {
-    if (to === uncommitted) {
-        if (from != null) {
-            args.push(from);
-        }
-        else {
-            // Get only unstaged changes
-            from = 'HEAD';
-        }
-    }
-    else if (to === uncommittedStaged) {
-        args.push('--staged');
-        if (from != null) {
-            args.push(from);
-        }
-        else {
-            // Get only staged changes
-            from = 'HEAD';
-        }
-    }
-    else if (from == null) {
-        if (to === '' || to.toUpperCase() === 'HEAD') {
-            from = 'HEAD';
-            args.push(from);
-        }
-        else {
-            from = `${to}^`;
-            args.push(from, to);
-        }
-    }
-    else if (to === '') {
-        args.push(from);
-    }
-    else if (notation != null) {
-        args.push(`${from}${notation}${to}`);
-    }
-    else {
-        args.push(from, to);
-    }
-    return from;
+	if (to === "0000000000000000000000000000000000000000") {
+		if (from != null) args.push(from);
+		else from = "HEAD";
+	} else if (to === "0000000000000000000000000000000000000000:") {
+		args.push("--staged");
+		if (from != null) args.push(from);
+		else from = "HEAD";
+	} else if (from == null) {
+		if (to === "" || to.toUpperCase() === "HEAD") {
+			from = "HEAD";
+			args.push(from);
+		} else {
+			from = `${to}^`;
+			args.push(from, to);
+		}
+	} else if (to === "") args.push(from);
+	else if (notation != null) args.push(`${from}${notation}${to}`);
+	else args.push(from, to);
+	return from;
 }
 function createRevisionUri(provider, repoPath, relativePath, sha) {
-    return {
-        uri: sha
-            ? fromUri({
-                scheme: 'gitlens',
-                authority: encodeGitLensRevisionUriAuthority({ ref: sha, repoPath: repoPath }),
-                path: provider.getAbsoluteUri(relativePath, repoPath).path,
-            })
-            : provider.getAbsoluteUri(relativePath, repoPath),
-        path: relativePath,
-        sha: sha,
-        repoPath: repoPath,
-    };
+	return {
+		uri: sha ? fromUri({
+			scheme: "gitlens",
+			authority: encodeGitLensRevisionUriAuthority({
+				ref: sha,
+				repoPath
+			}),
+			path: provider.getAbsoluteUri(relativePath, repoPath).path
+		}) : provider.getAbsoluteUri(relativePath, repoPath),
+		path: relativePath,
+		sha,
+		repoPath
+	};
 }
-export async function findPathStatusChanged(git, repoPath, pathspec, rev, options) {
-    const parser = getShaAndFileSummaryLogParser();
-    const ordering = options?.ordering;
-    const result = await git.run({ cwd: repoPath, configs: gitConfigsLog }, 'log', ...parser.arguments, ordering ? `--${ordering}-order` : undefined, '--no-walk', `--diff-filter=${options?.filters?.length ? options.filters.join('') : 'RCD'}`, rev, 
-    // Note: --no-walk constrains to the exact commit (no ancestor search). Pathspec is omitted
-    // because git suppresses rename detection with pathspecs (shows D instead of R, losing the destination path).
-    '--');
-    const commit = first(parser.parse(result.stdout));
-    if (commit == null)
-        return undefined;
-    const file = commit.files.find(f => f.path === pathspec || f.originalPath === pathspec);
-    return { sha: commit.sha, file: file };
+async function findPathStatusChanged(git, repoPath, pathspec, rev, options) {
+	const parser = getShaAndFileSummaryLogParser();
+	const ordering = options?.ordering;
+	const result = await git.run({
+		cwd: repoPath,
+		configs: gitConfigsLog
+	}, "log", ...parser.arguments, ordering ? `--${ordering}-order` : void 0, "--no-walk", `--diff-filter=${options?.filters?.length ? options.filters.join("") : "RCD"}`, rev, "--");
+	const commit = first(parser.parse(result.stdout));
+	if (commit == null) return void 0;
+	const file = commit.files.find((f) => f.path === pathspec || f.originalPath === pathspec);
+	return {
+		sha: commit.sha,
+		file
+	};
 }
+//#endregion
+export { DiffGitSubProvider, findPathStatusChanged };
+
 //# sourceMappingURL=diff.js.map