@gitkraken/core-gitlens 0.2.0 → 0.3.0

package/src/plus/git-github/providers/github/tags.ts

@@ -33,72 +33,71 @@ export class TagsGitSubProvider implements GitTagsSubProvider {
 	): Promise<PagedResult<GitTag>> {
 		if (repoPath == null) return emptyPagedResult;
 
+		const path = repoPath;
+
 		const scope = getScopedLogger();
 
-		const tagsPromise = options?.paging?.cursor
-			? undefined
-			: this.cache.tags.getOrCreate(
-					repoPath,
-					async cancellable => {
-						try {
-							const { metadata, github, session } = await this.provider.ensureRepositoryContext(repoPath);
-
-							const tags: GitTag[] = [];
-
-							let cursor = options?.paging?.cursor;
-							const loadAll = cursor == null;
-
-							let authoredDate;
-							let committedDate;
-
-							while (true) {
-								const result = await github.getTags(
-									toTokenInfo(this.provider.authenticationProviderId, session),
-									metadata.repo.owner,
-									metadata.repo.name,
-									{ cursor: cursor },
-								);
-
-								for (const tag of result.values) {
-									authoredDate =
-										tag.target.authoredDate ??
-										tag.target.target?.authoredDate ??
-										tag.target.tagger?.date;
-									committedDate =
-										tag.target.committedDate ??
-										tag.target.target?.committedDate ??
-										tag.target.tagger?.date;
-
-									tags.push(
-										new GitTag(
-											repoPath,
-											tag.name,
-											tag.target.target?.oid ?? tag.target.oid,
-											tag.target.message ?? tag.target.target?.message ?? '',
-											authoredDate != null ? new Date(authoredDate) : undefined,
-											committedDate != null ? new Date(committedDate) : undefined,
-										),
-									);
-								}
-
-								if (!result.paging?.more || !loadAll) return { ...result, values: tags };
-
-								cursor = result.paging.cursor;
-							}
-						} catch (ex) {
-							cancellable.invalidate();
-							scope?.error(ex);
-							debugger;
-
-							return emptyPagedResult;
+		// Compose cache key with cursor so re-loads of the same page hit the cache;
+		// `repoPath` (no suffix) is reserved for the full "all tags" entry.
+		// TODO: `cache.tags` is `PromiseMap<RepoPath, ...>` keyed exactly by repoPath, so
+		// `clearCaches('tags')` / `unregisterRepoPath` will not invalidate composite-key entries.
+		// Acceptable today because tags rarely move during a virtual-repo session, but the entries
+		// leak in memory until provider GC. Long-term: switch to RepoPromiseCacheMap or add prefix-invalidate.
+		const cacheKey = options?.paging?.cursor != null ? `${path}#${options.paging.cursor}` : path;
+		const tagsPromise = this.cache.tags.getOrCreate(
+			cacheKey,
+			async cancellable => {
+				try {
+					const { metadata, github, session } = await this.provider.ensureRepositoryContext(path);
+
+					const tags: GitTag[] = [];
+
+					let cursor = options?.paging?.cursor;
+					const loadAll = cursor == null;
+
+					let authoredDate;
+					let committedDate;
+
+					while (true) {
+						const result = await github.getTags(
+							toTokenInfo(this.provider.authenticationProviderId, session),
+							metadata.repo.owner,
+							metadata.repo.name,
+							{ cursor: cursor },
+						);
+
+						for (const tag of result.values) {
+							authoredDate =
+								tag.target.authoredDate ?? tag.target.target?.authoredDate ?? tag.target.tagger?.date;
+							committedDate =
+								tag.target.committedDate ?? tag.target.target?.committedDate ?? tag.target.tagger?.date;
+
+							tags.push(
+								new GitTag(
+									path,
+									tag.name,
+									tag.target.target?.oid ?? tag.target.oid,
+									tag.target.message ?? tag.target.target?.message ?? '',
+									authoredDate != null ? new Date(authoredDate) : undefined,
+									committedDate != null ? new Date(committedDate) : undefined,
+								),
+							);
 						}
-					},
-					cancellation,
-				);
 
-		if (tagsPromise == null) {
-			return emptyPagedResult;
-		}
+						if (!result.paging?.more || !loadAll) return { ...result, values: tags };
+
+						cursor = result.paging.cursor;
+					}
+				} catch (ex) {
+					cancellable.invalidate();
+					scope?.error(ex);
+					debugger;
+
+					return emptyPagedResult;
+				}
+			},
+			cancellation,
+		);
 
 		let result = await tagsPromise;
 		if (options?.filter != null) {

package/src/plus/git-github/providers/githubGitProvider.ts

@@ -152,6 +152,7 @@ export class GitHubGitProvider implements GitHubGitProviderInternal, GitProvider
 
 	getPagingLimit(limit?: number): number {
 		if (limit === 0) return 0;
+
 		limit = Math.min(limit ?? this.context.config?.paging?.limit ?? 100, 100);
 		if (limit !== 0 && limit < 100) {
 			limit = Math.max(limit, 1);

package/src/utils/color.ts

@@ -568,6 +568,7 @@ export class Color {
 		if (of.isLighterThan(relative)) {
 			return of;
 		}
+
 		factor = factor ? factor : 0.5;
 		const lum1 = of.getRelativeLuminance();
 		const lum2 = relative.getRelativeLuminance();
@@ -579,6 +580,7 @@ export class Color {
 		if (of.isDarkerThan(relative)) {
 			return of;
 		}
+
 		factor = factor ? factor : 0.5;
 		const lum1 = of.getRelativeLuminance();
 		const lum2 = relative.getRelativeLuminance();

package/src/utils/decorators/serializable.ts

@@ -18,6 +18,7 @@ export function serializable(target: Function): void {
 	while (proto != null && proto !== Object.prototype) {
 		for (const key of Object.getOwnPropertyNames(proto)) {
 			if (key === 'constructor') continue;
+
 			const desc = Object.getOwnPropertyDescriptor(proto, key);
 			if (desc?.get != null) {
 				getterKeys.add(key);

package/src/utils/dedupedAsyncCache.ts

@@ -0,0 +1,74 @@
+/**
+ * Per-key cache for async resolution that dedupes concurrent first-time callers and caches the
+ * resolved value (including `undefined`) for subsequent reads.
+ *
+ * Two internal Maps drive the semantics:
+ * - `_resolved` holds settled values. `has(key)` distinguishes a cached `undefined` from "never
+ *   resolved", so callers can intentionally cache "no result" without re-running the resolver.
+ * - `_resolving` holds in-flight Promises. While a key resolves, concurrent `getOrResolve` callers
+ *   share the same Promise instead of each invoking the resolver.
+ *
+ * Failed resolutions do not poison the cache — the entry is removed when the in-flight Promise
+ * rejects, so the next call retries.
+ */
+export class DedupedAsyncCache<K, V> {
+	private readonly _resolved = new Map<K, V>();
+	private readonly _resolving = new Map<K, Promise<V>>();
+
+	/** True iff `key` has a settled value cached. Distinct from "currently resolving". */
+	has(key: K): boolean {
+		return this._resolved.has(key);
+	}
+
+	/** Settled value for `key`, or `undefined` when not yet cached. May also legitimately return
+	 *  `undefined` for a key whose cached value is `undefined`; use `has` to disambiguate. */
+	get(key: K): V | undefined {
+		return this._resolved.get(key);
+	}
+
+	/** Populates the cache directly, bypassing the resolver. Used by callers that already know the
+	 *  value (e.g. event payloads, post-write reconciles) and want subsequent reads to hit. */
+	set(key: K, value: V): void {
+		this._resolved.set(key, value);
+	}
+
+	/** Removes both the settled value and any in-flight Promise for `key`. */
+	delete(key: K): void {
+		this._resolved.delete(key);
+		this._resolving.delete(key);
+	}
+
+	/** Clears everything — both settled values and in-flight Promises. */
+	clear(): void {
+		this._resolved.clear();
+		this._resolving.clear();
+	}
+
+	/**
+	 * Returns the cached value for `key`, invoking `resolver` only on a cache miss. Concurrent
+	 * cache-miss callers for the same key share the same in-flight Promise — `resolver` is invoked
+	 * exactly once per cache fill. If `resolver` rejects, the entry is removed so subsequent calls
+	 * retry rather than receiving a permanently cached failure.
+	 */
+	getOrResolve(key: K, resolver: () => Promise<V>): Promise<V> {
+		if (this._resolved.has(key)) {
+			// Map.get returns `V | undefined`; `has` confirmed presence, so the value (even if it
+			// is `undefined` by intent) is the cached one. Cast pins the return type.
+			return Promise.resolve(this._resolved.get(key) as V);
+		}
+
+		const existing = this._resolving.get(key);
+		if (existing != null) return existing;
+
+		const pending = resolver()
+			.then(value => {
+				this._resolved.set(key, value);
+				return value;
+			})
+			.finally(() => {
+				this._resolving.delete(key);
+			});
+		this._resolving.set(key, pending);
+		return pending;
+	}
+}

package/src/utils/diff.ts

@@ -0,0 +1,61 @@
+// Annotates diff to make is easier for agentic reference to line number.
+// Brackets sit AFTER the line-type marker so file-level diff parsers
+// (e.g. `filterDiffFiles`) that key off `diff --git` / `+++` / `---` headers still work.
+export function annotateDiffWithNewLineNumbers(diff: string): string {
+	if (!diff) return diff;
+
+	const lines = diff.split('\n');
+	const out: string[] = new Array(lines.length);
+	let newLine = 0;
+	let inHunk = false;
+
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+
+		if (line.startsWith('@@')) {
+			const match = /\+(\d+)(?:,\d+)?\s/.exec(line);
+			newLine = match != null ? parseInt(match[1], 10) : 0;
+			inHunk = true;
+			out[i] = line;
+			continue;
+		}
+
+		if (
+			line.startsWith('diff --git') ||
+			line.startsWith('index ') ||
+			line.startsWith('--- ') ||
+			line.startsWith('+++ ') ||
+			line.startsWith('new file') ||
+			line.startsWith('deleted file') ||
+			line.startsWith('rename ') ||
+			line.startsWith('copy ') ||
+			line.startsWith('similarity ') ||
+			line.startsWith('dissimilarity ') ||
+			line.startsWith('Binary files')
+		) {
+			inHunk = false;
+			out[i] = line;
+			continue;
+		}
+
+		if (!inHunk || line.startsWith('\\')) {
+			out[i] = line;
+			continue;
+		}
+
+		const marker = line[0];
+		if (marker === '-') {
+			out[i] = `-[     ]${line.slice(1)}`;
+			continue;
+		}
+		if (marker === '+' || marker === ' ') {
+			out[i] = `${marker}[${String(newLine).padStart(5, ' ')}]${line.slice(1)}`;
+			newLine++;
+			continue;
+		}
+
+		out[i] = line;
+	}
+
+	return out.join('\n');
+}

package/src/utils/disposable.ts

@@ -13,6 +13,7 @@ export function createDisposable(
 	options?: { once?: boolean },
 ): UnifiedDisposable | undefined {
 	if (dispose == null) return undefined;
+
 	if (options?.once) {
 		dispose = once(dispose);
 	}
@@ -61,6 +62,7 @@ export function fromDisposables(
 	let disposed = false;
 	const dispose = () => {
 		if (disposed) return;
+
 		disposed = true;
 
 		for (const d of disposables) {

package/src/utils/env/node/exec.ts

@@ -287,6 +287,7 @@ export function run<T extends number | string>(
 								`Non-UTF-8 encoding '${encoding}' requested but no decode function configured`,
 							);
 						}
+
 						stdoutDecoded = await decode(
 							Buffer.from(stdout, 'binary'),
 							encoding ? { encoding: encoding } : undefined,
@@ -311,6 +312,7 @@ export function run<T extends number | string>(
 					if (decode == null) {
 						throw new Error(`Non-UTF-8 encoding '${encoding}' requested but no decode function configured`);
 					}
+
 					resolve(
 						(await decode(
 							Buffer.from(stdout, 'binary'),

package/src/utils/error.ts

@@ -7,6 +7,7 @@
 export function isErrorLike(v: unknown): v is { name: string; message: string; stack?: string } {
 	if (v == null || typeof v !== 'object') return false;
 	if (v instanceof Error) return true;
+
 	const o = v as { name?: unknown; message?: unknown };
 	return typeof o.name === 'string' && typeof o.message === 'string';
 }

package/src/utils/iterable.ts

@@ -269,6 +269,7 @@ export function findIndex<T>(source: Iterable<T> | IterableIterator<T>, predicat
 	let i = 0;
 	for (const item of source) {
 		if (predicate(item)) return i;
+
 		i++;
 	}
 	return -1;
@@ -329,6 +330,7 @@ class FlatMapIterator<T, TMapped> implements IterableIterator<TMapped> {
 				if (!mappedResult.done) {
 					return { done: false, value: mappedResult.value };
 				}
+
 				// Current mapped iterator is exhausted, move to next source item
 				this.currentMappedIterator = undefined;
 			}
@@ -576,6 +578,7 @@ class SkipIterator<T> implements IterableIterator<T> {
 				this.done = true;
 				return { done: true, value: undefined };
 			}
+
 			this.skipped++;
 		}
 

package/src/utils/logger.ts

@@ -364,6 +364,7 @@ export function getLoggableName(instance: object): string {
 		if (customNameFn != null) {
 			return customNameFn(instance, name);
 		}
+
 		proto = Object.getPrototypeOf(proto);
 	}
 

package/src/utils/lruMap.ts

@@ -14,9 +14,24 @@
  */
 export class LruMap<K, V> {
 	private readonly _map = new Map<K, V>();
+	private readonly _pinned = new Set<K>();
 
 	constructor(private readonly limit: number) {}
 
+	/**
+	 * Pin a key so it's never evicted by capacity pressure (it can still be explicitly
+	 * `delete`d / `clear`ed). Use for entries that must stay available regardless of how many
+	 * other keys churn — e.g. the selected repo's WIP, which the header badge derives from.
+	 * Pinning a key not yet present is fine; it takes effect once the key is `set`.
+	 */
+	pin(key: K): void {
+		this._pinned.add(key);
+	}
+
+	unpin(key: K): void {
+		this._pinned.delete(key);
+	}
+
 	get size(): number {
 		return this._map.size;
 	}
@@ -55,6 +70,7 @@ export class LruMap<K, V> {
 	 */
 	touch(key: K): boolean {
 		if (!this._map.has(key)) return false;
+
 		const value = this._map.get(key) as V;
 		this._map.delete(key);
 		this._map.set(key, value);
@@ -67,6 +83,9 @@ export class LruMap<K, V> {
 
 	clear(): void {
 		this._map.clear();
+		// Drop pins too — a cleared map has no entries to protect, and leaving stale pins would
+		// wrongly shield the NEXT value set under a previously-pinned key from eviction.
+		this._pinned.clear();
 	}
 
 	keys(): IterableIterator<K> {
@@ -78,10 +97,16 @@ export class LruMap<K, V> {
 	}
 
 	private evict(): void {
-		while (this._map.size > this.limit) {
-			const oldest = this._map.keys().next().value;
-			if (oldest === undefined) break;
-			this._map.delete(oldest);
+		if (this._map.size <= this.limit) return;
+
+		// Iterate oldest-first, deleting the first non-pinned keys until back at capacity.
+		// Pinned keys are skipped — if everything is pinned the map can exceed `limit`, which
+		// is the intended trade-off (pins are deliberate and few).
+		for (const key of this._map.keys()) {
+			if (this._map.size <= this.limit) break;
+			if (this._pinned.has(key)) continue;
+
+			this._map.delete(key);
 		}
 	}
 }

package/src/utils/markdown.ts

@@ -88,6 +88,7 @@ export function escapeMarkdownCodeBlocks(s: string): string {
 			i += 2;
 			continue;
 		}
+
 		if (quotesOpened) {
 			buffer += char;
 		} else {

package/src/utils/mru.ts

@@ -55,9 +55,11 @@ export class MRU<T> {
 
 		if (direction === 'back') {
 			if (this._position >= this.stack.length - 1) return undefined;
+
 			this._position += 1;
 		} else {
 			if (this._position <= 0) return undefined;
+
 			this._position -= 1;
 		}
 

package/src/utils/path.ts

@@ -25,6 +25,7 @@ export function commonBase(s: string[], delimiter: string, ignoreCase?: boolean)
 	for (let i = 1; i < s.length; i++) {
 		const index = commonBaseIndex(common, s[i], delimiter, ignoreCase);
 		if (index === 0) return undefined;
+
 		common = common.substring(0, index + 1);
 	}
 

package/src/utils/promise.ts

@@ -143,6 +143,7 @@ export function cancellable<T>(
 				resolver('cancelled');
 				return;
 			}
+
 			const handler = () => resolver('cancelled');
 			cancellation.addEventListener('abort', handler);
 			disposeCancellation = { dispose: () => cancellation.removeEventListener('abort', handler) };
@@ -156,6 +157,7 @@ export function cancellable<T>(
 					resolver('timedout');
 					return;
 				}
+
 				const handler = () => resolver('timedout');
 				timeout.addEventListener('abort', handler);
 				disposeTimeout = { dispose: () => timeout.removeEventListener('abort', handler) };
@@ -588,3 +590,23 @@ export function wait(ms: number): Promise<void> {
 export function waitUntilNextTick(): Promise<void> {
 	return new Promise<void>(resolve => queueMicrotask(resolve));
 }
+
+const _schedulerYield = (
+	globalThis as unknown as { scheduler?: { yield?: () => Promise<void> } }
+).scheduler?.yield?.bind((globalThis as any).scheduler);
+const _raf =
+	typeof (globalThis as any).requestAnimationFrame === 'function'
+		? (globalThis as unknown as { requestAnimationFrame?: (callback: (time: number) => void) => number })
+				.requestAnimationFrame
+		: undefined;
+
+export async function yieldToScheduler(): Promise<void> {
+	if (_schedulerYield != null) {
+		await _schedulerYield();
+	} else if (_raf != null) {
+		await new Promise(r => _raf(r));
+	} else {
+		// Node fallback
+		await new Promise(r => setTimeout(r, 0));
+	}
+}

package/src/utils/promiseCache.ts

@@ -97,6 +97,7 @@ export class PromiseCache<K, V> {
 		if (entry == null || this.expired(entry, now)) {
 			return undefined;
 		}
+
 		// Update accessed time
 		entry.accessed = now;
 		return entry.promise;
@@ -686,6 +687,29 @@ export class RepoPromiseCacheMap<K, V> {
 		return deleted;
 	}
 
+	/**
+	 * Invalidates all keys matching a prefix from a repository's cache. See `PromiseCache.invalidate`
+	 * for semantics — in-flight entries are marked invalidated and shared with new callers; settled
+	 * entries are hard-deleted. Prefer over `deleteByKeyPrefix` when the eviction is a "data has
+	 * changed" event and in-flight factories' results would still be valid for current waiters.
+	 * @param repoPath - The repository path
+	 * @param prefix - Key prefix to match
+	 * @returns true if something was invalidated
+	 */
+	invalidateByKeyPrefix(this: RepoPromiseCacheMap<string, V>, repoPath: string, prefix: string): boolean {
+		const repoCache = this.cache.get(repoPath);
+		if (repoCache == null) return false;
+
+		let invalidated = false;
+		for (const key of repoCache.keys()) {
+			if (key.startsWith(prefix)) {
+				repoCache.invalidate(key);
+				invalidated = true;
+			}
+		}
+		return invalidated;
+	}
+
 	/**
 	 * Clears all caches for all repositories.
 	 */

package/src/utils/string.ts

@@ -518,6 +518,7 @@ class IterableDelimiterIterator implements IterableIterator<string> {
 						this.done = true;
 						return { done: false, value: value };
 					}
+
 					this.done = true;
 					return { done: true, value: undefined };
 				}
@@ -631,6 +632,7 @@ class AsyncIterableDelimiterIterator implements AsyncIterableIterator<string> {
 					this.done = true;
 					return { done: false, value: value };
 				}
+
 				this.done = true;
 				return { done: true, value: undefined };
 			}

package/src/utils/uri.ts

@@ -105,6 +105,7 @@ export function reviveUri(data: UriComponents): Uri {
 export function getRepositoryKey(pathOrUri: string | Uri): string {
 	if (typeof pathOrUri === 'string') {
 		if (!hasScheme(pathOrUri)) return normalizePath(pathOrUri);
+
 		// Parse URI strings so file: URIs get normalized to fsPath
 		pathOrUri = URI.parse(pathOrUri);
 	}

package/src/utils/version.ts

@@ -96,6 +96,7 @@ export function compareByVersion(a: string, b: string): number {
 		} else {
 			// Compare non-digit characters lexicographically
 			if (ca !== cb) return ca - cb;
+
 			i++;
 			j++;
 		}

package/dist/git/exec.types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"exec.types.d.ts","sourceRoot":"","sources":["../../src/git/exec.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAEtE,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,QAAQ,CAAC;AAElD,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,IAAI;IACrE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IACnB,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IAEpB,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC9B,WAAW,CACV,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,CAAC,SAAS,EAAE,eAAe,KAAK,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,EACpE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAClD,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC;CAC/B;AAED;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,aAAa,GAAG,QAAQ,GAAG,YAAY,CAAC;AAEzE,MAAM,WAAW,cAAc;IAC9B,YAAY,CAAC,EAAE,WAAW,CAAC;IAC3B,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,mGAAmG;IACnG,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B,0GAA0G;IAC1G,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;;OAGG;IACH,OAAO,CAAC,EAAE;QACT,KAAK,EAAE,cAAc,CAAC;QACtB,gGAAgG;QAChG,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,OAAO,CAAC,EAAE;YAAE,SAAS,CAAC,EAAE,MAAM,CAAC;YAAC,SAAS,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;KACrD,CAAC;IAGF,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAClD,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,GAAG,QAAQ,GAAG,MAAM,CAAC;IACvD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACjC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAEhC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,eAAe;IAC/B,YAAY,CAAC,EAAE,WAAW,CAAC;IAC3B,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAG5B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAClD,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,GAAG,QAAQ,GAAG,MAAM,CAAC;IACvD,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACjC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAEhC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC1B"}

package/dist/git/exec.types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=exec.types.js.map

package/dist/git/exec.types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"exec.types.js","sourceRoot":"","sources":["../../src/git/exec.types.ts"],"names":[],"mappings":""}