@gitkraken/core-gitlens 0.6.0 → 0.7.0

package/dist/git/errors.js

@@ -1,718 +1,940 @@
-import { pluralize } from '../utils/string.js';
+import { getNumericFormat } from "../utils/date.js";
+import * as l10n from "@vscode/l10n";
+//#region ../git/src/errors.ts
+function formatEnglish(message, ...args) {
+	if (typeof message === "object") return formatEnglish(message.message, ...Array.isArray(message.args) ? message.args : [message.args]);
+	const values = args.length === 1 && typeof args[0] === "object" && args[0] != null ? args[0] : args;
+	return message.replace(/{([^}]+)}/g, (match, key) => {
+		const value = values[key];
+		return typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? String(value) : match;
+	});
+}
+/** Renders the source (English) string with placeholders substituted, never a translation */
+const english = { t: formatEnglish };
 /**
- * stderr patterns git emits that are EXPECTED rather than exceptional — an empty repo, a path that doesn't
- * exist at a revision, a branch with no upstream. The exec layer matches these to decide a command "warned"
- * rather than failed.
- *
- * Matching one does NOT mean the empty output is a valid answer: `noCommits` on a fresh repo genuinely means
- * "no commits", while `notARepository` means the read never happened. Callers must branch on which key
- * matched — see `GitRunCompletion`. Pure patterns with no environment dependency, so this lives here rather
- * than in the CLI provider, where the shared run contract couldn't reference it.
- */
-export const GitWarnings = {
-    notARepository: /Not a git repository/i,
-    outsideRepository: /is outside repository/i,
-    noPath: /no such path/i,
-    noCommits: /does not have any commits/i,
-    notFound: /Path '.*?' does not exist in/i,
-    foundButNotInRevision: /Path '.*?' exists on disk, but not in/i,
-    headNotABranch: /HEAD does not point to a branch/i,
-    noUpstream: /no upstream configured for branch '(.*?)'/i,
-    unknownRevision: /ambiguous argument '.*?': unknown revision or path not in the working tree|not stored as a remote-tracking branch/i,
-    mustRunInWorkTree: /this operation must be run in a work tree/i,
-    patchWithConflicts: /Applied patch to '.*?' with conflicts/i,
-    noRemoteRepositorySpecified: /No remote repository specified\./i,
-    remoteConnectionError: /Could not read from remote repository/i,
-    notAGitCommand: /'.+' is not a git command/i,
-    tipBehind: /tip of your current branch is behind/i,
+* stderr patterns git emits that are EXPECTED rather than exceptional — an empty repo, a path that doesn't
+* exist at a revision, a branch with no upstream. The exec layer matches these to decide a command "warned"
+* rather than failed.
+*
+* Matching one does NOT mean the empty output is a valid answer: `noCommits` on a fresh repo genuinely means
+* "no commits", while `notARepository` means the read never happened. Callers must branch on which key
+* matched — see `GitRunCompletion`. Pure patterns with no environment dependency, so this lives here rather
+* than in the CLI provider, where the shared run contract couldn't reference it.
+*/
+const GitWarnings = {
+	notARepository: /Not a git repository/i,
+	outsideRepository: /is outside repository/i,
+	noPath: /no such path/i,
+	noCommits: /does not have any commits/i,
+	notFound: /Path '.*?' does not exist in/i,
+	foundButNotInRevision: /Path '.*?' exists on disk, but not in/i,
+	headNotABranch: /HEAD does not point to a branch/i,
+	noUpstream: /no upstream configured for branch '(.*?)'/i,
+	unknownRevision: /ambiguous argument '.*?': unknown revision or path not in the working tree|not stored as a remote-tracking branch/i,
+	mustRunInWorkTree: /this operation must be run in a work tree/i,
+	patchWithConflicts: /Applied patch to '.*?' with conflicts/i,
+	noRemoteRepositorySpecified: /No remote repository specified\./i,
+	remoteConnectionError: /Could not read from remote repository/i,
+	notAGitCommand: /'.+' is not a git command/i,
+	tipBehind: /tip of your current branch is behind/i
 };
-export class GitCommandError extends Error {
-    static is(ex) {
-        return ex instanceof GitCommandError;
-    }
-    _details;
-    get details() {
-        return this._details;
-    }
-    set details(details) {
-        this._details = details;
-        this.message = this.buildErrorMessage(details);
-    }
-    original;
-    constructor(message, details, original) {
-        super(message);
-        this.original = original;
-        this.details = details;
-        Error.captureStackTrace?.(this, new.target);
-    }
-    update(changes) {
-        this.details = { ...this.details, ...changes };
-        return this;
-    }
-}
-export class GitSearchError extends Error {
-    original;
-    reason;
-    detail;
-    static is(ex) {
-        return ex instanceof GitSearchError;
-    }
-    constructor(original, reason, detail) {
-        super(original.message);
-        this.original = original;
-        this.reason = reason;
-        this.detail = detail;
-        Error.captureStackTrace?.(this, new.target);
-    }
-}
-export class ApplyPatchCommitError extends GitCommandError {
-    static is(ex, reason) {
-        return ex instanceof ApplyPatchCommitError && (reason == null || ex.details.reason === reason);
-    }
-    constructor(details, original) {
-        super('Unable to apply patch', details, original);
-    }
-    buildErrorMessage(details) {
-        const baseMessage = 'Unable to apply patch';
-        switch (details.reason) {
-            case 'applyFailed':
-                return `${baseMessage}${this.original instanceof CherryPickError ? `. ${this.original.message}` : ''}`;
-            case 'appliedWithConflicts':
-                return 'Patch applied with conflicts';
-            case 'checkoutFailed':
-                return `${baseMessage} as we were unable to checkout the branch '${details.branch}'${this.original instanceof CheckoutError ? `. ${this.original.message}` : ''}`;
-            case 'createWorktreeFailed':
-                return `${baseMessage} as we were unable to create a worktree${this.original instanceof WorktreeCreateError ? `. ${this.original.message}` : ''}`;
-            case 'stashFailed':
-                return `${baseMessage} as we were unable to stash your working changes${this.original instanceof StashPushError ? `. ${this.original.message}` : ''}`;
-            case 'wouldOverwriteChanges':
-                return `${baseMessage} as some local changes would be overwritten`;
-            default:
-                return baseMessage;
-        }
-    }
-}
-export class CommitError extends GitCommandError {
-    static is(ex, reason) {
-        return ex instanceof CommitError && (reason == null || ex.details.reason === reason);
-    }
-    constructor(details, original) {
-        super('Unable to commit', details, original);
-    }
-    buildErrorMessage(details) {
-        const baseMessage = 'Unable to commit';
-        switch (details.reason) {
-            case 'nothingToCommit':
-                return `${baseMessage} because there are no staged changes`;
-            case 'conflicts':
-                return `${baseMessage} because there are unresolved merge conflicts`;
-            case 'noUserNameConfigured':
-                return 'Please configure your git user name and email before committing';
-            default:
-                return baseMessage;
-        }
-    }
-}
-export class BlameIgnoreRevsFileError extends Error {
-    fileName;
-    original;
-    static is(ex) {
-        return ex instanceof BlameIgnoreRevsFileError;
-    }
-    constructor(fileName, original) {
-        super(`Invalid blame.ignoreRevsFile: '${fileName}'`);
-        this.fileName = fileName;
-        this.original = original;
-        Error.captureStackTrace?.(this, new.target);
-    }
-}
-export class BlameIgnoreRevsFileBadRevisionError extends Error {
-    revision;
-    original;
-    static is(ex) {
-        return ex instanceof BlameIgnoreRevsFileBadRevisionError;
-    }
-    constructor(revision, original) {
-        super(`Invalid revision in blame.ignoreRevsFile: '${revision}'`);
-        this.revision = revision;
-        this.original = original;
-        Error.captureStackTrace?.(this, new.target);
-    }
-}
-export class BranchError extends GitCommandError {
-    static is(ex, reason) {
-        return ex instanceof BranchError && (reason == null || ex.details.reason === reason);
-    }
-    constructor(details, original) {
-        super('Unable to perform action on branch', details, original);
-    }
-    buildErrorMessage(details) {
-        let baseMessage;
-        if (details.action != null) {
-            baseMessage = `Unable to ${details.action} branch ${details.branch ? `'${details.branch}'` : ''}`;
-        }
-        else {
-            baseMessage = `Unable to perform action ${details.branch ? `with branch '${details.branch}'` : 'on branch'}`;
-        }
-        switch (details.reason) {
-            case 'alreadyExists':
-                return `${baseMessage} because it already exists`;
-            case 'notFullyMerged':
-                return `${baseMessage} because it is not fully merged`;
-            case 'invalidName':
-                return `${baseMessage} because the branch name is invalid`;
-            case 'noRemoteReference':
-                return `${baseMessage} because the remote reference does not exist`;
-            default:
-                return baseMessage;
-        }
-    }
-}
-export class CheckoutError extends GitCommandError {
-    static is(ex, reason) {
-        return ex instanceof CheckoutError && (reason == null || ex.details.reason === reason);
-    }
-    constructor(details, original) {
-        super('Unable to checkout', details, original);
-    }
-    buildErrorMessage(details) {
-        const baseMessage = `Unable to checkout${details.ref ? ` '${details.ref}'` : ''}`;
-        switch (details.reason) {
-            case 'invalidRef':
-                return `${baseMessage} because the reference is invalid`;
-            case 'pathspecNotFound':
-                return `${baseMessage} because the path or reference does not exist`;
-            case 'wouldOverwriteChanges':
-                return `${baseMessage}. Your local changes would be overwritten. Please commit or stash your changes before switching branches.`;
-            default:
-                return baseMessage;
-        }
-    }
-}
-export class CherryPickError extends GitCommandError {
-    static is(ex, reason) {
-        return ex instanceof CherryPickError && (reason == null || ex.details.reason === reason);
-    }
-    constructor(details, original) {
-        super('Unable to cherry-pick', details, original);
-    }
-    buildErrorMessage(details) {
-        const baseMessage = `Unable to cherry-pick${details.revs?.length
-            ? details.revs.length === 1
-                ? ` commit '${details.revs[0]}'`
-                : ` ${pluralize('commit', details.revs.length)}`
-            : ''}`;
-        switch (details.reason) {
-            case 'aborted':
-                return `${baseMessage} as it was aborted.`;
-            case 'alreadyInProgress':
-                return `${baseMessage} as a cherry-pick is already in progress.`;
-            case 'conflicts':
-                return `${baseMessage} due to conflicts.`;
-            case 'emptyCommit':
-                return `${baseMessage} because it is an empty commit.`;
-            case 'wouldOverwriteChanges':
-                return `${baseMessage} as some local changes would be overwritten.`;
-            default:
-                return baseMessage;
-        }
-    }
-}
-export class FetchError extends GitCommandError {
-    static is(ex, reason) {
-        return ex instanceof FetchError && (reason == null || ex.details.reason === reason);
-    }
-    constructor(details, original) {
-        super('Unable to fetch', details, original);
-    }
-    buildErrorMessage(details) {
-        const baseMessage = `Unable to fetch${details.branch ? ` branch '${details.branch}'` : ''}${details.remote ? ` from ${details.remote}` : ''}`;
-        switch (details.reason) {
-            case 'noFastForward':
-                return `${baseMessage} as it cannot be fast-forwarded`;
-            case 'noRemote':
-                return `${baseMessage} without a remote repository specified.`;
-            case 'remoteConnectionFailed':
-                return `${baseMessage}. Could not connect to the remote repository.`;
-            default:
-                return baseMessage;
-        }
-    }
-}
-export class MergeError extends GitCommandError {
-    static is(ex, reason) {
-        return ex instanceof MergeError && (reason == null || ex.details.reason === reason);
-    }
-    constructor(details, original) {
-        super('Unable to merge', details, original);
-    }
-    buildErrorMessage(details) {
-        const baseMessage = `Unable to merge${details.ref ? ` '${details.ref}'` : ''}`;
-        switch (details.reason) {
-            case 'aborted':
-                return `Merge${details.ref ? ` of '${details.ref}'` : ''} was aborted`;
-            case 'alreadyInProgress':
-                return `${baseMessage} because a merge is already in progress`;
-            case 'conflicts':
-                return `${baseMessage} due to conflicts. Resolve the conflicts first and continue the merge`;
-            case 'uncommittedChanges':
-                return `${baseMessage} because there are uncommitted changes`;
-            case 'wouldOverwriteChanges':
-                return `${baseMessage} because some local changes would be overwritten`;
-            default:
-                return baseMessage;
-        }
-    }
-}
-export class PausedOperationAbortError extends GitCommandError {
-    static is(ex, reason) {
-        return ex instanceof PausedOperationAbortError && (reason == null || ex.details.reason === reason);
-    }
-    constructor(details, original) {
-        super('Unable to abort operation', details, original);
-    }
-    buildErrorMessage(details) {
-        switch (details.reason) {
-            case 'nothingToAbort':
-                return `Cannot abort as there is no ${details.operation.type} operation in progress`;
-            default:
-                return `Unable to abort the ${details.operation.type} operation${this.original ? `: ${this.original.message}` : ''}`;
-        }
-    }
-}
-export class PausedOperationContinueError extends GitCommandError {
-    static is(ex, reason) {
-        return ex instanceof PausedOperationContinueError && (reason == null || ex.details.reason === reason);
-    }
-    constructor(details, original) {
-        super('Unable to continue operation', details, original);
-    }
-    buildErrorMessage(details) {
-        switch (details.reason) {
-            case 'conflicts':
-                return `Cannot ${details.skip ? 'skip' : 'continue'} the ${details.operation.type} operation as there are unresolved conflicts`;
-            case 'emptyCommit':
-                return `Cannot ${details.skip ? 'skip' : 'continue'} the ${details.operation.type} operation as the previous commit is empty`;
-            case 'messageEditFailed':
-                return `Cannot ${details.skip ? 'skip' : 'continue'} the ${details.operation.type} operation as a commit message needs to be edited and the editor could not be opened`;
-            case 'nothingToContinue':
-                return `Cannot ${details.skip ? 'skip' : 'continue'} the ${details.operation.type} operation as there is no ${details.operation.type} in progress`;
-            case 'uncommittedChanges':
-                return `Cannot ${details.skip ? 'skip' : 'continue'} the ${details.operation.type} operation as there are uncommitted changes`;
-            case 'unmergedFiles':
-                return `Cannot ${details.skip ? 'skip' : 'continue'} the ${details.operation.type} operation as there are unmerged files`;
-            case 'unstagedChanges':
-                return `Cannot ${details.skip ? 'skip' : 'continue'} the ${details.operation.type} operation as there are unstaged changes`;
-            case 'wouldOverwriteChanges':
-                return `Cannot ${details.skip ? 'skip' : 'continue'} the ${details.operation.type} operation as some local changes would be overwritten`;
-            default:
-                return `Unable to ${details.skip ? 'skip' : 'continue'} the ${details.operation.type} operation${this.original ? `: ${this.original.message}` : ''}`;
-        }
-    }
-}
-export class PullError extends GitCommandError {
-    static is(ex, reason) {
-        return ex instanceof PullError && (reason == null || ex.details.reason === reason);
-    }
-    constructor(details, original) {
-        super('Unable to pull', details, original);
-    }
-    buildErrorMessage(details) {
-        const baseMessage = 'Unable to pull';
-        switch (details.reason) {
-            case 'conflict':
-                return 'Unable to complete pull due to conflicts which must be resolved.';
-            case 'gitIdentity':
-                return `${baseMessage} because you have not yet set up your Git identity.`;
-            case 'rebaseMultipleBranches':
-                return `${baseMessage} because you are trying to rebase onto multiple branches.`;
-            case 'refLocked':
-                return `${baseMessage} because a local ref could not be updated.`;
-            case 'remoteConnectionFailed':
-                return `${baseMessage} because the remote repository could not be reached.`;
-            case 'tagConflict':
-                return `${baseMessage} because a local tag would be overwritten.`;
-            case 'uncommittedChanges':
-                return `${baseMessage} because you have uncommitted changes.`;
-            case 'unmergedFiles':
-                return `${baseMessage} because you have unmerged files.`;
-            case 'unstagedChanges':
-                return `${baseMessage} because you have unstaged changes.`;
-            case 'wouldOverwriteChanges':
-                return `${baseMessage} because local changes to some files would be overwritten.`;
-            default:
-                return baseMessage;
-        }
-    }
-}
-export class PushError extends GitCommandError {
-    static is(ex, reason) {
-        return ex instanceof PushError && (reason == null || ex.details.reason === reason);
-    }
-    constructor(details, original) {
-        super('Unable to push', details, original);
-    }
-    buildErrorMessage(details) {
-        const baseMessage = `Unable to push${details.branch ? ` branch '${details.branch}'` : ''}${details.remote ? ` to ${details.remote}` : ''}`;
-        switch (details.reason) {
-            case 'noUpstream':
-                return `${baseMessage} because it has no upstream branch.`;
-            case 'permissionDenied':
-                return `${baseMessage} because you don't have permission to push to this remote repository.`;
-            case 'rejected':
-                return `${baseMessage} because some refs failed to push or the push was rejected. Try pulling first.`;
-            case 'rejectedRefDoesNotExist':
-                return `Unable to delete remote branch${details.branch ? ` '${details.branch}'` : ''}${details.remote ? ` from ${details.remote}` : ''}, the remote reference does not exist`;
-            case 'rejectedWithLease':
-            case 'rejectedWithLeaseIfIncludes':
-                return `Unable to force push${details.branch ? ` branch '${details.branch}'` : ''}${details.remote ? ` to ${details.remote}` : ''} because some refs failed to push or the push was rejected. The tip of the remote-tracking branch has been updated since the last checkout. Try pulling first.`;
-            case 'remoteAhead':
-                return `${baseMessage} because the remote contains work that you do not have locally. Try fetching first.`;
-            case 'remoteConnectionFailed':
-                return `${baseMessage} because the remote repository could not be reached.`;
-            case 'tipBehind':
-                return `${baseMessage} as it is behind its remote counterpart. Try pulling first.`;
-            default:
-                return baseMessage;
-        }
-    }
-}
-export class RebaseError extends GitCommandError {
-    static is(ex, reason) {
-        return ex instanceof RebaseError && (reason == null || ex.details.reason === reason);
-    }
-    constructor(details, original) {
-        super('Unable to rebase', details, original);
-    }
-    buildErrorMessage(details) {
-        const baseMessage = `Unable to rebase${details.upstream ? ` onto '${details.upstream}'` : ''}`;
-        switch (details.reason) {
-            case 'aborted':
-                return `Rebase${details.upstream ? ` onto '${details.upstream}'` : ''} was aborted`;
-            case 'alreadyInProgress':
-                return `${baseMessage} because a rebase is already in progress`;
-            case 'conflicts':
-                return `${baseMessage} due to conflicts. Resolve the conflicts first and continue the rebase`;
-            case 'uncommittedChanges':
-                return `${baseMessage} because there are uncommitted changes`;
-            case 'wouldOverwriteChanges':
-                return `${baseMessage} because some local changes would be overwritten`;
-            default:
-                return baseMessage;
-        }
-    }
-}
-export class ResetError extends GitCommandError {
-    static is(ex, reason) {
-        return ex instanceof ResetError && (reason == null || ex.details.reason === reason);
-    }
-    constructor(details, original) {
-        super('Unable to reset', details, original);
-    }
-    buildErrorMessage(details) {
-        const baseMessage = 'Unable to reset';
-        switch (details.reason) {
-            case 'ambiguousArgument':
-                return `${baseMessage} because the argument is ambiguous`;
-            case 'detachedHead':
-                return `${baseMessage} because you are in a detached HEAD state`;
-            case 'notUpToDate':
-                return `${baseMessage} because the index is not up to date (you may have unresolved merge conflicts)`;
-            case 'permissionDenied':
-                return `${baseMessage} because you don't have permission to modify affected files`;
-            case 'refLocked':
-                return `${baseMessage} because the ref is locked`;
-            case 'unmergedChanges':
-                return `${baseMessage} because there are unmerged changes`;
-            case 'wouldOverwriteChanges':
-                return `${baseMessage} because your local changes would be overwritten`;
-            default:
-                return baseMessage;
-        }
-    }
-}
-export class RevertError extends GitCommandError {
-    static is(ex, reason) {
-        return ex instanceof RevertError && (reason == null || ex.details.reason === reason);
-    }
-    constructor(details, original) {
-        super('Unable to revert', details, original);
-    }
-    buildErrorMessage(details) {
-        const baseMessage = `Unable to revert${details.refs?.length ? ` ${details.refs.join(', ')}` : ''}`;
-        switch (details.reason) {
-            case 'aborted':
-                return `Revert${details.refs?.length ? ` of ${details.refs.join(', ')}` : ''} was aborted`;
-            case 'alreadyInProgress':
-                return `${baseMessage} because a revert is already in progress`;
-            case 'conflicts':
-                return `${baseMessage} due to conflicts. Resolve the conflicts first and continue the revert`;
-            case 'uncommittedChanges':
-                return `${baseMessage} because there are uncommitted changes`;
-            case 'wouldOverwriteChanges':
-                return `${baseMessage} because some local changes would be overwritten`;
-            default:
-                return baseMessage;
-        }
-    }
-}
-export class StashApplyError extends GitCommandError {
-    static is(ex, reason) {
-        return ex instanceof StashApplyError && (reason == null || ex.details.reason === reason);
-    }
-    constructor(details, original) {
-        super('Unable to apply stash', details, original);
-    }
-    buildErrorMessage(details) {
-        switch (details.reason) {
-            case 'uncommittedChanges':
-                return 'Unable to apply stash. Your working tree changes would be overwritten. Please commit or stash your changes before trying again';
-            default:
-                return 'Unable to apply stash';
-        }
-    }
-}
-export class StashPushError extends GitCommandError {
-    static is(ex, reason) {
-        return ex instanceof StashPushError && (reason == null || ex.details.reason === reason);
-    }
-    constructor(details, original) {
-        super('Unable to stash', details, original);
-    }
-    buildErrorMessage(details) {
-        switch (details.reason) {
-            case 'conflictingStagedAndUnstagedLines':
-                return 'Changes were stashed, but the working tree cannot be updated because at least one file has staged and unstaged changes on the same line(s)';
-            case 'nothingToSave':
-                return 'No files to stash';
-            default:
-                return 'Unable to stash';
-        }
-    }
-}
-export class ShowError extends GitCommandError {
-    static is(ex, reason) {
-        return ex instanceof ShowError && (reason == null || ex.details.reason === reason);
-    }
-    constructor(details, original) {
-        super('Unable to show file', details, original);
-    }
-    buildErrorMessage(details) {
-        const baseMessage = `Unable to show${details.path ? ` '${details.path}'` : ' file'}${details.rev ? ` at revision '${details.rev}'` : ''}`;
-        switch (details.reason) {
-            case 'invalidObject':
-                return `${baseMessage} because the path is not a file`;
-            case 'invalidRevision':
-                return `${baseMessage} because the specified revision is invalid`;
-            case 'notFound':
-                return `${baseMessage} because the file does not exist`;
-            case 'notInRevision':
-                return `${baseMessage} because the file is not in the specified revision`;
-            default:
-                return baseMessage;
-        }
-    }
-}
-export class TagError extends GitCommandError {
-    static is(ex, reason) {
-        return ex instanceof TagError && (reason == null || ex.details.reason === reason);
-    }
-    constructor(details, original) {
-        super('Unable to perform action on tag', details, original);
-    }
-    buildErrorMessage(details) {
-        let baseMessage;
-        if (details.action != null) {
-            baseMessage = `Unable to ${details.action} tag ${details.tag ? `'${details.tag}'` : ''}`;
-        }
-        else {
-            baseMessage = `Unable to perform action${details.tag ? ` with tag '${details.tag}'` : 'on tag'}`;
-        }
-        switch (details.reason) {
-            case 'alreadyExists':
-                return `${baseMessage} because it already exists`;
-            case 'invalidName':
-                return `${baseMessage} because the tag name is invalid`;
-            case 'notFound':
-                return `${baseMessage} because it does not exist`;
-            case 'permissionDenied':
-                return `${baseMessage} because you don't have permission to push to this remote repository.`;
-            case 'remoteRejected':
-                return `${baseMessage} because the remote repository rejected the push.`;
-            case 'tagConflict':
-                return `${baseMessage} because the remote already has a tag with that name. Use force to overwrite it.`;
-            default:
-                return baseMessage;
-        }
-    }
+var GitCommandError = class GitCommandError extends Error {
+	static is(ex) {
+		return ex instanceof GitCommandError;
+	}
+	_details;
+	get details() {
+		return this._details;
+	}
+	set details(details) {
+		this._details = details;
+		this.message = this.buildErrorMessage(details, english);
+	}
+	/** The translated message for UI. `message` is always the English sentence so logs and stack traces stay searchable — see `getPresentableErrorMessage` */
+	get localizedMessage() {
+		return this.buildErrorMessage(this._details, l10n);
+	}
+	original;
+	constructor(details, original) {
+		super();
+		this.name = new.target.name;
+		this.original = original;
+		this.details = details;
+		Error.captureStackTrace?.(this, new.target);
+	}
+	update(changes) {
+		this.details = {
+			...this.details,
+			...changes
+		};
+		return this;
+	}
+};
+var GitSearchError = class GitSearchError extends Error {
+	original;
+	reason;
+	detail;
+	static is(ex) {
+		return ex instanceof GitSearchError;
+	}
+	constructor(original, reason, detail) {
+		super(original.message);
+		this.original = original;
+		this.reason = reason;
+		this.detail = detail;
+		Error.captureStackTrace?.(this, new.target);
+	}
+};
+var ApplyPatchCommitError = class ApplyPatchCommitError extends GitCommandError {
+	static is(ex, reason) {
+		return ex instanceof ApplyPatchCommitError && (reason == null || ex.details.reason === reason);
+	}
+	buildErrorMessage(details, l10n) {
+		switch (details.reason) {
+			case "applyFailed": return this.original instanceof CherryPickError ? l10n.t("Unable to apply patch. {0}", this.original.message) : l10n.t("Unable to apply patch");
+			case "appliedWithConflicts": return l10n.t("Patch applied with conflicts");
+			case "checkoutFailed": return this.original instanceof CheckoutError ? l10n.t("Unable to apply patch as we were unable to checkout the branch '{0}'. {1}", String(details.branch), this.original.message) : l10n.t("Unable to apply patch as we were unable to checkout the branch '{0}'", String(details.branch));
+			case "createWorktreeFailed": return this.original instanceof WorktreeCreateError ? l10n.t("Unable to apply patch as we were unable to create a worktree. {0}", this.original.message) : l10n.t("Unable to apply patch as we were unable to create a worktree");
+			case "stashFailed": return this.original instanceof StashPushError ? l10n.t("Unable to apply patch as we were unable to stash your working changes. {0}", this.original.message) : l10n.t("Unable to apply patch as we were unable to stash your working changes");
+			case "wouldOverwriteChanges": return l10n.t("Unable to apply patch as some local changes would be overwritten");
+			default: return l10n.t("Unable to apply patch");
+		}
+	}
+};
+var CommitError = class CommitError extends GitCommandError {
+	static is(ex, reason) {
+		return ex instanceof CommitError && (reason == null || ex.details.reason === reason);
+	}
+	buildErrorMessage(details, l10n) {
+		const baseMessage = l10n.t("Unable to commit");
+		switch (details.reason) {
+			case "nothingToCommit": return l10n.t("Unable to commit because there are no staged changes");
+			case "conflicts": return l10n.t("Unable to commit because there are unresolved merge conflicts");
+			case "noUserNameConfigured": return l10n.t("Please configure your git user name and email before committing");
+			default: return baseMessage;
+		}
+	}
+};
+var BlameIgnoreRevsFileError = class BlameIgnoreRevsFileError extends Error {
+	fileName;
+	original;
+	static is(ex) {
+		return ex instanceof BlameIgnoreRevsFileError;
+	}
+	constructor(fileName, original) {
+		super(l10n.t("Invalid blame.ignoreRevsFile: '{0}'", fileName));
+		this.fileName = fileName;
+		this.original = original;
+		Error.captureStackTrace?.(this, new.target);
+	}
+};
+var BlameIgnoreRevsFileBadRevisionError = class BlameIgnoreRevsFileBadRevisionError extends Error {
+	revision;
+	original;
+	static is(ex) {
+		return ex instanceof BlameIgnoreRevsFileBadRevisionError;
+	}
+	constructor(revision, original) {
+		super(l10n.t("Invalid revision in blame.ignoreRevsFile: '{0}'", revision));
+		this.revision = revision;
+		this.original = original;
+		Error.captureStackTrace?.(this, new.target);
+	}
+};
+var BranchError = class BranchError extends GitCommandError {
+	static is(ex, reason) {
+		return ex instanceof BranchError && (reason == null || ex.details.reason === reason);
+	}
+	buildErrorMessage(details, l10n) {
+		const branch = details.branch;
+		const action = details.action;
+		if (!branch) switch (action) {
+			case "create": return getMissingBranchErrorMessage("create", details.reason, l10n);
+			case "delete": return getMissingBranchErrorMessage("delete", details.reason, l10n);
+			case "force delete": return getMissingBranchErrorMessage("force delete", details.reason, l10n);
+			case "rename": return getMissingBranchErrorMessage("rename", details.reason, l10n);
+			case "unset upstream of": return getMissingBranchErrorMessage("unset upstream of", details.reason, l10n);
+			default:
+				if (action?.startsWith("set upstream to '") && action.endsWith("' for")) return getMissingSetUpstreamBranchErrorMessage(action.slice(17, -5), details.reason, l10n);
+				return getGenericBranchErrorMessage(void 0, details.reason, l10n);
+		}
+		if (action?.startsWith("set upstream to '") && action.endsWith("' for")) {
+			const upstream = action.slice(17, -5);
+			switch (details.reason) {
+				case "alreadyExists": return l10n.t("Unable to set upstream to '{0}' for branch '{1}' because it already exists", upstream, branch);
+				case "notFullyMerged": return l10n.t("Unable to set upstream to '{0}' for branch '{1}' because it is not fully merged", upstream, branch);
+				case "invalidName": return l10n.t("Unable to set upstream to '{0}' for branch '{1}' because the branch name is invalid", upstream, branch);
+				case "noRemoteReference": return l10n.t("Unable to set upstream to '{0}' for branch '{1}' because the remote reference does not exist", upstream, branch);
+				default: return l10n.t("Unable to set upstream to '{0}' for branch '{1}'", upstream, branch);
+			}
+		}
+		switch (action) {
+			case "create": switch (details.reason) {
+				case "alreadyExists": return l10n.t("Unable to create branch '{0}' because it already exists", branch);
+				case "notFullyMerged": return l10n.t("Unable to create branch '{0}' because it is not fully merged", branch);
+				case "invalidName": return l10n.t("Unable to create branch '{0}' because the branch name is invalid", branch);
+				case "noRemoteReference": return l10n.t("Unable to create branch '{0}' because the remote reference does not exist", branch);
+				default: return l10n.t("Unable to create branch '{0}'", branch);
+			}
+			case "delete": switch (details.reason) {
+				case "alreadyExists": return l10n.t("Unable to delete branch '{0}' because it already exists", branch);
+				case "notFullyMerged": return l10n.t("Unable to delete branch '{0}' because it is not fully merged", branch);
+				case "invalidName": return l10n.t("Unable to delete branch '{0}' because the branch name is invalid", branch);
+				case "noRemoteReference": return l10n.t("Unable to delete branch '{0}' because the remote reference does not exist", branch);
+				default: return l10n.t("Unable to delete branch '{0}'", branch);
+			}
+			case "force delete": switch (details.reason) {
+				case "alreadyExists": return l10n.t("Unable to force delete branch '{0}' because it already exists", branch);
+				case "notFullyMerged": return l10n.t("Unable to force delete branch '{0}' because it is not fully merged", branch);
+				case "invalidName": return l10n.t("Unable to force delete branch '{0}' because the branch name is invalid", branch);
+				case "noRemoteReference": return l10n.t("Unable to force delete branch '{0}' because the remote reference does not exist", branch);
+				default: return l10n.t("Unable to force delete branch '{0}'", branch);
+			}
+			case "rename": switch (details.reason) {
+				case "alreadyExists": return l10n.t("Unable to rename branch '{0}' because it already exists", branch);
+				case "notFullyMerged": return l10n.t("Unable to rename branch '{0}' because it is not fully merged", branch);
+				case "invalidName": return l10n.t("Unable to rename branch '{0}' because the branch name is invalid", branch);
+				case "noRemoteReference": return l10n.t("Unable to rename branch '{0}' because the remote reference does not exist", branch);
+				default: return l10n.t("Unable to rename branch '{0}'", branch);
+			}
+			case "unset upstream of": switch (details.reason) {
+				case "alreadyExists": return l10n.t("Unable to unset upstream of branch '{0}' because it already exists", branch);
+				case "notFullyMerged": return l10n.t("Unable to unset upstream of branch '{0}' because it is not fully merged", branch);
+				case "invalidName": return l10n.t("Unable to unset upstream of branch '{0}' because the branch name is invalid", branch);
+				case "noRemoteReference": return l10n.t("Unable to unset upstream of branch '{0}' because the remote reference does not exist", branch);
+				default: return l10n.t("Unable to unset upstream of branch '{0}'", branch);
+			}
+			default: return getGenericBranchErrorMessage(branch, details.reason, l10n);
+		}
+	}
+};
+function getMissingBranchErrorMessage(action, reason, l10n) {
+	switch (action) {
+		case "create": switch (reason) {
+			case "alreadyExists": return l10n.t("Unable to create branch because it already exists");
+			case "notFullyMerged": return l10n.t("Unable to create branch because it is not fully merged");
+			case "invalidName": return l10n.t("Unable to create branch because the branch name is invalid");
+			case "noRemoteReference": return l10n.t("Unable to create branch because the remote reference does not exist");
+			default: return l10n.t("Unable to create branch");
+		}
+		case "delete": switch (reason) {
+			case "alreadyExists": return l10n.t("Unable to delete branch because it already exists");
+			case "notFullyMerged": return l10n.t("Unable to delete branch because it is not fully merged");
+			case "invalidName": return l10n.t("Unable to delete branch because the branch name is invalid");
+			case "noRemoteReference": return l10n.t("Unable to delete branch because the remote reference does not exist");
+			default: return l10n.t("Unable to delete branch");
+		}
+		case "force delete": switch (reason) {
+			case "alreadyExists": return l10n.t("Unable to force delete branch because it already exists");
+			case "notFullyMerged": return l10n.t("Unable to force delete branch because it is not fully merged");
+			case "invalidName": return l10n.t("Unable to force delete branch because the branch name is invalid");
+			case "noRemoteReference": return l10n.t("Unable to force delete branch because the remote reference does not exist");
+			default: return l10n.t("Unable to force delete branch");
+		}
+		case "rename": switch (reason) {
+			case "alreadyExists": return l10n.t("Unable to rename branch because it already exists");
+			case "notFullyMerged": return l10n.t("Unable to rename branch because it is not fully merged");
+			case "invalidName": return l10n.t("Unable to rename branch because the branch name is invalid");
+			case "noRemoteReference": return l10n.t("Unable to rename branch because the remote reference does not exist");
+			default: return l10n.t("Unable to rename branch");
+		}
+		case "unset upstream of": switch (reason) {
+			case "alreadyExists": return l10n.t("Unable to unset upstream of branch because it already exists");
+			case "notFullyMerged": return l10n.t("Unable to unset upstream of branch because it is not fully merged");
+			case "invalidName": return l10n.t("Unable to unset upstream of branch because the branch name is invalid");
+			case "noRemoteReference": return l10n.t("Unable to unset upstream of branch because the remote reference does not exist");
+			default: return l10n.t("Unable to unset upstream of branch");
+		}
+	}
 }
-export class WorkspaceUntrustedError extends Error {
-    static is(ex) {
-        return ex instanceof WorkspaceUntrustedError;
-    }
-    constructor() {
-        super('Unable to perform Git operations because the current workspace is untrusted');
-        Error.captureStackTrace?.(this, new.target);
-    }
+function getMissingSetUpstreamBranchErrorMessage(upstream, reason, l10n) {
+	switch (reason) {
+		case "alreadyExists": return l10n.t("Unable to set upstream to '{0}' for branch because it already exists", upstream);
+		case "notFullyMerged": return l10n.t("Unable to set upstream to '{0}' for branch because it is not fully merged", upstream);
+		case "invalidName": return l10n.t("Unable to set upstream to '{0}' for branch because the branch name is invalid", upstream);
+		case "noRemoteReference": return l10n.t("Unable to set upstream to '{0}' for branch because the remote reference does not exist", upstream);
+		default: return l10n.t("Unable to set upstream to '{0}' for branch", upstream);
+	}
 }
-export class WorktreeCreateError extends GitCommandError {
-    static is(ex, reason) {
-        return ex instanceof WorktreeCreateError && (reason == null || ex.details.reason === reason);
-    }
-    constructor(details, original) {
-        super('Unable to create worktree', details, original);
-    }
-    buildErrorMessage(details) {
-        switch (details.reason) {
-            case 'alreadyCheckedOut':
-                return 'Unable to create worktree because it is already checked out';
-            case 'alreadyExists':
-                return 'Unable to create worktree because it already exists';
-            default:
-                return 'Unable to create worktree';
-        }
-    }
+function getGenericBranchErrorMessage(branch, reason, l10n) {
+	if (branch) switch (reason) {
+		case "alreadyExists": return l10n.t("Unable to perform action with branch '{0}' because it already exists", branch);
+		case "notFullyMerged": return l10n.t("Unable to perform action with branch '{0}' because it is not fully merged", branch);
+		case "invalidName": return l10n.t("Unable to perform action with branch '{0}' because the branch name is invalid", branch);
+		case "noRemoteReference": return l10n.t("Unable to perform action with branch '{0}' because the remote reference does not exist", branch);
+		default: return l10n.t("Unable to perform action with branch '{0}'", branch);
+	}
+	switch (reason) {
+		case "alreadyExists": return l10n.t("Unable to perform action on branch because it already exists");
+		case "notFullyMerged": return l10n.t("Unable to perform action on branch because it is not fully merged");
+		case "invalidName": return l10n.t("Unable to perform action on branch because the branch name is invalid");
+		case "noRemoteReference": return l10n.t("Unable to perform action on branch because the remote reference does not exist");
+		default: return l10n.t("Unable to perform action on branch");
+	}
 }
-export class WorktreeDeleteError extends GitCommandError {
-    static is(ex, reason) {
-        return ex instanceof WorktreeDeleteError && (reason == null || ex.details.reason === reason);
-    }
-    constructor(details, original) {
-        super('Unable to delete worktree', details, original);
-    }
-    buildErrorMessage(details) {
-        switch (details.reason) {
-            case 'defaultWorkingTree':
-                return 'Cannot delete worktree because it is the default working tree';
-            case 'directoryNotEmpty':
-                return 'Unable to delete worktree because the directory is not empty';
-            case 'locked':
-                return 'Unable to delete worktree because it is locked';
-            case 'uncommittedChanges':
-                return 'Unable to delete worktree because there are uncommitted changes';
-            default:
-                return 'Unable to delete worktree';
-        }
-    }
+var CheckoutError = class CheckoutError extends GitCommandError {
+	static is(ex, reason) {
+		return ex instanceof CheckoutError && (reason == null || ex.details.reason === reason);
+	}
+	buildErrorMessage(details, l10n) {
+		switch (details.reason) {
+			case "invalidRef": return details.ref ? l10n.t("Unable to checkout '{0}' because the reference is invalid", details.ref) : l10n.t("Unable to checkout because the reference is invalid");
+			case "pathspecNotFound": return details.ref ? l10n.t("Unable to checkout '{0}' because the path or reference does not exist", details.ref) : l10n.t("Unable to checkout because the path or reference does not exist");
+			case "wouldOverwriteChanges": return details.ref ? l10n.t("Unable to checkout '{0}'. Your local changes would be overwritten. Please commit or stash your changes before switching branches.", details.ref) : l10n.t("Unable to checkout. Your local changes would be overwritten. Please commit or stash your changes before switching branches.");
+			default: return details.ref ? l10n.t("Unable to checkout '{0}'", details.ref) : l10n.t("Unable to checkout");
+		}
+	}
+};
+var CherryPickError = class CherryPickError extends GitCommandError {
+	static is(ex, reason) {
+		return ex instanceof CherryPickError && (reason == null || ex.details.reason === reason);
+	}
+	buildErrorMessage(details, l10n) {
+		if (details.revs?.length === 1) {
+			const rev = details.revs[0];
+			switch (details.reason) {
+				case "aborted": return l10n.t("Unable to cherry-pick commit '{0}' as it was aborted.", rev);
+				case "alreadyInProgress": return l10n.t("Unable to cherry-pick commit '{0}' as a cherry-pick is already in progress.", rev);
+				case "conflicts": return l10n.t("Unable to cherry-pick commit '{0}' due to conflicts.", rev);
+				case "emptyCommit": return l10n.t("Unable to cherry-pick commit '{0}' because it is an empty commit.", rev);
+				case "wouldOverwriteChanges": return l10n.t("Unable to cherry-pick commit '{0}' as some local changes would be overwritten.", rev);
+				default: return l10n.t("Unable to cherry-pick commit '{0}'", rev);
+			}
+		}
+		if (details.revs?.length) {
+			const count = getNumericFormat()(details.revs.length);
+			switch (details.reason) {
+				case "aborted": return l10n.t("Unable to cherry-pick {0} commits as it was aborted.", count);
+				case "alreadyInProgress": return l10n.t("Unable to cherry-pick {0} commits as a cherry-pick is already in progress.", count);
+				case "conflicts": return l10n.t("Unable to cherry-pick {0} commits due to conflicts.", count);
+				case "emptyCommit": return l10n.t("Unable to cherry-pick {0} commits because it is an empty commit.", count);
+				case "wouldOverwriteChanges": return l10n.t("Unable to cherry-pick {0} commits as some local changes would be overwritten.", count);
+				default: return l10n.t("Unable to cherry-pick {0} commits", count);
+			}
+		}
+		switch (details.reason) {
+			case "aborted": return l10n.t("Unable to cherry-pick as it was aborted.");
+			case "alreadyInProgress": return l10n.t("Unable to cherry-pick as a cherry-pick is already in progress.");
+			case "conflicts": return l10n.t("Unable to cherry-pick due to conflicts.");
+			case "emptyCommit": return l10n.t("Unable to cherry-pick because it is an empty commit.");
+			case "wouldOverwriteChanges": return l10n.t("Unable to cherry-pick as some local changes would be overwritten.");
+			default: return l10n.t("Unable to cherry-pick");
+		}
+	}
+};
+var FetchError = class FetchError extends GitCommandError {
+	static is(ex, reason) {
+		return ex instanceof FetchError && (reason == null || ex.details.reason === reason);
+	}
+	buildErrorMessage(details, l10n) {
+		if (details.branch && details.remote) switch (details.reason) {
+			case "noFastForward": return l10n.t("Unable to fetch branch '{0}' from {1} as it cannot be fast-forwarded", details.branch, details.remote);
+			case "noRemote": return l10n.t("Unable to fetch branch '{0}' from {1} without a remote repository specified.", details.branch, details.remote);
+			case "remoteConnectionFailed": return l10n.t("Unable to fetch branch '{0}' from {1}. Could not connect to the remote repository.", details.branch, details.remote);
+			default: return l10n.t("Unable to fetch branch '{0}' from {1}", details.branch, details.remote);
+		}
+		if (details.branch) switch (details.reason) {
+			case "noFastForward": return l10n.t("Unable to fetch branch '{0}' as it cannot be fast-forwarded", details.branch);
+			case "noRemote": return l10n.t("Unable to fetch branch '{0}' without a remote repository specified.", details.branch);
+			case "remoteConnectionFailed": return l10n.t("Unable to fetch branch '{0}'. Could not connect to the remote repository.", details.branch);
+			default: return l10n.t("Unable to fetch branch '{0}'", details.branch);
+		}
+		if (details.remote) switch (details.reason) {
+			case "noFastForward": return l10n.t("Unable to fetch from {0} as it cannot be fast-forwarded", details.remote);
+			case "noRemote": return l10n.t("Unable to fetch from {0} without a remote repository specified.", details.remote);
+			case "remoteConnectionFailed": return l10n.t("Unable to fetch from {0}. Could not connect to the remote repository.", details.remote);
+			default: return l10n.t("Unable to fetch from {0}", details.remote);
+		}
+		switch (details.reason) {
+			case "noFastForward": return l10n.t("Unable to fetch as it cannot be fast-forwarded");
+			case "noRemote": return l10n.t("Unable to fetch without a remote repository specified.");
+			case "remoteConnectionFailed": return l10n.t("Unable to fetch. Could not connect to the remote repository.");
+			default: return l10n.t("Unable to fetch");
+		}
+	}
+};
+var MergeError = class MergeError extends GitCommandError {
+	static is(ex, reason) {
+		return ex instanceof MergeError && (reason == null || ex.details.reason === reason);
+	}
+	buildErrorMessage(details, l10n) {
+		if (details.ref) switch (details.reason) {
+			case "aborted": return l10n.t("Merge of '{0}' was aborted", details.ref);
+			case "alreadyInProgress": return l10n.t("Unable to merge '{0}' because a merge is already in progress", details.ref);
+			case "conflicts": return l10n.t("Unable to merge '{0}' due to conflicts. Resolve the conflicts first and continue the merge", details.ref);
+			case "uncommittedChanges": return l10n.t("Unable to merge '{0}' because there are uncommitted changes", details.ref);
+			case "wouldOverwriteChanges": return l10n.t("Unable to merge '{0}' because some local changes would be overwritten", details.ref);
+			default: return l10n.t("Unable to merge '{0}'", details.ref);
+		}
+		switch (details.reason) {
+			case "aborted": return l10n.t("Merge was aborted");
+			case "alreadyInProgress": return l10n.t("Unable to merge because a merge is already in progress");
+			case "conflicts": return l10n.t("Unable to merge due to conflicts. Resolve the conflicts first and continue the merge");
+			case "uncommittedChanges": return l10n.t("Unable to merge because there are uncommitted changes");
+			case "wouldOverwriteChanges": return l10n.t("Unable to merge because some local changes would be overwritten");
+			default: return l10n.t("Unable to merge");
+		}
+	}
+};
+var PausedOperationAbortError = class PausedOperationAbortError extends GitCommandError {
+	static is(ex, reason) {
+		return ex instanceof PausedOperationAbortError && (reason == null || ex.details.reason === reason);
+	}
+	buildErrorMessage(details, l10n) {
+		switch (details.operation.type) {
+			case "cherry-pick":
+				if (details.reason === "nothingToAbort") return l10n.t("Cannot abort as there is no cherry-pick operation in progress");
+				return this.original ? l10n.t("Unable to abort the cherry-pick operation: {0}", this.original.message) : l10n.t("Unable to abort the cherry-pick operation");
+			case "merge":
+				if (details.reason === "nothingToAbort") return l10n.t("Cannot abort as there is no merge operation in progress");
+				return this.original ? l10n.t("Unable to abort the merge operation: {0}", this.original.message) : l10n.t("Unable to abort the merge operation");
+			case "rebase":
+				if (details.reason === "nothingToAbort") return l10n.t("Cannot abort as there is no rebase operation in progress");
+				return this.original ? l10n.t("Unable to abort the rebase operation: {0}", this.original.message) : l10n.t("Unable to abort the rebase operation");
+			case "revert":
+				if (details.reason === "nothingToAbort") return l10n.t("Cannot abort as there is no revert operation in progress");
+				return this.original ? l10n.t("Unable to abort the revert operation: {0}", this.original.message) : l10n.t("Unable to abort the revert operation");
+		}
+	}
+};
+var PausedOperationContinueError = class PausedOperationContinueError extends GitCommandError {
+	static is(ex, reason) {
+		return ex instanceof PausedOperationContinueError && (reason == null || ex.details.reason === reason);
+	}
+	buildErrorMessage(details, l10n) {
+		switch (details.operation.type) {
+			case "cherry-pick": return getCherryPickContinueErrorMessage(details.reason, details.skip ?? false, this.original, l10n);
+			case "merge": return getMergeContinueErrorMessage(details.reason, details.skip ?? false, this.original, l10n);
+			case "rebase": return getRebaseContinueErrorMessage(details.reason, details.skip ?? false, this.original, l10n);
+			case "revert": return getRevertContinueErrorMessage(details.reason, details.skip ?? false, this.original, l10n);
+		}
+	}
+};
+function getCherryPickContinueErrorMessage(reason, skip, original, l10n) {
+	if (skip) switch (reason) {
+		case "conflicts": return l10n.t("Cannot skip the cherry-pick operation as there are unresolved conflicts");
+		case "emptyCommit": return l10n.t("Cannot skip the cherry-pick operation as the previous commit is empty");
+		case "messageEditFailed": return l10n.t("Cannot skip the cherry-pick operation as a commit message needs to be edited and the editor could not be opened");
+		case "nothingToContinue": return l10n.t("Cannot skip the cherry-pick operation as there is no cherry-pick in progress");
+		case "uncommittedChanges": return l10n.t("Cannot skip the cherry-pick operation as there are uncommitted changes");
+		case "unmergedFiles": return l10n.t("Cannot skip the cherry-pick operation as there are unmerged files");
+		case "unstagedChanges": return l10n.t("Cannot skip the cherry-pick operation as there are unstaged changes");
+		case "wouldOverwriteChanges": return l10n.t("Cannot skip the cherry-pick operation as some local changes would be overwritten");
+		default: return original ? l10n.t("Unable to skip the cherry-pick operation: {0}", original.message) : l10n.t("Unable to skip the cherry-pick operation");
+	}
+	switch (reason) {
+		case "conflicts": return l10n.t("Cannot continue the cherry-pick operation as there are unresolved conflicts");
+		case "emptyCommit": return l10n.t("Cannot continue the cherry-pick operation as the previous commit is empty");
+		case "messageEditFailed": return l10n.t("Cannot continue the cherry-pick operation as a commit message needs to be edited and the editor could not be opened");
+		case "nothingToContinue": return l10n.t("Cannot continue the cherry-pick operation as there is no cherry-pick in progress");
+		case "uncommittedChanges": return l10n.t("Cannot continue the cherry-pick operation as there are uncommitted changes");
+		case "unmergedFiles": return l10n.t("Cannot continue the cherry-pick operation as there are unmerged files");
+		case "unstagedChanges": return l10n.t("Cannot continue the cherry-pick operation as there are unstaged changes");
+		case "wouldOverwriteChanges": return l10n.t("Cannot continue the cherry-pick operation as some local changes would be overwritten");
+		default: return original ? l10n.t("Unable to continue the cherry-pick operation: {0}", original.message) : l10n.t("Unable to continue the cherry-pick operation");
+	}
 }
-export var AuthenticationErrorReason;
-(function (AuthenticationErrorReason) {
-    AuthenticationErrorReason[AuthenticationErrorReason["UserDidNotConsent"] = 1] = "UserDidNotConsent";
-    AuthenticationErrorReason[AuthenticationErrorReason["Unauthorized"] = 2] = "Unauthorized";
-    AuthenticationErrorReason[AuthenticationErrorReason["Forbidden"] = 3] = "Forbidden";
-})(AuthenticationErrorReason || (AuthenticationErrorReason = {}));
-export class AuthenticationError extends Error {
-    id;
-    original;
-    reason;
-    authInfo;
-    constructor(info, messageOrReason, original) {
-        const { providerId: id, type, cloud, scopes, expiresAt } = info;
-        const tokenDetails = [
-            cloud ? 'cloud' : 'self-managed',
-            type,
-            info.microHash,
-            expiresAt && `expiresAt=${isNaN(expiresAt.getTime()) ? expiresAt.toString() : expiresAt.toISOString()}`,
-            scopes && `[${scopes.join(',')}]`,
-        ]
-            .filter(v => v)
-            .join(', ');
-        const authInfo = `(token details: ${tokenDetails})`;
-        let message;
-        let reason;
-        if (messageOrReason == null) {
-            message = `Unable to get required authentication session for '${id}'`;
-        }
-        else if (typeof messageOrReason === 'string') {
-            message = messageOrReason;
-            reason = undefined;
-        }
-        else {
-            reason = messageOrReason;
-            switch (reason) {
-                case AuthenticationErrorReason.UserDidNotConsent:
-                    message = `'${id}' authentication is required for this operation`;
-                    break;
-                case AuthenticationErrorReason.Unauthorized:
-                    message = `Your '${id}' credentials are either invalid or expired`;
-                    break;
-                case AuthenticationErrorReason.Forbidden:
-                    message = `Your '${id}' credentials do not have the required access`;
-                    break;
-            }
-        }
-        super(message);
-        this.id = id;
-        this.original = original;
-        this.reason = reason;
-        this.authInfo = authInfo;
-        Error.captureStackTrace?.(this, new.target);
-    }
-    static is(ex) {
-        return ex instanceof AuthenticationError;
-    }
-    toString() {
-        return `${super.toString()} ${this.authInfo}`;
-    }
+function getMergeContinueErrorMessage(reason, skip, original, l10n) {
+	if (skip) switch (reason) {
+		case "conflicts": return l10n.t("Cannot skip the merge operation as there are unresolved conflicts");
+		case "emptyCommit": return l10n.t("Cannot skip the merge operation as the previous commit is empty");
+		case "messageEditFailed": return l10n.t("Cannot skip the merge operation as a commit message needs to be edited and the editor could not be opened");
+		case "nothingToContinue": return l10n.t("Cannot skip the merge operation as there is no merge in progress");
+		case "uncommittedChanges": return l10n.t("Cannot skip the merge operation as there are uncommitted changes");
+		case "unmergedFiles": return l10n.t("Cannot skip the merge operation as there are unmerged files");
+		case "unstagedChanges": return l10n.t("Cannot skip the merge operation as there are unstaged changes");
+		case "wouldOverwriteChanges": return l10n.t("Cannot skip the merge operation as some local changes would be overwritten");
+		default: return original ? l10n.t("Unable to skip the merge operation: {0}", original.message) : l10n.t("Unable to skip the merge operation");
+	}
+	switch (reason) {
+		case "conflicts": return l10n.t("Cannot continue the merge operation as there are unresolved conflicts");
+		case "emptyCommit": return l10n.t("Cannot continue the merge operation as the previous commit is empty");
+		case "messageEditFailed": return l10n.t("Cannot continue the merge operation as a commit message needs to be edited and the editor could not be opened");
+		case "nothingToContinue": return l10n.t("Cannot continue the merge operation as there is no merge in progress");
+		case "uncommittedChanges": return l10n.t("Cannot continue the merge operation as there are uncommitted changes");
+		case "unmergedFiles": return l10n.t("Cannot continue the merge operation as there are unmerged files");
+		case "unstagedChanges": return l10n.t("Cannot continue the merge operation as there are unstaged changes");
+		case "wouldOverwriteChanges": return l10n.t("Cannot continue the merge operation as some local changes would be overwritten");
+		default: return original ? l10n.t("Unable to continue the merge operation: {0}", original.message) : l10n.t("Unable to continue the merge operation");
+	}
 }
-export class RequestClientError extends Error {
-    original;
-    static is(ex) {
-        return ex instanceof RequestClientError;
-    }
-    constructor(original) {
-        super(original.message);
-        this.original = original;
-        Error.captureStackTrace?.(this, new.target);
-    }
+function getRebaseContinueErrorMessage(reason, skip, original, l10n) {
+	if (skip) switch (reason) {
+		case "conflicts": return l10n.t("Cannot skip the rebase operation as there are unresolved conflicts");
+		case "emptyCommit": return l10n.t("Cannot skip the rebase operation as the previous commit is empty");
+		case "messageEditFailed": return l10n.t("Cannot skip the rebase operation as a commit message needs to be edited and the editor could not be opened");
+		case "nothingToContinue": return l10n.t("Cannot skip the rebase operation as there is no rebase in progress");
+		case "uncommittedChanges": return l10n.t("Cannot skip the rebase operation as there are uncommitted changes");
+		case "unmergedFiles": return l10n.t("Cannot skip the rebase operation as there are unmerged files");
+		case "unstagedChanges": return l10n.t("Cannot skip the rebase operation as there are unstaged changes");
+		case "wouldOverwriteChanges": return l10n.t("Cannot skip the rebase operation as some local changes would be overwritten");
+		default: return original ? l10n.t("Unable to skip the rebase operation: {0}", original.message) : l10n.t("Unable to skip the rebase operation");
+	}
+	switch (reason) {
+		case "conflicts": return l10n.t("Cannot continue the rebase operation as there are unresolved conflicts");
+		case "emptyCommit": return l10n.t("Cannot continue the rebase operation as the previous commit is empty");
+		case "messageEditFailed": return l10n.t("Cannot continue the rebase operation as a commit message needs to be edited and the editor could not be opened");
+		case "nothingToContinue": return l10n.t("Cannot continue the rebase operation as there is no rebase in progress");
+		case "uncommittedChanges": return l10n.t("Cannot continue the rebase operation as there are uncommitted changes");
+		case "unmergedFiles": return l10n.t("Cannot continue the rebase operation as there are unmerged files");
+		case "unstagedChanges": return l10n.t("Cannot continue the rebase operation as there are unstaged changes");
+		case "wouldOverwriteChanges": return l10n.t("Cannot continue the rebase operation as some local changes would be overwritten");
+		default: return original ? l10n.t("Unable to continue the rebase operation: {0}", original.message) : l10n.t("Unable to continue the rebase operation");
+	}
 }
-export class RequestNotFoundError extends Error {
-    original;
-    static is(ex) {
-        return ex instanceof RequestNotFoundError;
-    }
-    constructor(original) {
-        super(original.message);
-        this.original = original;
-        Error.captureStackTrace?.(this, new.target);
-    }
+function getRevertContinueErrorMessage(reason, skip, original, l10n) {
+	if (skip) switch (reason) {
+		case "conflicts": return l10n.t("Cannot skip the revert operation as there are unresolved conflicts");
+		case "emptyCommit": return l10n.t("Cannot skip the revert operation as the previous commit is empty");
+		case "messageEditFailed": return l10n.t("Cannot skip the revert operation as a commit message needs to be edited and the editor could not be opened");
+		case "nothingToContinue": return l10n.t("Cannot skip the revert operation as there is no revert in progress");
+		case "uncommittedChanges": return l10n.t("Cannot skip the revert operation as there are uncommitted changes");
+		case "unmergedFiles": return l10n.t("Cannot skip the revert operation as there are unmerged files");
+		case "unstagedChanges": return l10n.t("Cannot skip the revert operation as there are unstaged changes");
+		case "wouldOverwriteChanges": return l10n.t("Cannot skip the revert operation as some local changes would be overwritten");
+		default: return original ? l10n.t("Unable to skip the revert operation: {0}", original.message) : l10n.t("Unable to skip the revert operation");
+	}
+	switch (reason) {
+		case "conflicts": return l10n.t("Cannot continue the revert operation as there are unresolved conflicts");
+		case "emptyCommit": return l10n.t("Cannot continue the revert operation as the previous commit is empty");
+		case "messageEditFailed": return l10n.t("Cannot continue the revert operation as a commit message needs to be edited and the editor could not be opened");
+		case "nothingToContinue": return l10n.t("Cannot continue the revert operation as there is no revert in progress");
+		case "uncommittedChanges": return l10n.t("Cannot continue the revert operation as there are uncommitted changes");
+		case "unmergedFiles": return l10n.t("Cannot continue the revert operation as there are unmerged files");
+		case "unstagedChanges": return l10n.t("Cannot continue the revert operation as there are unstaged changes");
+		case "wouldOverwriteChanges": return l10n.t("Cannot continue the revert operation as some local changes would be overwritten");
+		default: return original ? l10n.t("Unable to continue the revert operation: {0}", original.message) : l10n.t("Unable to continue the revert operation");
+	}
 }
-export class RequestRateLimitError extends Error {
-    original;
-    token;
-    resetAt;
-    static is(ex) {
-        return ex instanceof RequestRateLimitError;
-    }
-    constructor(original, token, resetAt) {
-        super(original.message);
-        this.original = original;
-        this.token = token;
-        this.resetAt = resetAt;
-        Error.captureStackTrace?.(this, new.target);
-    }
+var PullError = class PullError extends GitCommandError {
+	static is(ex, reason) {
+		return ex instanceof PullError && (reason == null || ex.details.reason === reason);
+	}
+	buildErrorMessage(details, l10n) {
+		switch (details.reason) {
+			case "conflict": return l10n.t("Unable to complete pull due to conflicts which must be resolved.");
+			case "gitIdentity": return l10n.t("Unable to pull because you have not yet set up your Git identity.");
+			case "rebaseMultipleBranches": return l10n.t("Unable to pull because you are trying to rebase onto multiple branches.");
+			case "refLocked": return l10n.t("Unable to pull because a local ref could not be updated.");
+			case "remoteConnectionFailed": return l10n.t("Unable to pull because the remote repository could not be reached.");
+			case "tagConflict": return l10n.t("Unable to pull because a local tag would be overwritten.");
+			case "uncommittedChanges": return l10n.t("Unable to pull because you have uncommitted changes.");
+			case "unmergedFiles": return l10n.t("Unable to pull because you have unmerged files.");
+			case "unstagedChanges": return l10n.t("Unable to pull because you have unstaged changes.");
+			case "wouldOverwriteChanges": return l10n.t("Unable to pull because local changes to some files would be overwritten.");
+			default: return l10n.t("Unable to pull");
+		}
+	}
+};
+var PushError = class PushError extends GitCommandError {
+	static is(ex, reason) {
+		return ex instanceof PushError && (reason == null || ex.details.reason === reason);
+	}
+	buildErrorMessage(details, l10n) {
+		if (details.branch && details.remote) switch (details.reason) {
+			case "noUpstream": return l10n.t("Unable to push branch '{0}' to {1} because it has no upstream branch.", details.branch, details.remote);
+			case "permissionDenied": return l10n.t("Unable to push branch '{0}' to {1} because you don't have permission to push to this remote repository.", details.branch, details.remote);
+			case "rejected": return l10n.t("Unable to push branch '{0}' to {1} because some refs failed to push or the push was rejected. Try pulling first.", details.branch, details.remote);
+			case "rejectedRefDoesNotExist": return l10n.t("Unable to delete remote branch '{0}' from {1}, the remote reference does not exist", details.branch, details.remote);
+			case "rejectedWithLease":
+			case "rejectedWithLeaseIfIncludes": return l10n.t("Unable to force push branch '{0}' to {1} because some refs failed to push or the push was rejected. The tip of the remote-tracking branch has been updated since the last checkout. Try pulling first.", details.branch, details.remote);
+			case "remoteAhead": return l10n.t("Unable to push branch '{0}' to {1} because the remote contains work that you do not have locally. Try fetching first.", details.branch, details.remote);
+			case "remoteConnectionFailed": return l10n.t("Unable to push branch '{0}' to {1} because the remote repository could not be reached.", details.branch, details.remote);
+			case "tipBehind": return l10n.t("Unable to push branch '{0}' to {1} as it is behind its remote counterpart. Try pulling first.", details.branch, details.remote);
+			default: return l10n.t("Unable to push branch '{0}' to {1}", details.branch, details.remote);
+		}
+		if (details.branch) switch (details.reason) {
+			case "noUpstream": return l10n.t("Unable to push branch '{0}' because it has no upstream branch.", details.branch);
+			case "permissionDenied": return l10n.t("Unable to push branch '{0}' because you don't have permission to push to this remote repository.", details.branch);
+			case "rejected": return l10n.t("Unable to push branch '{0}' because some refs failed to push or the push was rejected. Try pulling first.", details.branch);
+			case "rejectedRefDoesNotExist": return l10n.t("Unable to delete remote branch '{0}', the remote reference does not exist", details.branch);
+			case "rejectedWithLease":
+			case "rejectedWithLeaseIfIncludes": return l10n.t("Unable to force push branch '{0}' because some refs failed to push or the push was rejected. The tip of the remote-tracking branch has been updated since the last checkout. Try pulling first.", details.branch);
+			case "remoteAhead": return l10n.t("Unable to push branch '{0}' because the remote contains work that you do not have locally. Try fetching first.", details.branch);
+			case "remoteConnectionFailed": return l10n.t("Unable to push branch '{0}' because the remote repository could not be reached.", details.branch);
+			case "tipBehind": return l10n.t("Unable to push branch '{0}' as it is behind its remote counterpart. Try pulling first.", details.branch);
+			default: return l10n.t("Unable to push branch '{0}'", details.branch);
+		}
+		if (details.remote) switch (details.reason) {
+			case "noUpstream": return l10n.t("Unable to push to {0} because it has no upstream branch.", details.remote);
+			case "permissionDenied": return l10n.t("Unable to push to {0} because you don't have permission to push to this remote repository.", details.remote);
+			case "rejected": return l10n.t("Unable to push to {0} because some refs failed to push or the push was rejected. Try pulling first.", details.remote);
+			case "rejectedRefDoesNotExist": return l10n.t("Unable to delete remote branch from {0}, the remote reference does not exist", details.remote);
+			case "rejectedWithLease":
+			case "rejectedWithLeaseIfIncludes": return l10n.t("Unable to force push to {0} because some refs failed to push or the push was rejected. The tip of the remote-tracking branch has been updated since the last checkout. Try pulling first.", details.remote);
+			case "remoteAhead": return l10n.t("Unable to push to {0} because the remote contains work that you do not have locally. Try fetching first.", details.remote);
+			case "remoteConnectionFailed": return l10n.t("Unable to push to {0} because the remote repository could not be reached.", details.remote);
+			case "tipBehind": return l10n.t("Unable to push to {0} as it is behind its remote counterpart. Try pulling first.", details.remote);
+			default: return l10n.t("Unable to push to {0}", details.remote);
+		}
+		switch (details.reason) {
+			case "noUpstream": return l10n.t("Unable to push because it has no upstream branch.");
+			case "permissionDenied": return l10n.t("Unable to push because you don't have permission to push to this remote repository.");
+			case "rejected": return l10n.t("Unable to push because some refs failed to push or the push was rejected. Try pulling first.");
+			case "rejectedRefDoesNotExist": return l10n.t("Unable to delete remote branch, the remote reference does not exist");
+			case "rejectedWithLease":
+			case "rejectedWithLeaseIfIncludes": return l10n.t("Unable to force push because some refs failed to push or the push was rejected. The tip of the remote-tracking branch has been updated since the last checkout. Try pulling first.");
+			case "remoteAhead": return l10n.t("Unable to push because the remote contains work that you do not have locally. Try fetching first.");
+			case "remoteConnectionFailed": return l10n.t("Unable to push because the remote repository could not be reached.");
+			case "tipBehind": return l10n.t("Unable to push as it is behind its remote counterpart. Try pulling first.");
+			default: return l10n.t("Unable to push");
+		}
+	}
+};
+var RebaseError = class RebaseError extends GitCommandError {
+	static is(ex, reason) {
+		return ex instanceof RebaseError && (reason == null || ex.details.reason === reason);
+	}
+	buildErrorMessage(details, l10n) {
+		if (details.upstream) switch (details.reason) {
+			case "aborted": return l10n.t("Rebase onto '{0}' was aborted", details.upstream);
+			case "alreadyInProgress": return l10n.t("Unable to rebase onto '{0}' because a rebase is already in progress", details.upstream);
+			case "conflicts": return l10n.t("Unable to rebase onto '{0}' due to conflicts. Resolve the conflicts first and continue the rebase", details.upstream);
+			case "uncommittedChanges": return l10n.t("Unable to rebase onto '{0}' because there are uncommitted changes", details.upstream);
+			case "wouldOverwriteChanges": return l10n.t("Unable to rebase onto '{0}' because some local changes would be overwritten", details.upstream);
+			default: return l10n.t("Unable to rebase onto '{0}'", details.upstream);
+		}
+		switch (details.reason) {
+			case "aborted": return l10n.t("Rebase was aborted");
+			case "alreadyInProgress": return l10n.t("Unable to rebase because a rebase is already in progress");
+			case "conflicts": return l10n.t("Unable to rebase due to conflicts. Resolve the conflicts first and continue the rebase");
+			case "uncommittedChanges": return l10n.t("Unable to rebase because there are uncommitted changes");
+			case "wouldOverwriteChanges": return l10n.t("Unable to rebase because some local changes would be overwritten");
+			default: return l10n.t("Unable to rebase");
+		}
+	}
+};
+var ResetError = class ResetError extends GitCommandError {
+	static is(ex, reason) {
+		return ex instanceof ResetError && (reason == null || ex.details.reason === reason);
+	}
+	buildErrorMessage(details, l10n) {
+		switch (details.reason) {
+			case "ambiguousArgument": return l10n.t("Unable to reset because the argument is ambiguous");
+			case "detachedHead": return l10n.t("Unable to reset because you are in a detached HEAD state");
+			case "notUpToDate": return l10n.t("Unable to reset because the index is not up to date (you may have unresolved merge conflicts)");
+			case "permissionDenied": return l10n.t("Unable to reset because you don't have permission to modify affected files");
+			case "refLocked": return l10n.t("Unable to reset because the ref is locked");
+			case "unmergedChanges": return l10n.t("Unable to reset because there are unmerged changes");
+			case "wouldOverwriteChanges": return l10n.t("Unable to reset because your local changes would be overwritten");
+			default: return l10n.t("Unable to reset");
+		}
+	}
+};
+var RevertError = class RevertError extends GitCommandError {
+	static is(ex, reason) {
+		return ex instanceof RevertError && (reason == null || ex.details.reason === reason);
+	}
+	buildErrorMessage(details, l10n) {
+		if (details.refs?.length) {
+			const refs = details.refs.join(", ");
+			switch (details.reason) {
+				case "aborted": return l10n.t("Revert of {0} was aborted", refs);
+				case "alreadyInProgress": return l10n.t("Unable to revert {0} because a revert is already in progress", refs);
+				case "conflicts": return l10n.t("Unable to revert {0} due to conflicts. Resolve the conflicts first and continue the revert", refs);
+				case "uncommittedChanges": return l10n.t("Unable to revert {0} because there are uncommitted changes", refs);
+				case "wouldOverwriteChanges": return l10n.t("Unable to revert {0} because some local changes would be overwritten", refs);
+				default: return l10n.t("Unable to revert {0}", refs);
+			}
+		}
+		switch (details.reason) {
+			case "aborted": return l10n.t("Revert was aborted");
+			case "alreadyInProgress": return l10n.t("Unable to revert because a revert is already in progress");
+			case "conflicts": return l10n.t("Unable to revert due to conflicts. Resolve the conflicts first and continue the revert");
+			case "uncommittedChanges": return l10n.t("Unable to revert because there are uncommitted changes");
+			case "wouldOverwriteChanges": return l10n.t("Unable to revert because some local changes would be overwritten");
+			default: return l10n.t("Unable to revert");
+		}
+	}
+};
+var StashApplyError = class StashApplyError extends GitCommandError {
+	static is(ex, reason) {
+		return ex instanceof StashApplyError && (reason == null || ex.details.reason === reason);
+	}
+	buildErrorMessage(details, l10n) {
+		switch (details.reason) {
+			case "uncommittedChanges": return l10n.t("Unable to apply stash. Your working tree changes would be overwritten. Please commit or stash your changes before trying again");
+			default: return l10n.t("Unable to apply stash");
+		}
+	}
+};
+var StashPushError = class StashPushError extends GitCommandError {
+	static is(ex, reason) {
+		return ex instanceof StashPushError && (reason == null || ex.details.reason === reason);
+	}
+	buildErrorMessage(details, l10n) {
+		switch (details.reason) {
+			case "conflictingStagedAndUnstagedLines": return l10n.t("Changes were stashed, but the working tree cannot be updated because at least one file has staged and unstaged changes on the same line(s)");
+			case "nothingToSave": return l10n.t("No files to stash");
+			default: return l10n.t("Unable to stash");
+		}
+	}
+};
+var ShowError = class ShowError extends GitCommandError {
+	static is(ex, reason) {
+		return ex instanceof ShowError && (reason == null || ex.details.reason === reason);
+	}
+	buildErrorMessage(details, l10n) {
+		if (details.path && details.rev) switch (details.reason) {
+			case "invalidObject": return l10n.t("Unable to show '{0}' at revision '{1}' because the path is not a file", details.path, details.rev);
+			case "invalidRevision": return l10n.t("Unable to show '{0}' at revision '{1}' because the specified revision is invalid", details.path, details.rev);
+			case "notFound": return l10n.t("Unable to show '{0}' at revision '{1}' because the file does not exist", details.path, details.rev);
+			case "notInRevision": return l10n.t("Unable to show '{0}' at revision '{1}' because the file is not in the specified revision", details.path, details.rev);
+			default: return l10n.t("Unable to show '{0}' at revision '{1}'", details.path, details.rev);
+		}
+		if (details.path) switch (details.reason) {
+			case "invalidObject": return l10n.t("Unable to show '{0}' because the path is not a file", details.path);
+			case "invalidRevision": return l10n.t("Unable to show '{0}' because the specified revision is invalid", details.path);
+			case "notFound": return l10n.t("Unable to show '{0}' because the file does not exist", details.path);
+			case "notInRevision": return l10n.t("Unable to show '{0}' because the file is not in the specified revision", details.path);
+			default: return l10n.t("Unable to show '{0}'", details.path);
+		}
+		if (details.rev) switch (details.reason) {
+			case "invalidObject": return l10n.t("Unable to show file at revision '{0}' because the path is not a file", details.rev);
+			case "invalidRevision": return l10n.t("Unable to show file at revision '{0}' because the specified revision is invalid", details.rev);
+			case "notFound": return l10n.t("Unable to show file at revision '{0}' because the file does not exist", details.rev);
+			case "notInRevision": return l10n.t("Unable to show file at revision '{0}' because the file is not in the specified revision", details.rev);
+			default: return l10n.t("Unable to show file at revision '{0}'", details.rev);
+		}
+		switch (details.reason) {
+			case "invalidObject": return l10n.t("Unable to show file because the path is not a file");
+			case "invalidRevision": return l10n.t("Unable to show file because the specified revision is invalid");
+			case "notFound": return l10n.t("Unable to show file because the file does not exist");
+			case "notInRevision": return l10n.t("Unable to show file because the file is not in the specified revision");
+			default: return l10n.t("Unable to show file");
+		}
+	}
+};
+var TagError = class TagError extends GitCommandError {
+	static is(ex, reason) {
+		return ex instanceof TagError && (reason == null || ex.details.reason === reason);
+	}
+	buildErrorMessage(details, l10n) {
+		const tag = details.tag;
+		const action = details.action;
+		if (!tag) return getMissingTagErrorMessage(action, details.reason, l10n);
+		switch (action) {
+			case "create": switch (details.reason) {
+				case "alreadyExists": return l10n.t("Unable to create tag '{0}' because it already exists", tag);
+				case "invalidName": return l10n.t("Unable to create tag '{0}' because the tag name is invalid", tag);
+				case "notFound": return l10n.t("Unable to create tag '{0}' because it does not exist", tag);
+				case "permissionDenied": return l10n.t("Unable to create tag '{0}' because you don't have permission to push to this remote repository.", tag);
+				case "remoteRejected": return l10n.t("Unable to create tag '{0}' because the remote repository rejected the push.", tag);
+				case "tagConflict": return l10n.t("Unable to create tag '{0}' because the remote already has a tag with that name. Use force to overwrite it.", tag);
+				default: return l10n.t("Unable to create tag '{0}'", tag);
+			}
+			case "delete": switch (details.reason) {
+				case "alreadyExists": return l10n.t("Unable to delete tag '{0}' because it already exists", tag);
+				case "invalidName": return l10n.t("Unable to delete tag '{0}' because the tag name is invalid", tag);
+				case "notFound": return l10n.t("Unable to delete tag '{0}' because it does not exist", tag);
+				case "permissionDenied": return l10n.t("Unable to delete tag '{0}' because you don't have permission to push to this remote repository.", tag);
+				case "remoteRejected": return l10n.t("Unable to delete tag '{0}' because the remote repository rejected the push.", tag);
+				case "tagConflict": return l10n.t("Unable to delete tag '{0}' because the remote already has a tag with that name. Use force to overwrite it.", tag);
+				default: return l10n.t("Unable to delete tag '{0}'", tag);
+			}
+			case "push": switch (details.reason) {
+				case "alreadyExists": return l10n.t("Unable to push tag '{0}' because it already exists", tag);
+				case "invalidName": return l10n.t("Unable to push tag '{0}' because the tag name is invalid", tag);
+				case "notFound": return l10n.t("Unable to push tag '{0}' because it does not exist", tag);
+				case "permissionDenied": return l10n.t("Unable to push tag '{0}' because you don't have permission to push to this remote repository.", tag);
+				case "remoteRejected": return l10n.t("Unable to push tag '{0}' because the remote repository rejected the push.", tag);
+				case "tagConflict": return l10n.t("Unable to push tag '{0}' because the remote already has a tag with that name. Use force to overwrite it.", tag);
+				default: return l10n.t("Unable to push tag '{0}'", tag);
+			}
+			default: return getGenericTagErrorMessage(tag, details.reason, l10n);
+		}
+	}
+};
+function getMissingTagErrorMessage(action, reason, l10n) {
+	switch (action) {
+		case "create": switch (reason) {
+			case "alreadyExists": return l10n.t("Unable to create tag because it already exists");
+			case "invalidName": return l10n.t("Unable to create tag because the tag name is invalid");
+			case "notFound": return l10n.t("Unable to create tag because it does not exist");
+			case "permissionDenied": return l10n.t("Unable to create tag because you don't have permission to push to this remote repository.");
+			case "remoteRejected": return l10n.t("Unable to create tag because the remote repository rejected the push.");
+			case "tagConflict": return l10n.t("Unable to create tag because the remote already has a tag with that name. Use force to overwrite it.");
+			default: return l10n.t("Unable to create tag");
+		}
+		case "delete": switch (reason) {
+			case "alreadyExists": return l10n.t("Unable to delete tag because it already exists");
+			case "invalidName": return l10n.t("Unable to delete tag because the tag name is invalid");
+			case "notFound": return l10n.t("Unable to delete tag because it does not exist");
+			case "permissionDenied": return l10n.t("Unable to delete tag because you don't have permission to push to this remote repository.");
+			case "remoteRejected": return l10n.t("Unable to delete tag because the remote repository rejected the push.");
+			case "tagConflict": return l10n.t("Unable to delete tag because the remote already has a tag with that name. Use force to overwrite it.");
+			default: return l10n.t("Unable to delete tag");
+		}
+		case "push": switch (reason) {
+			case "alreadyExists": return l10n.t("Unable to push tag because it already exists");
+			case "invalidName": return l10n.t("Unable to push tag because the tag name is invalid");
+			case "notFound": return l10n.t("Unable to push tag because it does not exist");
+			case "permissionDenied": return l10n.t("Unable to push tag because you don't have permission to push to this remote repository.");
+			case "remoteRejected": return l10n.t("Unable to push tag because the remote repository rejected the push.");
+			case "tagConflict": return l10n.t("Unable to push tag because the remote already has a tag with that name. Use force to overwrite it.");
+			default: return l10n.t("Unable to push tag");
+		}
+		default: switch (reason) {
+			case "alreadyExists": return l10n.t("Unable to perform action on tag because it already exists");
+			case "invalidName": return l10n.t("Unable to perform action on tag because the tag name is invalid");
+			case "notFound": return l10n.t("Unable to perform action on tag because it does not exist");
+			case "permissionDenied": return l10n.t("Unable to perform action on tag because you don't have permission to push to this remote repository.");
+			case "remoteRejected": return l10n.t("Unable to perform action on tag because the remote repository rejected the push.");
+			case "tagConflict": return l10n.t("Unable to perform action on tag because the remote already has a tag with that name. Use force to overwrite it.");
+			default: return l10n.t("Unable to perform action on tag");
+		}
+	}
 }
-export class SigningError extends GitCommandError {
-    static is(ex, reason) {
-        return ex instanceof SigningError && (reason == null || ex.details.reason === reason);
-    }
-    constructor(details, original) {
-        super('Unable to sign commit', details, original);
-    }
-    buildErrorMessage(details) {
-        const baseMessage = 'Unable to sign commit';
-        switch (details.reason) {
-            case 'noKey':
-                return `${baseMessage} because no signing key is configured`;
-            case 'gpgNotFound':
-                return `${baseMessage} because GPG program was not found`;
-            case 'sshNotFound':
-                return `${baseMessage} because SSH program was not found`;
-            case 'passphraseFailed':
-                return `${baseMessage} because GPG passphrase failed or was cancelled`;
-            default:
-                return baseMessage;
-        }
-    }
+function getGenericTagErrorMessage(tag, reason, l10n) {
+	switch (reason) {
+		case "alreadyExists": return l10n.t("Unable to perform action with tag '{0}' because it already exists", tag);
+		case "invalidName": return l10n.t("Unable to perform action with tag '{0}' because the tag name is invalid", tag);
+		case "notFound": return l10n.t("Unable to perform action with tag '{0}' because it does not exist", tag);
+		case "permissionDenied": return l10n.t("Unable to perform action with tag '{0}' because you don't have permission to push to this remote repository.", tag);
+		case "remoteRejected": return l10n.t("Unable to perform action with tag '{0}' because the remote repository rejected the push.", tag);
+		case "tagConflict": return l10n.t("Unable to perform action with tag '{0}' because the remote already has a tag with that name. Use force to overwrite it.", tag);
+		default: return l10n.t("Unable to perform action with tag '{0}'", tag);
+	}
 }
+var WorkspaceUntrustedError = class WorkspaceUntrustedError extends Error {
+	static is(ex) {
+		return ex instanceof WorkspaceUntrustedError;
+	}
+	constructor() {
+		super(l10n.t("Unable to perform Git operations because the current workspace is untrusted"));
+		Error.captureStackTrace?.(this, new.target);
+	}
+};
+var WorktreeCreateError = class WorktreeCreateError extends GitCommandError {
+	static is(ex, reason) {
+		return ex instanceof WorktreeCreateError && (reason == null || ex.details.reason === reason);
+	}
+	buildErrorMessage(details, l10n) {
+		switch (details.reason) {
+			case "alreadyCheckedOut": return l10n.t("Unable to create worktree because it is already checked out");
+			case "alreadyExists": return l10n.t("Unable to create worktree because it already exists");
+			default: return l10n.t("Unable to create worktree");
+		}
+	}
+};
+var WorktreeDeleteError = class WorktreeDeleteError extends GitCommandError {
+	static is(ex, reason) {
+		return ex instanceof WorktreeDeleteError && (reason == null || ex.details.reason === reason);
+	}
+	buildErrorMessage(details, l10n) {
+		switch (details.reason) {
+			case "defaultWorkingTree": return l10n.t("Cannot delete worktree because it is the default working tree");
+			case "directoryNotEmpty": return l10n.t("Unable to delete worktree because the directory is not empty");
+			case "locked": return l10n.t("Unable to delete worktree because it is locked");
+			case "uncommittedChanges": return l10n.t("Unable to delete worktree because there are uncommitted changes");
+			default: return l10n.t("Unable to delete worktree");
+		}
+	}
+};
+let AuthenticationErrorReason = /* @__PURE__ */ function(AuthenticationErrorReason) {
+	AuthenticationErrorReason[AuthenticationErrorReason["UserDidNotConsent"] = 1] = "UserDidNotConsent";
+	AuthenticationErrorReason[AuthenticationErrorReason["Unauthorized"] = 2] = "Unauthorized";
+	AuthenticationErrorReason[AuthenticationErrorReason["Forbidden"] = 3] = "Forbidden";
+	return AuthenticationErrorReason;
+}({});
+var AuthenticationError = class AuthenticationError extends Error {
+	id;
+	original;
+	reason;
+	authInfo;
+	constructor(info, messageOrReason, original) {
+		const { providerId: id, type, cloud, scopes, expiresAt } = info;
+		const authInfo = `(token details: ${[
+			cloud ? "cloud" : "self-managed",
+			type,
+			info.microHash,
+			expiresAt && `expiresAt=${isNaN(expiresAt.getTime()) ? expiresAt.toString() : expiresAt.toISOString()}`,
+			scopes && `[${scopes.join(",")}]`
+		].filter((v) => v).join(", ")})`;
+		let message;
+		let reason;
+		if (messageOrReason == null) message = l10n.t("Unable to get required authentication session for '{0}'", id);
+		else if (typeof messageOrReason === "string") {
+			message = messageOrReason;
+			reason = void 0;
+		} else {
+			reason = messageOrReason;
+			switch (reason) {
+				case 1:
+					message = l10n.t("'{0}' authentication is required for this operation", id);
+					break;
+				case 2:
+					message = l10n.t("Your '{0}' credentials are either invalid or expired", id);
+					break;
+				case 3: message = l10n.t("Your '{0}' credentials do not have the required access", id);
+			}
+		}
+		super(message);
+		this.id = id;
+		this.original = original;
+		this.reason = reason;
+		this.authInfo = authInfo;
+		Error.captureStackTrace?.(this, new.target);
+	}
+	static is(ex) {
+		return ex instanceof AuthenticationError;
+	}
+	toString() {
+		return `${super.toString()} ${this.authInfo}`;
+	}
+};
+var RequestClientError = class RequestClientError extends Error {
+	original;
+	static is(ex) {
+		return ex instanceof RequestClientError;
+	}
+	constructor(original) {
+		super(original.message);
+		this.original = original;
+		Error.captureStackTrace?.(this, new.target);
+	}
+};
+var RequestNotFoundError = class RequestNotFoundError extends Error {
+	original;
+	static is(ex) {
+		return ex instanceof RequestNotFoundError;
+	}
+	constructor(original) {
+		super(original.message);
+		this.original = original;
+		Error.captureStackTrace?.(this, new.target);
+	}
+};
+var RequestRateLimitError = class RequestRateLimitError extends Error {
+	original;
+	token;
+	resetAt;
+	static is(ex) {
+		return ex instanceof RequestRateLimitError;
+	}
+	constructor(original, token, resetAt) {
+		super(original.message);
+		this.original = original;
+		this.token = token;
+		this.resetAt = resetAt;
+		Error.captureStackTrace?.(this, new.target);
+	}
+};
+var SigningError = class SigningError extends GitCommandError {
+	static is(ex, reason) {
+		return ex instanceof SigningError && (reason == null || ex.details.reason === reason);
+	}
+	buildErrorMessage(details, l10n) {
+		switch (details.reason) {
+			case "noKey": return l10n.t("Unable to sign commit because no signing key is configured");
+			case "gpgNotFound": return l10n.t("Unable to sign commit because GPG program was not found");
+			case "sshNotFound": return l10n.t("Unable to sign commit because SSH program was not found");
+			case "passphraseFailed": return l10n.t("Unable to sign commit because GPG passphrase failed or was cancelled");
+			default: return l10n.t("Unable to sign commit");
+		}
+	}
+};
+//#endregion
+export { ApplyPatchCommitError, AuthenticationError, AuthenticationErrorReason, BlameIgnoreRevsFileBadRevisionError, BlameIgnoreRevsFileError, BranchError, CheckoutError, CherryPickError, CommitError, FetchError, GitCommandError, GitSearchError, GitWarnings, MergeError, PausedOperationAbortError, PausedOperationContinueError, PullError, PushError, RebaseError, RequestClientError, RequestNotFoundError, RequestRateLimitError, ResetError, RevertError, ShowError, SigningError, StashApplyError, StashPushError, TagError, WorkspaceUntrustedError, WorktreeCreateError, WorktreeDeleteError };
+
 //# sourceMappingURL=errors.js.map