@gitkraken/core-gitlens 0.6.0 → 0.7.0

package/dist/git-cli/parsers/logParser.js

@@ -1,1254 +1,1053 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { diffHunkRegex, diffRegex } from '../../git/parsers/diffParser.js';
-import { joinPaths, normalizePath } from '../../utils/path.js';
-import { maybeStopWatch } from '../../utils/stopwatch.js';
-import { flattenString, iterateAsyncByDelimiter, iterateByDelimiter } from '../../utils/string.js';
+import { flattenString, iterateAsyncByDelimiter, iterateByDelimiter } from "../../utils/string.js";
+import { joinPaths, normalizePath } from "../../utils/path.js";
+import { maybeStopWatch } from "../../utils/stopwatch.js";
+import _usingCtx from "../../_virtual/@oxc-project+runtime/helpers/esm/usingCtx.js";
+import { diffHunkRegex, diffRegex } from "../../git/parsers/diffParser.js";
+//#region ../git-cli/src/parsers/logParser.ts
 const commitsMapping = {
-    sha: '%H',
-    author: '%aN',
-    authorEmail: '%aE',
-    authorDate: '%at',
-    committer: '%cN',
-    committerEmail: '%cE',
-    committerDate: '%ct',
-    parents: '%P',
-    tips: '%D',
-    message: '%B',
+	sha: "%H",
+	author: "%aN",
+	authorEmail: "%aE",
+	authorDate: "%at",
+	committer: "%cN",
+	committerEmail: "%cE",
+	committerDate: "%ct",
+	parents: "%P",
+	tips: "%D",
+	message: "%B"
 };
 let _commitsParser;
 let _commitsWithFilesParser;
 let _commitsInFileRangeParser;
-export function getCommitsLogParser(includeFiles, inFileRange) {
-    if (inFileRange) {
-        _commitsInFileRangeParser ??= createLogParserWithPatch(commitsMapping);
-        return _commitsInFileRangeParser;
-    }
-    if (includeFiles) {
-        _commitsWithFilesParser ??= createLogParserWithFilesAndStats(commitsMapping);
-        return _commitsWithFilesParser;
-    }
-    _commitsParser ??= createLogParser(commitsMapping);
-    return _commitsParser;
+function getCommitsLogParser(includeFiles, inFileRange) {
+	if (inFileRange) {
+		_commitsInFileRangeParser ??= createLogParserWithPatch(commitsMapping);
+		return _commitsInFileRangeParser;
+	}
+	if (includeFiles) {
+		_commitsWithFilesParser ??= createLogParserWithFilesAndStats(commitsMapping);
+		return _commitsWithFilesParser;
+	}
+	_commitsParser ??= createLogParser(commitsMapping);
+	return _commitsParser;
 }
-const contributorsMapping = { sha: '%H', author: '%aN', email: '%aE', date: '%at', message: '%B' };
+const contributorsMapping = {
+	sha: "%H",
+	author: "%aN",
+	email: "%aE",
+	date: "%at",
+	message: "%B"
+};
 let _contributorsParser;
 let _contributorsWithStatsParser;
-export function getContributorsLogParser(stats) {
-    if (stats) {
-        _contributorsWithStatsParser ??= createLogParserWithStats(contributorsMapping);
-        return _contributorsWithStatsParser;
-    }
-    _contributorsParser ??= createLogParser(contributorsMapping);
-    return _contributorsParser;
+function getContributorsLogParser(stats) {
+	if (stats) {
+		_contributorsWithStatsParser ??= createLogParserWithStats(contributorsMapping);
+		return _contributorsWithStatsParser;
+	}
+	_contributorsParser ??= createLogParser(contributorsMapping);
+	return _contributorsParser;
 }
 const graphMapping = {
-    sha: '%H',
-    author: '%aN',
-    authorEmail: '%aE',
-    authorDate: '%at',
-    committerDate: '%ct',
-    parents: '%P',
-    tips: '%D',
-    message: '%B',
+	sha: "%H",
+	author: "%aN",
+	authorEmail: "%aE",
+	authorDate: "%at",
+	committerDate: "%ct",
+	parents: "%P",
+	tips: "%D",
+	message: "%B"
 };
 let _graphParser;
 let _graphWithStatsParser;
-export function getGraphParser(stats) {
-    if (stats) {
-        _graphWithStatsParser ??= createLogParserWithStats(graphMapping);
-        return _graphWithStatsParser;
-    }
-    _graphParser ??= createLogParser(graphMapping);
-    return _graphParser;
+function getGraphParser(stats) {
+	if (stats) {
+		_graphWithStatsParser ??= createLogParserWithStats(graphMapping);
+		return _graphWithStatsParser;
+	}
+	_graphParser ??= createLogParser(graphMapping);
+	return _graphParser;
 }
 let _shaParser;
-export function getShaLogParser() {
-    _shaParser ??= createLogParserSingle('%H');
-    return _shaParser;
+function getShaLogParser() {
+	_shaParser ??= createLogParserSingle("%H");
+	return _shaParser;
 }
-const shaAndDateMapping = { sha: '%H', authorDate: '%at', committerDate: '%ct' };
-const shaAndDateAndTipsMapping = { sha: '%H', authorDate: '%at', committerDate: '%ct', tips: '%D' };
+const shaAndDateMapping = {
+	sha: "%H",
+	authorDate: "%at",
+	committerDate: "%ct"
+};
+const shaAndDateAndTipsMapping = {
+	sha: "%H",
+	authorDate: "%at",
+	committerDate: "%ct",
+	tips: "%D"
+};
 let _shaAndDatesParser;
 let _shaAndDatesAndTipsParser;
-export function getShaAndDatesLogParser(includeTips) {
-    if (includeTips) {
-        _shaAndDatesAndTipsParser ??= createLogParser(shaAndDateAndTipsMapping);
-        return _shaAndDatesAndTipsParser;
-    }
-    _shaAndDatesParser ??= createLogParser(shaAndDateMapping);
-    return _shaAndDatesParser;
+function getShaAndDatesLogParser(includeTips) {
+	if (includeTips) {
+		_shaAndDatesAndTipsParser ??= createLogParser(shaAndDateAndTipsMapping);
+		return _shaAndDatesAndTipsParser;
+	}
+	_shaAndDatesParser ??= createLogParser(shaAndDateMapping);
+	return _shaAndDatesParser;
 }
 let _shaAndDatesWithFilesParser;
 let _shaAndDatesAndTipsWithFilesParser;
-export function getShaAndDatesWithFilesLogParser(includeTips) {
-    if (includeTips) {
-        _shaAndDatesAndTipsWithFilesParser ??= createLogParserWithFiles(shaAndDateAndTipsMapping);
-        return _shaAndDatesAndTipsWithFilesParser;
-    }
-    _shaAndDatesWithFilesParser ??= createLogParserWithFiles(shaAndDateMapping);
-    return _shaAndDatesWithFilesParser;
+function getShaAndDatesWithFilesLogParser(includeTips) {
+	if (includeTips) {
+		_shaAndDatesAndTipsWithFilesParser ??= createLogParserWithFiles(shaAndDateAndTipsMapping);
+		return _shaAndDatesAndTipsWithFilesParser;
+	}
+	_shaAndDatesWithFilesParser ??= createLogParserWithFiles(shaAndDateMapping);
+	return _shaAndDatesWithFilesParser;
 }
-const shaMapping = { sha: '%H' };
+const shaMapping = { sha: "%H" };
 let _shaAndFilesAndStatsParser;
-export function getShaAndFilesAndStatsLogParser() {
-    _shaAndFilesAndStatsParser ??= createLogParserWithFilesAndStats(shaMapping);
-    return _shaAndFilesAndStatsParser;
+function getShaAndFilesAndStatsLogParser() {
+	_shaAndFilesAndStatsParser ??= createLogParserWithFilesAndStats(shaMapping);
+	return _shaAndFilesAndStatsParser;
 }
 let _shaAndFileRangeParser;
-export function getShaAndFileRangeLogParser() {
-    _shaAndFileRangeParser ??= createLogParserWithPatch(shaMapping);
-    return _shaAndFileRangeParser;
+function getShaAndFileRangeLogParser() {
+	_shaAndFileRangeParser ??= createLogParserWithPatch(shaMapping);
+	return _shaAndFileRangeParser;
 }
 let _shaAndFileSummaryParser;
-export function getShaAndFileSummaryLogParser() {
-    _shaAndFileSummaryParser ??= createLogParserWithFileSummary(shaMapping);
-    return _shaAndFileSummaryParser;
+function getShaAndFileSummaryLogParser() {
+	_shaAndFileSummaryParser ??= createLogParserWithFileSummary(shaMapping);
+	return _shaAndFileSummaryParser;
 }
 let _shaAndStatsParser;
-export function getShaAndStatsLogParser() {
-    _shaAndStatsParser ??= createLogParserWithStats(shaMapping);
-    return _shaAndStatsParser;
+function getShaAndStatsLogParser() {
+	_shaAndStatsParser ??= createLogParserWithStats(shaMapping);
+	return _shaAndStatsParser;
 }
 const stashMapping = {
-    sha: '%H',
-    authorDate: '%at',
-    committedDate: '%ct',
-    parents: '%P',
-    stashName: '%gd',
-    summary: '%gs',
-    // %s (commit subject) is git's authoritative `On <branch>: …` / `WIP on <branch>: …` record,
-    // present even when the reflog message (%gs) was customized (autostash, `git stash store -m`).
-    // Used downstream to extract `stashOnRef` reliably.
-    commitSubject: '%s',
+	sha: "%H",
+	authorDate: "%at",
+	committedDate: "%ct",
+	parents: "%P",
+	stashName: "%gd",
+	summary: "%gs",
+	commitSubject: "%s"
 };
 let _stashParser;
 let _stashParserWithFiles;
-export function getStashLogParser(includeFiles) {
-    if (includeFiles) {
-        _stashParserWithFiles ??= createLogParserWithFilesAndStats(stashMapping);
-        return _stashParserWithFiles;
-    }
-    _stashParser ??= createLogParser(stashMapping);
-    return _stashParser;
+function getStashLogParser(includeFiles) {
+	if (includeFiles) {
+		_stashParserWithFiles ??= createLogParserWithFilesAndStats(stashMapping);
+		return _stashParserWithFiles;
+	}
+	_stashParser ??= createLogParser(stashMapping);
+	return _stashParser;
 }
 let _stashFilesOnlyParser;
-export function getStashFilesOnlyLogParser() {
-    _stashFilesOnlyParser ??= createLogParserWithFilesAndStats();
-    return _stashFilesOnlyParser;
+function getStashFilesOnlyLogParser() {
+	_stashFilesOnlyParser ??= createLogParserWithFilesAndStats();
+	return _stashFilesOnlyParser;
 }
-const recordSep = '\x1E'; // ASCII Record Separator character
-const recordFormatSep = '%x1E';
-const fieldSep = '\x1D'; // ASCII Group Separator character
-const fieldFormatSep = '%x1D';
-// A complete record terminates every mapped field with a field separator — a cancelled/early-closed
-// stream resolves cleanly with a truncated tail missing at least the final terminator.
+const recordSep = "";
+const recordFormatSep = "%x1E";
+const fieldSep = "";
+const fieldFormatSep = "%x1D";
 function isCompleteRecord(record, requiredFields) {
-    let count = 0;
-    let index = -1;
-    while (count < requiredFields) {
-        index = record.indexOf(fieldSep, index + 1);
-        if (index === -1)
-            return false;
-        count++;
-    }
-    return true;
+	let count = 0;
+	let index = -1;
+	while (count < requiredFields) {
+		index = record.indexOf(fieldSep, index + 1);
+		if (index === -1) return false;
+		count++;
+	}
+	return true;
 }
-export function createLogParser(mapping) {
-    let format = recordFormatSep;
-    const keys = [];
-    for (const key in mapping) {
-        keys.push(key);
-        format += `${mapping[key]}${fieldFormatSep}`;
-    }
-    const args = [`--format=${format}`];
-    function* parse(data) {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            const sw = __addDisposableResource(env_1, maybeStopWatch('Git.LogParser.parse', { log: { onlyExit: true, level: 'debug' } }), false);
-            if (!data) {
-                sw?.stop({ suffix: ` no data` });
-                return;
-            }
-            const records = iterateByDelimiter(data, recordSep);
-            let count = 0;
-            let entry;
-            let fields;
-            for (const record of records) {
-                if (!record.length)
-                    continue;
-                entry = {};
-                fields = iterateByDelimiter(record, fieldSep);
-                let fieldCount = 0;
-                let field;
-                while (true) {
-                    field = fields.next();
-                    if (field.done)
-                        break;
-                    if (fieldCount >= keys.length)
-                        continue;
-                    count++;
-                    entry[keys[fieldCount++]] = field.value;
-                }
-                yield entry;
-            }
-            sw?.stop({ suffix: ` parsed ${count} records` });
-        }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
-        }
-        finally {
-            __disposeResources(env_1);
-        }
-    }
-    async function* parseAsync(stream) {
-        const env_2 = { stack: [], error: void 0, hasError: false };
-        try {
-            const sw = __addDisposableResource(env_2, maybeStopWatch('Git.LogParser.parseAsync', { log: { onlyExit: true, level: 'debug' } }), false);
-            const records = iterateAsyncByDelimiter(stream, recordSep);
-            let count = 0;
-            let entry;
-            let fields;
-            for await (const record of records) {
-                if (!record.length)
-                    continue;
-                // Drop a truncated tail (cancelled/early-closed stream) instead of yielding undefined/partial fields.
-                if (!isCompleteRecord(record, keys.length))
-                    continue;
-                entry = {};
-                fields = iterateByDelimiter(record, fieldSep);
-                let fieldCount = 0;
-                let field;
-                while (true) {
-                    field = fields.next();
-                    if (field.done)
-                        break;
-                    if (fieldCount >= keys.length)
-                        continue;
-                    count++;
-                    entry[keys[fieldCount++]] = field.value;
-                }
-                yield entry;
-            }
-            sw?.stop({ suffix: ` parsed ${count} records` });
-        }
-        catch (e_2) {
-            env_2.error = e_2;
-            env_2.hasError = true;
-        }
-        finally {
-            __disposeResources(env_2);
-        }
-    }
-    // Builds one entry from a complete record with a plain `indexOf` walk. Matches `parseAsync`'s
-    // semantics exactly: fields beyond the mapping are ignored, and every mapped field is
-    // terminated by a field separator (the format string appends one after each field).
-    function parseRecord(record) {
-        // Fields sliced out of the record become long-lived (graph rows); flatten the record so they
-        // pin a record-sized copy rather than the full walk output the record was sliced from.
-        record = flattenString(record);
-        const entry = {};
-        let start = 0;
-        for (const key of keys) {
-            const end = record.indexOf(fieldSep, start);
-            if (end === -1)
-                break;
-            entry[key] = record.substring(start, end);
-            start = end + 1;
-        }
-        return entry;
-    }
-    async function* parseAsyncBatched(stream) {
-        const env_3 = { stack: [], error: void 0, hasError: false };
-        try {
-            const sw = __addDisposableResource(env_3, maybeStopWatch('Git.LogParser.parseAsyncBatched', { log: { onlyExit: true, level: 'debug' } }), false);
-            let count = 0;
-            let buffer = '';
-            for await (const chunk of stream) {
-                buffer += chunk;
-                let batch;
-                let start = 0;
-                while (true) {
-                    const end = buffer.indexOf(recordSep, start);
-                    if (end === -1)
-                        break;
-                    if (end > start) {
-                        (batch ??= []).push(parseRecord(buffer.substring(start, end)));
-                        count++;
-                    }
-                    start = end + 1;
-                }
-                if (start > 0) {
-                    buffer = buffer.substring(start);
-                }
-                if (batch != null) {
-                    yield batch;
-                }
-            }
-            // Trailing record (the stream doesn't end with a record separator); a truncated tail from a
-            // cancelled/early-closed stream is missing a field terminator and must be dropped, not parsed.
-            if (buffer.length > 0 && isCompleteRecord(buffer, keys.length)) {
-                count++;
-                yield [parseRecord(buffer)];
-            }
-            sw?.stop({ suffix: ` parsed ${count} records` });
-        }
-        catch (e_3) {
-            env_3.error = e_3;
-            env_3.hasError = true;
-        }
-        finally {
-            __disposeResources(env_3);
-        }
-    }
-    return {
-        arguments: args,
-        separators: { record: recordSep, field: fieldSep },
-        parse: parse,
-        parseAsync: parseAsync,
-        parseAsyncBatched: parseAsyncBatched,
-    };
+function createLogParser(mapping) {
+	let format = recordFormatSep;
+	const keys = [];
+	for (const key in mapping) {
+		keys.push(key);
+		format += `${mapping[key]}${fieldFormatSep}`;
+	}
+	const args = [`--format=${format}`];
+	function* parse(data) {
+		try {
+			var _usingCtx$1 = _usingCtx();
+			const sw = _usingCtx$1.u(maybeStopWatch("Git.LogParser.parse", { log: {
+				onlyExit: true,
+				level: "debug"
+			} }));
+			if (!data) {
+				sw?.stop({ suffix: ` no data` });
+				return;
+			}
+			const records = iterateByDelimiter(data, recordSep);
+			let count = 0;
+			let entry;
+			let fields;
+			for (const record of records) {
+				if (!record.length) continue;
+				entry = {};
+				fields = iterateByDelimiter(record, fieldSep);
+				let fieldCount = 0;
+				let field;
+				while (true) {
+					field = fields.next();
+					if (field.done) break;
+					if (fieldCount >= keys.length) continue;
+					count++;
+					entry[keys[fieldCount++]] = field.value;
+				}
+				yield entry;
+			}
+			sw?.stop({ suffix: ` parsed ${count} records` });
+		} catch (_) {
+			_usingCtx$1.e = _;
+		} finally {
+			_usingCtx$1.d();
+		}
+	}
+	async function* parseAsync(stream) {
+		try {
+			var _usingCtx3 = _usingCtx();
+			const sw = _usingCtx3.u(maybeStopWatch("Git.LogParser.parseAsync", { log: {
+				onlyExit: true,
+				level: "debug"
+			} }));
+			const records = iterateAsyncByDelimiter(stream, recordSep);
+			let count = 0;
+			let entry;
+			let fields;
+			for await (const record of records) {
+				if (!record.length) continue;
+				if (!isCompleteRecord(record, keys.length)) continue;
+				entry = {};
+				fields = iterateByDelimiter(record, fieldSep);
+				let fieldCount = 0;
+				let field;
+				while (true) {
+					field = fields.next();
+					if (field.done) break;
+					if (fieldCount >= keys.length) continue;
+					count++;
+					entry[keys[fieldCount++]] = field.value;
+				}
+				yield entry;
+			}
+			sw?.stop({ suffix: ` parsed ${count} records` });
+		} catch (_) {
+			_usingCtx3.e = _;
+		} finally {
+			_usingCtx3.d();
+		}
+	}
+	function parseRecord(record) {
+		record = flattenString(record);
+		const entry = {};
+		let start = 0;
+		for (const key of keys) {
+			const end = record.indexOf(fieldSep, start);
+			if (end === -1) break;
+			entry[key] = record.substring(start, end);
+			start = end + 1;
+		}
+		return entry;
+	}
+	async function* parseAsyncBatched(stream) {
+		try {
+			var _usingCtx4 = _usingCtx();
+			const sw = _usingCtx4.u(maybeStopWatch("Git.LogParser.parseAsyncBatched", { log: {
+				onlyExit: true,
+				level: "debug"
+			} }));
+			let count = 0;
+			let buffer = "";
+			for await (const chunk of stream) {
+				buffer += chunk;
+				let batch;
+				let start = 0;
+				while (true) {
+					const end = buffer.indexOf(recordSep, start);
+					if (end === -1) break;
+					if (end > start) {
+						(batch ??= []).push(parseRecord(buffer.substring(start, end)));
+						count++;
+					}
+					start = end + 1;
+				}
+				if (start > 0) buffer = buffer.substring(start);
+				if (batch != null) yield batch;
+			}
+			if (buffer.length > 0 && isCompleteRecord(buffer, keys.length)) {
+				count++;
+				yield [parseRecord(buffer)];
+			}
+			sw?.stop({ suffix: ` parsed ${count} records` });
+		} catch (_) {
+			_usingCtx4.e = _;
+		} finally {
+			_usingCtx4.d();
+		}
+	}
+	return {
+		arguments: args,
+		separators: {
+			record: recordSep,
+			field: fieldSep
+		},
+		parse,
+		parseAsync,
+		parseAsyncBatched
+	};
 }
 function createLogParserWithFilesAndStats(mapping) {
-    let format = recordFormatSep;
-    const keys = [];
-    if (mapping != null) {
-        for (const key in mapping) {
-            keys.push(key);
-            format += `${mapping[key]}${fieldFormatSep}`;
-        }
-    }
-    // Use --raw instead of --summary to get accurate mode info for ALL files (not just creates/deletes)
-    // This allows us to reliably detect submodules (mode 160000) even for modifications
-    const args = [`--format=${format}`, '--numstat', '--raw'];
-    function parseFilesAndStats(content) {
-        const files = [];
-        if (!content?.length)
-            return files;
-        // Map to store info from --raw lines: path -> { mode, status, originalPath, oid?, previousOid? }
-        // Raw format: :<old_mode> <new_mode> <old_sha> <new_sha> <status>[score]\t<path>[\t<new_path>]
-        const infoMap = new Map();
-        let startIndex;
-        let endIndex;
-        // Single pass: --raw lines come first, then --numstat lines
-        for (const line of iterateByDelimiter(content, '\n')) {
-            if (!line)
-                continue;
-            if (line.charCodeAt(0) === 58 /* ':' */) {
-                // --raw format: :<old_mode> <new_mode> <old_sha> <new_sha> <status>[score]\t<path>[\t<new_path>]
-                const tabIndex = line.indexOf('\t');
-                if (tabIndex === -1)
-                    continue;
-                // Parse metadata using indexOf instead of split() to avoid array allocation
-                // Format after ':': <old_mode> <new_mode> <old_sha> <new_sha> <status>[score]
-                // Skip old_mode, find new_mode
-                startIndex = line.indexOf(' ') + 1;
-                if (startIndex === 0)
-                    continue;
-                endIndex = line.indexOf(' ', startIndex);
-                if (endIndex === -1)
-                    continue;
-                const newMode = line.substring(startIndex, endIndex);
-                // Parse old_sha and new_sha positions
-                const oldShaStart = endIndex + 1;
-                const oldShaEnd = line.indexOf(' ', oldShaStart);
-                if (oldShaEnd === -1)
-                    continue;
-                const newShaStart = oldShaEnd + 1;
-                const newShaEnd = line.indexOf(' ', newShaStart);
-                if (newShaEnd === -1)
-                    continue;
-                // For submodules (mode 160000), capture the commit SHAs
-                let oid;
-                let previousOid;
-                if (newMode === '160000') {
-                    previousOid = line.substring(oldShaStart, oldShaEnd);
-                    oid = line.substring(newShaStart, newShaEnd);
-                }
-                // Status is first char after the last space
-                startIndex = newShaEnd;
-                const status = line.charAt(startIndex + 1);
-                // Parse path(s) using indexOf instead of split
-                const pathPart = line.substring(tabIndex + 1);
-                let path;
-                let originalPath;
-                const pathTabIndex = pathPart.indexOf('\t');
-                if ((status === 'R' || status === 'C') && pathTabIndex !== -1) {
-                    // For renames/copies: old_path\tnew_path
-                    originalPath = pathPart.substring(0, pathTabIndex);
-                    path = pathPart.substring(pathTabIndex + 1);
-                }
-                else {
-                    path = pathPart;
-                }
-                // Trim to match parseCopyOrRename which trims renamed paths
-                infoMap.set(path.trim(), {
-                    mode: newMode,
-                    status: status,
-                    originalPath: originalPath?.trim(),
-                    oid: oid,
-                    previousOid: previousOid,
-                });
-            }
-            else {
-                // --numstat format: <additions>\t<deletions>\t<path>
-                // With renames: <additions>\t<deletions>\t{prefix/old => new/suffix}
-                endIndex = line.indexOf('\t');
-                if (endIndex === -1) {
-                    debugger;
-                    continue;
-                }
-                const additions = line.substring(0, endIndex);
-                startIndex = endIndex + 1;
-                endIndex = line.indexOf('\t', startIndex);
-                if (endIndex === -1) {
-                    debugger;
-                    continue;
-                }
-                const deletions = line.substring(startIndex, endIndex);
-                let path = line.substring(endIndex + 1);
-                let originalPath;
-                // Parse rename format from numstat (e.g., "{old => new}/path")
-                ({ path, originalPath } = parseCopyOrRename(path, false));
-                // Look up --raw info for this path (keyed by trimmed new/destination path)
-                const info = infoMap.get(path.trim());
-                // Use status from --raw if available; provides accurate status (A/D/M/R/C/T)
-                const status = info?.status ?? (originalPath ? 'R' : 'M');
-                // Use originalPath from --raw if available (cleaner than numstat format)
-                if (info?.originalPath) {
-                    originalPath = info.originalPath;
-                }
-                const file = {
-                    status: status,
-                    path: path.trim(),
-                    originalPath: originalPath?.trim(),
-                    additions: additions === '-' ? 0 : parseInt(additions, 10) || 0,
-                    deletions: deletions === '-' ? 0 : parseInt(deletions, 10) || 0,
-                    // Store mode for consumers to derive file type (160000=submodule, 100755=executable, etc.)
-                    mode: info?.mode,
-                    oid: info?.oid,
-                    previousOid: info?.previousOid,
-                };
-                files.push(file);
-            }
-        }
-        return files;
-    }
-    function* parse(data) {
-        const env_4 = { stack: [], error: void 0, hasError: false };
-        try {
-            const sw = __addDisposableResource(env_4, maybeStopWatch('Git.LogParserWithFilesAndStats.parse', { log: { onlyExit: true, level: 'debug' } }), false);
-            if (!data) {
-                sw?.stop({ suffix: ` no data` });
-                return;
-            }
-            const records = iterateByDelimiter(data, recordSep);
-            let count = 0;
-            let entry;
-            let files;
-            let fields;
-            for (const record of records) {
-                if (!record.length)
-                    continue;
-                count++;
-                entry = {};
-                files = [];
-                fields = iterateByDelimiter(record, fieldSep);
-                let fieldCount = 0;
-                let field;
-                while (true) {
-                    field = fields.next();
-                    if (field.done)
-                        break;
-                    if (fieldCount < keys.length) {
-                        entry[keys[fieldCount++]] = field.value;
-                    }
-                    else if (fieldCount === keys.length) {
-                        // Slice off the first newlines between the commits and files/summary, if any
-                        const summary = field.value.startsWith('\n\n')
-                            ? field.value.substring(2)
-                            : field.value.startsWith('\n')
-                                ? field.value.substring(1)
-                                : field.value;
-                        files.push(...parseFilesAndStats(summary));
-                    }
-                    else {
-                        debugger;
-                    }
-                }
-                entry.files = files;
-                if (files.length) {
-                    entry.stats = { additions: 0, deletions: 0, files: { added: 0, deleted: 0, changed: 0 } };
-                    for (const f of files) {
-                        if (f.additions || f.deletions) {
-                            entry.stats.additions += f.additions ?? 0;
-                            entry.stats.deletions += f.deletions ?? 0;
-                            if (f.status === 'A' || f.status === '?') {
-                                entry.stats.files.added++;
-                            }
-                            else if (f.status === 'D') {
-                                entry.stats.files.deleted++;
-                            }
-                            else {
-                                entry.stats.files.changed++;
-                            }
-                        }
-                    }
-                }
-                yield entry;
-            }
-            sw?.stop({ suffix: ` parsed ${count} records` });
-        }
-        catch (e_4) {
-            env_4.error = e_4;
-            env_4.hasError = true;
-        }
-        finally {
-            __disposeResources(env_4);
-        }
-    }
-    async function* parseAsync(stream) {
-        const env_5 = { stack: [], error: void 0, hasError: false };
-        try {
-            const sw = __addDisposableResource(env_5, maybeStopWatch('Git.LogParserWithFilesAndStats.parseAsync', {
-                log: { onlyExit: true, level: 'debug' },
-            }), false);
-            const records = iterateAsyncByDelimiter(stream, recordSep);
-            let count = 0;
-            let entry;
-            let files;
-            let fields;
-            for await (const record of records) {
-                if (!record.length)
-                    continue;
-                // Drop a truncated tail (cancelled/early-closed stream) instead of yielding undefined/partial fields.
-                if (!isCompleteRecord(record, keys.length))
-                    continue;
-                count++;
-                entry = {};
-                files = [];
-                fields = iterateByDelimiter(record, fieldSep);
-                let fieldCount = 0;
-                let field;
-                while (true) {
-                    field = fields.next();
-                    if (field.done)
-                        break;
-                    if (fieldCount < keys.length) {
-                        entry[keys[fieldCount++]] = field.value;
-                    }
-                    else if (fieldCount === keys.length) {
-                        // Slice off the first newlines between the commits and files/summary, if any
-                        const summary = field.value.startsWith('\n\n')
-                            ? field.value.substring(2)
-                            : field.value.startsWith('\n')
-                                ? field.value.substring(1)
-                                : field.value;
-                        files.push(...parseFilesAndStats(summary));
-                    }
-                    else {
-                        debugger;
-                    }
-                }
-                entry.files = files;
-                if (files.length) {
-                    entry.stats = { additions: 0, deletions: 0, files: { added: 0, deleted: 0, changed: 0 } };
-                    for (const f of files) {
-                        if (f.additions || f.deletions) {
-                            entry.stats.additions += f.additions ?? 0;
-                            entry.stats.deletions += f.deletions ?? 0;
-                            if (f.status === 'A' || f.status === '?') {
-                                entry.stats.files.added++;
-                            }
-                            else if (f.status === 'D') {
-                                entry.stats.files.deleted++;
-                            }
-                            else {
-                                entry.stats.files.changed++;
-                            }
-                        }
-                    }
-                }
-                yield entry;
-            }
-            sw?.stop({ suffix: ` parsed ${count} records` });
-        }
-        catch (e_5) {
-            env_5.error = e_5;
-            env_5.hasError = true;
-        }
-        finally {
-            __disposeResources(env_5);
-        }
-    }
-    return {
-        arguments: args,
-        separators: { record: recordSep, field: fieldSep },
-        parse: parse,
-        parseAsync: parseAsync,
-    };
+	let format = recordFormatSep;
+	const keys = [];
+	if (mapping != null) for (const key in mapping) {
+		keys.push(key);
+		format += `${mapping[key]}${fieldFormatSep}`;
+	}
+	const args = [
+		`--format=${format}`,
+		"--numstat",
+		"--raw"
+	];
+	function parseFilesAndStats(content) {
+		const files = [];
+		if (!content?.length) return files;
+		const infoMap = /* @__PURE__ */ new Map();
+		let startIndex;
+		let endIndex;
+		for (const line of iterateByDelimiter(content, "\n")) {
+			if (!line) continue;
+			if (line.charCodeAt(0) === 58) {
+				const tabIndex = line.indexOf("	");
+				if (tabIndex === -1) continue;
+				startIndex = line.indexOf(" ") + 1;
+				if (startIndex === 0) continue;
+				endIndex = line.indexOf(" ", startIndex);
+				if (endIndex === -1) continue;
+				const newMode = line.substring(startIndex, endIndex);
+				const oldShaStart = endIndex + 1;
+				const oldShaEnd = line.indexOf(" ", oldShaStart);
+				if (oldShaEnd === -1) continue;
+				const newShaStart = oldShaEnd + 1;
+				const newShaEnd = line.indexOf(" ", newShaStart);
+				if (newShaEnd === -1) continue;
+				let oid;
+				let previousOid;
+				if (newMode === "160000") {
+					previousOid = line.substring(oldShaStart, oldShaEnd);
+					oid = line.substring(newShaStart, newShaEnd);
+				}
+				startIndex = newShaEnd;
+				const status = line.charAt(startIndex + 1);
+				const pathPart = line.substring(tabIndex + 1);
+				let path;
+				let originalPath;
+				const pathTabIndex = pathPart.indexOf("	");
+				if ((status === "R" || status === "C") && pathTabIndex !== -1) {
+					originalPath = pathPart.substring(0, pathTabIndex);
+					path = pathPart.substring(pathTabIndex + 1);
+				} else path = pathPart;
+				infoMap.set(path.trim(), {
+					mode: newMode,
+					status,
+					originalPath: originalPath?.trim(),
+					oid,
+					previousOid
+				});
+			} else {
+				endIndex = line.indexOf("	");
+				if (endIndex === -1) {
+					debugger;
+					continue;
+				}
+				const additions = line.substring(0, endIndex);
+				startIndex = endIndex + 1;
+				endIndex = line.indexOf("	", startIndex);
+				if (endIndex === -1) {
+					debugger;
+					continue;
+				}
+				const deletions = line.substring(startIndex, endIndex);
+				let path = line.substring(endIndex + 1);
+				let originalPath;
+				({path, originalPath} = parseCopyOrRename(path, false));
+				const info = infoMap.get(path.trim());
+				const status = info?.status ?? (originalPath ? "R" : "M");
+				if (info?.originalPath) originalPath = info.originalPath;
+				const file = {
+					status,
+					path: path.trim(),
+					originalPath: originalPath?.trim(),
+					additions: additions === "-" ? 0 : parseInt(additions, 10) || 0,
+					deletions: deletions === "-" ? 0 : parseInt(deletions, 10) || 0,
+					mode: info?.mode,
+					oid: info?.oid,
+					previousOid: info?.previousOid
+				};
+				files.push(file);
+			}
+		}
+		return files;
+	}
+	function* parse(data) {
+		try {
+			var _usingCtx5 = _usingCtx();
+			const sw = _usingCtx5.u(maybeStopWatch("Git.LogParserWithFilesAndStats.parse", { log: {
+				onlyExit: true,
+				level: "debug"
+			} }));
+			if (!data) {
+				sw?.stop({ suffix: ` no data` });
+				return;
+			}
+			const records = iterateByDelimiter(data, recordSep);
+			let count = 0;
+			let entry;
+			let files;
+			let fields;
+			for (const record of records) {
+				if (!record.length) continue;
+				count++;
+				entry = {};
+				files = [];
+				fields = iterateByDelimiter(record, fieldSep);
+				let fieldCount = 0;
+				let field;
+				while (true) {
+					field = fields.next();
+					if (field.done) break;
+					if (fieldCount < keys.length) entry[keys[fieldCount++]] = field.value;
+					else if (fieldCount === keys.length) {
+						const summary = field.value.startsWith("\n\n") ? field.value.substring(2) : field.value.startsWith("\n") ? field.value.substring(1) : field.value;
+						files.push(...parseFilesAndStats(summary));
+					} else debugger;
+				}
+				entry.files = files;
+				if (files.length) {
+					entry.stats = {
+						additions: 0,
+						deletions: 0,
+						files: {
+							added: 0,
+							deleted: 0,
+							changed: 0
+						}
+					};
+					for (const f of files) if (f.additions || f.deletions) {
+						entry.stats.additions += f.additions ?? 0;
+						entry.stats.deletions += f.deletions ?? 0;
+						if (f.status === "A" || f.status === "?") entry.stats.files.added++;
+						else if (f.status === "D") entry.stats.files.deleted++;
+						else entry.stats.files.changed++;
+					}
+				}
+				yield entry;
+			}
+			sw?.stop({ suffix: ` parsed ${count} records` });
+		} catch (_) {
+			_usingCtx5.e = _;
+		} finally {
+			_usingCtx5.d();
+		}
+	}
+	async function* parseAsync(stream) {
+		try {
+			var _usingCtx6 = _usingCtx();
+			const sw = _usingCtx6.u(maybeStopWatch("Git.LogParserWithFilesAndStats.parseAsync", { log: {
+				onlyExit: true,
+				level: "debug"
+			} }));
+			const records = iterateAsyncByDelimiter(stream, recordSep);
+			let count = 0;
+			let entry;
+			let files;
+			let fields;
+			for await (const record of records) {
+				if (!record.length) continue;
+				if (!isCompleteRecord(record, keys.length)) continue;
+				count++;
+				entry = {};
+				files = [];
+				fields = iterateByDelimiter(record, fieldSep);
+				let fieldCount = 0;
+				let field;
+				while (true) {
+					field = fields.next();
+					if (field.done) break;
+					if (fieldCount < keys.length) entry[keys[fieldCount++]] = field.value;
+					else if (fieldCount === keys.length) {
+						const summary = field.value.startsWith("\n\n") ? field.value.substring(2) : field.value.startsWith("\n") ? field.value.substring(1) : field.value;
+						files.push(...parseFilesAndStats(summary));
+					} else debugger;
+				}
+				entry.files = files;
+				if (files.length) {
+					entry.stats = {
+						additions: 0,
+						deletions: 0,
+						files: {
+							added: 0,
+							deleted: 0,
+							changed: 0
+						}
+					};
+					for (const f of files) if (f.additions || f.deletions) {
+						entry.stats.additions += f.additions ?? 0;
+						entry.stats.deletions += f.deletions ?? 0;
+						if (f.status === "A" || f.status === "?") entry.stats.files.added++;
+						else if (f.status === "D") entry.stats.files.deleted++;
+						else entry.stats.files.changed++;
+					}
+				}
+				yield entry;
+			}
+			sw?.stop({ suffix: ` parsed ${count} records` });
+		} catch (_) {
+			_usingCtx6.e = _;
+		} finally {
+			_usingCtx6.d();
+		}
+	}
+	return {
+		arguments: args,
+		separators: {
+			record: recordSep,
+			field: fieldSep
+		},
+		parse,
+		parseAsync
+	};
 }
 function createLogParserWithFileSummary(mapping) {
-    let format = recordFormatSep;
-    const keys = [];
-    if (mapping != null) {
-        for (const key in mapping) {
-            keys.push(key);
-            format += `${mapping[key]}${fieldFormatSep}`;
-        }
-    }
-    const args = [`--format=${format}`, '--summary'];
-    function parseFileSummary(content) {
-        const files = [];
-        if (!content?.length)
-            return files;
-        let startIndex;
-        let path;
-        let originalPath;
-        let status;
-        for (const line of iterateByDelimiter(content, '\n')) {
-            if (!line)
-                continue;
-            if (line.startsWith(' rename ')) {
-                ({ path, originalPath } = parseCopyOrRename(line.substring(8 /* move past ' rename ' */), true));
-                files.push({ path: path, originalPath: originalPath, status: 'R' });
-            }
-            else if (line.startsWith(' copy ')) {
-                ({ path, originalPath } = parseCopyOrRename(line.substring(6 /* move past ' copy ' */), true));
-                files.push({ path: path, originalPath: originalPath, status: 'C' });
-            }
-            else {
-                if (line.startsWith(' create mode ')) {
-                    status = 'A';
-                }
-                else if (line.startsWith(' delete mode ')) {
-                    status = 'D';
-                }
-                else {
-                    // Ignore " mode change " lines
-                    if (!line.startsWith(' mode change ')) {
-                        debugger;
-                    }
-                    continue;
-                }
-                startIndex = line.indexOf(' ', 13 /* move past 'create mode <num>' or 'delete mode <num>' */);
-                if (startIndex > -1) {
-                    path = line.substring(startIndex + 1);
-                    files.push({ path: path, status: status });
-                }
-                else {
-                    debugger;
-                }
-            }
-        }
-        return files;
-    }
-    function* parse(data) {
-        const env_6 = { stack: [], error: void 0, hasError: false };
-        try {
-            const sw = __addDisposableResource(env_6, maybeStopWatch('Git.LogParserWithFileSummary.parse', { log: { onlyExit: true, level: 'debug' } }), false);
-            if (!data) {
-                sw?.stop({ suffix: ` no data` });
-                return;
-            }
-            const records = iterateByDelimiter(data, recordSep);
-            let count = 0;
-            let entry;
-            let files;
-            let fields;
-            for (const record of records) {
-                if (!record.length)
-                    continue;
-                count++;
-                entry = {};
-                files = [];
-                fields = iterateByDelimiter(record, fieldSep);
-                let fieldCount = 0;
-                let field;
-                while (true) {
-                    field = fields.next();
-                    if (field.done)
-                        break;
-                    if (fieldCount < keys.length) {
-                        entry[keys[fieldCount++]] = field.value;
-                    }
-                    else if (fieldCount === keys.length) {
-                        // Slice off the first newlines between the commits and files/summary, if any
-                        const summary = field.value.startsWith('\n\n')
-                            ? field.value.substring(2)
-                            : field.value.startsWith('\n')
-                                ? field.value.substring(1)
-                                : field.value;
-                        files.push(...parseFileSummary(summary));
-                    }
-                    else {
-                        debugger;
-                    }
-                }
-                entry.files = files;
-                yield entry;
-            }
-            sw?.stop({ suffix: ` parsed ${count} records` });
-        }
-        catch (e_6) {
-            env_6.error = e_6;
-            env_6.hasError = true;
-        }
-        finally {
-            __disposeResources(env_6);
-        }
-    }
-    return {
-        arguments: args,
-        separators: { record: recordSep, field: fieldSep },
-        parse: parse,
-    };
+	let format = recordFormatSep;
+	const keys = [];
+	if (mapping != null) for (const key in mapping) {
+		keys.push(key);
+		format += `${mapping[key]}${fieldFormatSep}`;
+	}
+	const args = [`--format=${format}`, "--summary"];
+	function parseFileSummary(content) {
+		const files = [];
+		if (!content?.length) return files;
+		let startIndex;
+		let path;
+		let originalPath;
+		let status;
+		for (const line of iterateByDelimiter(content, "\n")) {
+			if (!line) continue;
+			if (line.startsWith(" rename ")) {
+				({path, originalPath} = parseCopyOrRename(line.substring(8), true));
+				files.push({
+					path,
+					originalPath,
+					status: "R"
+				});
+			} else if (line.startsWith(" copy ")) {
+				({path, originalPath} = parseCopyOrRename(line.substring(6), true));
+				files.push({
+					path,
+					originalPath,
+					status: "C"
+				});
+			} else {
+				if (line.startsWith(" create mode ")) status = "A";
+				else if (line.startsWith(" delete mode ")) status = "D";
+				else {
+					if (!line.startsWith(" mode change ")) debugger;
+					continue;
+				}
+				startIndex = line.indexOf(" ", 13);
+				if (startIndex > -1) {
+					path = line.substring(startIndex + 1);
+					files.push({
+						path,
+						status
+					});
+				} else debugger;
+			}
+		}
+		return files;
+	}
+	function* parse(data) {
+		try {
+			var _usingCtx7 = _usingCtx();
+			const sw = _usingCtx7.u(maybeStopWatch("Git.LogParserWithFileSummary.parse", { log: {
+				onlyExit: true,
+				level: "debug"
+			} }));
+			if (!data) {
+				sw?.stop({ suffix: ` no data` });
+				return;
+			}
+			const records = iterateByDelimiter(data, recordSep);
+			let count = 0;
+			let entry;
+			let files;
+			let fields;
+			for (const record of records) {
+				if (!record.length) continue;
+				count++;
+				entry = {};
+				files = [];
+				fields = iterateByDelimiter(record, fieldSep);
+				let fieldCount = 0;
+				let field;
+				while (true) {
+					field = fields.next();
+					if (field.done) break;
+					if (fieldCount < keys.length) entry[keys[fieldCount++]] = field.value;
+					else if (fieldCount === keys.length) {
+						const summary = field.value.startsWith("\n\n") ? field.value.substring(2) : field.value.startsWith("\n") ? field.value.substring(1) : field.value;
+						files.push(...parseFileSummary(summary));
+					} else debugger;
+				}
+				entry.files = files;
+				yield entry;
+			}
+			sw?.stop({ suffix: ` parsed ${count} records` });
+		} catch (_) {
+			_usingCtx7.e = _;
+		} finally {
+			_usingCtx7.d();
+		}
+	}
+	return {
+		arguments: args,
+		separators: {
+			record: recordSep,
+			field: fieldSep
+		},
+		parse
+	};
 }
 function parseCopyOrRename(path, stripPercentage) {
-    const renameIndex = path.indexOf(' => ');
-    if (renameIndex === -1)
-        return { path: path };
-    let hasBraces = true;
-    let openIndex = path.indexOf('{');
-    if (openIndex === -1) {
-        hasBraces = false;
-        openIndex = 0;
-    }
-    let closeIndex = path.indexOf('}', openIndex);
-    if (closeIndex === -1) {
-        hasBraces = false;
-        closeIndex = path.length;
-    }
-    const prefix = path.substring(0, openIndex);
-    const fromPart = path.substring(hasBraces ? openIndex + 1 : 0, renameIndex);
-    let toPart = path.substring(renameIndex + 4, closeIndex);
-    let suffix = path.substring(closeIndex + 1);
-    // Check for percentage marker which always appears at the end as (xx%)
-    if (stripPercentage) {
-        if (hasBraces) {
-            if (suffix.endsWith('%)')) {
-                // Find the last open paren that starts the percentage
-                const percentPos = suffix.lastIndexOf(' (');
-                if (percentPos > -1) {
-                    suffix = suffix.substring(0, percentPos);
-                }
-            }
-        }
-        else if (toPart.endsWith('%)')) {
-            // Find the last open paren that starts the percentage
-            const percentPos = toPart.lastIndexOf(' (');
-            if (percentPos > -1) {
-                toPart = toPart.substring(0, percentPos);
-            }
-        }
-    }
-    return {
-        path: normalizePath(joinPaths(prefix, toPart, suffix).trim()),
-        originalPath: normalizePath(joinPaths(prefix, fromPart, suffix).trim()),
-    };
+	const renameIndex = path.indexOf(" => ");
+	if (renameIndex === -1) return { path };
+	let hasBraces = true;
+	let openIndex = path.indexOf("{");
+	if (openIndex === -1) {
+		hasBraces = false;
+		openIndex = 0;
+	}
+	let closeIndex = path.indexOf("}", openIndex);
+	if (closeIndex === -1) {
+		hasBraces = false;
+		closeIndex = path.length;
+	}
+	const prefix = path.substring(0, openIndex);
+	const fromPart = path.substring(hasBraces ? openIndex + 1 : 0, renameIndex);
+	let toPart = path.substring(renameIndex + 4, closeIndex);
+	let suffix = path.substring(closeIndex + 1);
+	if (stripPercentage) {
+		if (hasBraces) {
+			if (suffix.endsWith("%)")) {
+				const percentPos = suffix.lastIndexOf(" (");
+				if (percentPos > -1) suffix = suffix.substring(0, percentPos);
+			}
+		} else if (toPart.endsWith("%)")) {
+			const percentPos = toPart.lastIndexOf(" (");
+			if (percentPos > -1) toPart = toPart.substring(0, percentPos);
+		}
+	}
+	return {
+		path: normalizePath(joinPaths(prefix, toPart, suffix).trim()),
+		originalPath: normalizePath(joinPaths(prefix, fromPart, suffix).trim())
+	};
 }
 function createLogParserSingle(field) {
-    const args = ['-z', `--format=${field}`];
-    function parse(data) {
-        const env_7 = { stack: [], error: void 0, hasError: false };
-        try {
-            const _sw = __addDisposableResource(env_7, maybeStopWatch('Git.LogParserSingle.parse', { log: { onlyExit: true, level: 'debug' } }), false);
-            return data ? iterateByDelimiter(data, '\0') : [];
-        }
-        catch (e_7) {
-            env_7.error = e_7;
-            env_7.hasError = true;
-        }
-        finally {
-            __disposeResources(env_7);
-        }
-    }
-    return { arguments: args, separators: { record: '\0', field: '\0' }, parse: parse };
+	const args = ["-z", `--format=${field}`];
+	function parse(data) {
+		try {
+			var _usingCtx8 = _usingCtx();
+			_usingCtx8.u(maybeStopWatch("Git.LogParserSingle.parse", { log: {
+				onlyExit: true,
+				level: "debug"
+			} }));
+			return data ? iterateByDelimiter(data, "\0") : [];
+		} catch (_) {
+			_usingCtx8.e = _;
+		} finally {
+			_usingCtx8.d();
+		}
+	}
+	return {
+		arguments: args,
+		separators: {
+			record: "\0",
+			field: "\0"
+		},
+		parse
+	};
 }
 function createLogParserWithPatch(mapping) {
-    let format = recordFormatSep;
-    const keys = [];
-    for (const key in mapping) {
-        keys.push(key);
-        format += `${mapping[key]}${fieldFormatSep}`;
-    }
-    const args = [`--format=${format}`];
-    function parsePatch(content) {
-        const lines = iterateByDelimiter(content, '\n');
-        let line = lines.next();
-        if (line.done)
-            return undefined;
-        const fileMatch = diffRegex.exec(line.value);
-        if (fileMatch == null)
-            return undefined;
-        while (!line.done && !line.value.startsWith('@@ ')) {
-            line = lines.next();
-        }
-        const rangeMatch = line.value.match(diffHunkRegex);
-        let range;
-        let originalRange;
-        if (rangeMatch != null) {
-            let start = parseInt(rangeMatch[1], 10);
-            let count = rangeMatch[2] ? parseInt(rangeMatch[2], 10) : 1;
-            originalRange = start && count ? { startLine: start, endLine: start + count - 1 } : undefined;
-            start = parseInt(rangeMatch[3], 10);
-            count = rangeMatch[4] ? parseInt(rangeMatch[4], 10) : 1;
-            range = start && count ? { startLine: start, endLine: start + count - 1 } : undefined;
-        }
-        return {
-            status: (fileMatch[1] === 'rename' ? 'R' : 'M'),
-            path: fileMatch[2],
-            originalPath: fileMatch[1] === 'rename' ? fileMatch[3] : undefined,
-            range: range,
-            originalRange: originalRange,
-        };
-    }
-    function* parse(data) {
-        const env_8 = { stack: [], error: void 0, hasError: false };
-        try {
-            const sw = __addDisposableResource(env_8, maybeStopWatch('Git.LogParserWithPatch.parse', { log: { onlyExit: true, level: 'debug' } }), false);
-            if (!data) {
-                sw?.stop({ suffix: ` no data` });
-                return;
-            }
-            const records = iterateByDelimiter(data, recordSep);
-            let count = 0;
-            let entry;
-            let fields;
-            for (const record of records) {
-                if (!record.length)
-                    continue;
-                count++;
-                entry = {};
-                fields = iterateByDelimiter(record, fieldSep);
-                let fieldCount = 0;
-                let field;
-                while (true) {
-                    field = fields.next();
-                    if (field.done)
-                        break;
-                    if (fieldCount < keys.length) {
-                        entry[keys[fieldCount++]] = field.value;
-                    }
-                    else if (fieldCount === keys.length) {
-                        // Slice off the first newlines between the commit data and patch, if any
-                        const patch = field.value.startsWith('\n\n')
-                            ? field.value.substring(2)
-                            : field.value.startsWith('\n')
-                                ? field.value.substring(1)
-                                : field.value;
-                        const file = parsePatch(patch);
-                        entry.files = file != null ? [file] : [];
-                    }
-                    else {
-                        debugger;
-                    }
-                }
-                yield entry;
-            }
-            sw?.stop({ suffix: ` parsed ${count} records` });
-        }
-        catch (e_8) {
-            env_8.error = e_8;
-            env_8.hasError = true;
-        }
-        finally {
-            __disposeResources(env_8);
-        }
-    }
-    async function* parseAsync(stream) {
-        const env_9 = { stack: [], error: void 0, hasError: false };
-        try {
-            const sw = __addDisposableResource(env_9, maybeStopWatch('Git.LogParserWithPatch.parseAsync', { log: { onlyExit: true, level: 'debug' } }), false);
-            const records = iterateAsyncByDelimiter(stream, recordSep);
-            let count = 0;
-            let entry;
-            let fields;
-            for await (const record of records) {
-                if (!record.length)
-                    continue;
-                // Drop a truncated tail (cancelled/early-closed stream) instead of yielding undefined/partial fields.
-                if (!isCompleteRecord(record, keys.length))
-                    continue;
-                count++;
-                entry = {};
-                fields = iterateByDelimiter(record, fieldSep);
-                let fieldCount = 0;
-                let field;
-                while (true) {
-                    field = fields.next();
-                    if (field.done)
-                        break;
-                    if (fieldCount < keys.length) {
-                        entry[keys[fieldCount++]] = field.value;
-                    }
-                    else if (fieldCount === keys.length) {
-                        // Slice off the first newlines between the commit data and patch, if any
-                        const patch = field.value.startsWith('\n\n')
-                            ? field.value.substring(2)
-                            : field.value.startsWith('\n')
-                                ? field.value.substring(1)
-                                : field.value;
-                        const file = parsePatch(patch);
-                        entry.files = file != null ? [file] : [];
-                    }
-                    else {
-                        debugger;
-                    }
-                }
-                yield entry;
-            }
-            sw?.stop({ suffix: ` parsed ${count} records` });
-        }
-        catch (e_9) {
-            env_9.error = e_9;
-            env_9.hasError = true;
-        }
-        finally {
-            __disposeResources(env_9);
-        }
-    }
-    return {
-        arguments: args,
-        separators: { record: recordSep, field: fieldSep },
-        parse: parse,
-        parseAsync: parseAsync,
-    };
+	let format = recordFormatSep;
+	const keys = [];
+	for (const key in mapping) {
+		keys.push(key);
+		format += `${mapping[key]}${fieldFormatSep}`;
+	}
+	const args = [`--format=${format}`];
+	function parsePatch(content) {
+		const lines = iterateByDelimiter(content, "\n");
+		let line = lines.next();
+		if (line.done) return void 0;
+		const fileMatch = diffRegex.exec(line.value);
+		if (fileMatch == null) return void 0;
+		while (!line.done && !line.value.startsWith("@@ ")) line = lines.next();
+		const rangeMatch = line.value.match(diffHunkRegex);
+		let range;
+		let originalRange;
+		if (rangeMatch != null) {
+			let start = parseInt(rangeMatch[1], 10);
+			let count = rangeMatch[2] ? parseInt(rangeMatch[2], 10) : 1;
+			originalRange = start && count ? {
+				startLine: start,
+				endLine: start + count - 1
+			} : void 0;
+			start = parseInt(rangeMatch[3], 10);
+			count = rangeMatch[4] ? parseInt(rangeMatch[4], 10) : 1;
+			range = start && count ? {
+				startLine: start,
+				endLine: start + count - 1
+			} : void 0;
+		}
+		return {
+			status: fileMatch[1] === "rename" ? "R" : "M",
+			path: fileMatch[2],
+			originalPath: fileMatch[1] === "rename" ? fileMatch[3] : void 0,
+			range,
+			originalRange
+		};
+	}
+	function* parse(data) {
+		try {
+			var _usingCtx9 = _usingCtx();
+			const sw = _usingCtx9.u(maybeStopWatch("Git.LogParserWithPatch.parse", { log: {
+				onlyExit: true,
+				level: "debug"
+			} }));
+			if (!data) {
+				sw?.stop({ suffix: ` no data` });
+				return;
+			}
+			const records = iterateByDelimiter(data, recordSep);
+			let count = 0;
+			let entry;
+			let fields;
+			for (const record of records) {
+				if (!record.length) continue;
+				count++;
+				entry = {};
+				fields = iterateByDelimiter(record, fieldSep);
+				let fieldCount = 0;
+				let field;
+				while (true) {
+					field = fields.next();
+					if (field.done) break;
+					if (fieldCount < keys.length) entry[keys[fieldCount++]] = field.value;
+					else if (fieldCount === keys.length) {
+						const file = parsePatch(field.value.startsWith("\n\n") ? field.value.substring(2) : field.value.startsWith("\n") ? field.value.substring(1) : field.value);
+						entry.files = file != null ? [file] : [];
+					} else debugger;
+				}
+				yield entry;
+			}
+			sw?.stop({ suffix: ` parsed ${count} records` });
+		} catch (_) {
+			_usingCtx9.e = _;
+		} finally {
+			_usingCtx9.d();
+		}
+	}
+	async function* parseAsync(stream) {
+		try {
+			var _usingCtx10 = _usingCtx();
+			const sw = _usingCtx10.u(maybeStopWatch("Git.LogParserWithPatch.parseAsync", { log: {
+				onlyExit: true,
+				level: "debug"
+			} }));
+			const records = iterateAsyncByDelimiter(stream, recordSep);
+			let count = 0;
+			let entry;
+			let fields;
+			for await (const record of records) {
+				if (!record.length) continue;
+				if (!isCompleteRecord(record, keys.length)) continue;
+				count++;
+				entry = {};
+				fields = iterateByDelimiter(record, fieldSep);
+				let fieldCount = 0;
+				let field;
+				while (true) {
+					field = fields.next();
+					if (field.done) break;
+					if (fieldCount < keys.length) entry[keys[fieldCount++]] = field.value;
+					else if (fieldCount === keys.length) {
+						const file = parsePatch(field.value.startsWith("\n\n") ? field.value.substring(2) : field.value.startsWith("\n") ? field.value.substring(1) : field.value);
+						entry.files = file != null ? [file] : [];
+					} else debugger;
+				}
+				yield entry;
+			}
+			sw?.stop({ suffix: ` parsed ${count} records` });
+		} catch (_) {
+			_usingCtx10.e = _;
+		} finally {
+			_usingCtx10.d();
+		}
+	}
+	return {
+		arguments: args,
+		separators: {
+			record: recordSep,
+			field: fieldSep
+		},
+		parse,
+		parseAsync
+	};
 }
 function createLogParserWithStats(mapping) {
-    let format = recordFormatSep;
-    const keys = [];
-    for (const key in mapping) {
-        keys.push(key);
-        format += `${mapping[key]}${fieldFormatSep}`;
-    }
-    const args = [`--format=${format}`, '--shortstat'];
-    function parseStats(content) {
-        const stats = { files: 0, additions: 0, deletions: 0 };
-        content = content?.trim();
-        if (!content?.length)
-            return { files: 0, additions: 0, deletions: 0 };
-        let filesEnd;
-        let filesIndex = content.indexOf(' files changed');
-        if (filesIndex === -1) {
-            filesIndex = content.indexOf(' file changed');
-            if (filesIndex === -1)
-                return stats;
-            filesEnd = filesIndex + ' file changed'.length;
-        }
-        else {
-            filesEnd = filesIndex + ' files changed'.length;
-        }
-        // Extract number before " files changed"
-        const filesPart = content.substring(0, filesIndex).trim();
-        stats.files = parseInt(filesPart, 10) || 0;
-        // Extract additions if present
-        const additionsIndex = content.indexOf(' insertion', filesEnd);
-        if (additionsIndex !== -1) {
-            // Look for the number before "insertion(+)" or "insertions(+)"
-            const spaceIndex = content.lastIndexOf(' ', additionsIndex - 1);
-            if (spaceIndex !== -1) {
-                const additionsPart = content.substring(spaceIndex, additionsIndex).trim();
-                stats.additions = parseInt(additionsPart, 10) || 0;
-            }
-        }
-        // Extract deletions if present
-        const deletionsIndex = content.indexOf(' deletion', filesEnd);
-        if (deletionsIndex !== -1) {
-            // Look for the number before ""deletion(-)" or "deletions(-)"
-            const spaceIndex = content.lastIndexOf(' ', deletionsIndex - 1);
-            if (spaceIndex !== -1) {
-                const deletionsPart = content.substring(spaceIndex, deletionsIndex).trim();
-                stats.deletions = parseInt(deletionsPart, 10) || 0;
-            }
-        }
-        return stats;
-    }
-    function* parse(data) {
-        const env_10 = { stack: [], error: void 0, hasError: false };
-        try {
-            const sw = __addDisposableResource(env_10, maybeStopWatch('Git.LogParserWithStats.parse', { log: { onlyExit: true, level: 'debug' } }), false);
-            if (!data) {
-                sw?.stop({ suffix: ` no data` });
-                return;
-            }
-            const records = iterateByDelimiter(data, recordSep);
-            let count = 0;
-            let entry;
-            let fields;
-            for (const record of records) {
-                if (!record.length)
-                    continue;
-                count++;
-                entry = {};
-                fields = iterateByDelimiter(record, fieldSep);
-                let fieldCount = 0;
-                let field;
-                while (true) {
-                    field = fields.next();
-                    if (field.done)
-                        break;
-                    if (fieldCount < keys.length) {
-                        entry[keys[fieldCount++]] = field.value;
-                    }
-                    else if (fieldCount === keys.length) {
-                        // Slice off the first newlines between the commit data and files/summary, if any
-                        const summary = field.value.startsWith('\n\n')
-                            ? field.value.substring(2)
-                            : field.value.startsWith('\n')
-                                ? field.value.substring(1)
-                                : field.value;
-                        entry.stats = parseStats(summary);
-                    }
-                    else {
-                        debugger;
-                    }
-                }
-                yield entry;
-            }
-            sw?.stop({ suffix: ` parsed ${count} records` });
-        }
-        catch (e_10) {
-            env_10.error = e_10;
-            env_10.hasError = true;
-        }
-        finally {
-            __disposeResources(env_10);
-        }
-    }
-    async function* parseAsync(stream) {
-        const env_11 = { stack: [], error: void 0, hasError: false };
-        try {
-            const sw = __addDisposableResource(env_11, maybeStopWatch('Git.LogParserWithStats.parseAsync', { log: { onlyExit: true, level: 'debug' } }), false);
-            const records = iterateAsyncByDelimiter(stream, recordSep);
-            let count = 0;
-            let entry;
-            let fields;
-            for await (const record of records) {
-                if (!record.length)
-                    continue;
-                count++;
-                entry = {};
-                fields = iterateByDelimiter(record, fieldSep);
-                let fieldCount = 0;
-                let field;
-                while (true) {
-                    field = fields.next();
-                    if (field.done)
-                        break;
-                    if (fieldCount < keys.length) {
-                        entry[keys[fieldCount++]] = field.value;
-                    }
-                    else if (fieldCount === keys.length) {
-                        // Slice off the first newlines between the commit data and files/summary, if any
-                        const summary = field.value.startsWith('\n\n')
-                            ? field.value.substring(2)
-                            : field.value.startsWith('\n')
-                                ? field.value.substring(1)
-                                : field.value;
-                        entry.stats = parseStats(summary);
-                    }
-                    else {
-                        debugger;
-                    }
-                }
-                yield entry;
-            }
-            sw?.stop({ suffix: ` parsed ${count} records` });
-        }
-        catch (e_11) {
-            env_11.error = e_11;
-            env_11.hasError = true;
-        }
-        finally {
-            __disposeResources(env_11);
-        }
-    }
-    return {
-        arguments: args,
-        separators: { record: recordSep, field: fieldSep },
-        parse: parse,
-        parseAsync: parseAsync,
-    };
+	let format = recordFormatSep;
+	const keys = [];
+	for (const key in mapping) {
+		keys.push(key);
+		format += `${mapping[key]}${fieldFormatSep}`;
+	}
+	const args = [`--format=${format}`, "--shortstat"];
+	function parseStats(content) {
+		const stats = {
+			files: 0,
+			additions: 0,
+			deletions: 0
+		};
+		content = content?.trim();
+		if (!content?.length) return {
+			files: 0,
+			additions: 0,
+			deletions: 0
+		};
+		let filesEnd;
+		let filesIndex = content.indexOf(" files changed");
+		if (filesIndex === -1) {
+			filesIndex = content.indexOf(" file changed");
+			if (filesIndex === -1) return stats;
+			filesEnd = filesIndex + 13;
+		} else filesEnd = filesIndex + 14;
+		const filesPart = content.substring(0, filesIndex).trim();
+		stats.files = parseInt(filesPart, 10) || 0;
+		const additionsIndex = content.indexOf(" insertion", filesEnd);
+		if (additionsIndex !== -1) {
+			const spaceIndex = content.lastIndexOf(" ", additionsIndex - 1);
+			if (spaceIndex !== -1) {
+				const additionsPart = content.substring(spaceIndex, additionsIndex).trim();
+				stats.additions = parseInt(additionsPart, 10) || 0;
+			}
+		}
+		const deletionsIndex = content.indexOf(" deletion", filesEnd);
+		if (deletionsIndex !== -1) {
+			const spaceIndex = content.lastIndexOf(" ", deletionsIndex - 1);
+			if (spaceIndex !== -1) {
+				const deletionsPart = content.substring(spaceIndex, deletionsIndex).trim();
+				stats.deletions = parseInt(deletionsPart, 10) || 0;
+			}
+		}
+		return stats;
+	}
+	function* parse(data) {
+		try {
+			var _usingCtx11 = _usingCtx();
+			const sw = _usingCtx11.u(maybeStopWatch("Git.LogParserWithStats.parse", { log: {
+				onlyExit: true,
+				level: "debug"
+			} }));
+			if (!data) {
+				sw?.stop({ suffix: ` no data` });
+				return;
+			}
+			const records = iterateByDelimiter(data, recordSep);
+			let count = 0;
+			let entry;
+			let fields;
+			for (const record of records) {
+				if (!record.length) continue;
+				count++;
+				entry = {};
+				fields = iterateByDelimiter(record, fieldSep);
+				let fieldCount = 0;
+				let field;
+				while (true) {
+					field = fields.next();
+					if (field.done) break;
+					if (fieldCount < keys.length) entry[keys[fieldCount++]] = field.value;
+					else if (fieldCount === keys.length) {
+						const summary = field.value.startsWith("\n\n") ? field.value.substring(2) : field.value.startsWith("\n") ? field.value.substring(1) : field.value;
+						entry.stats = parseStats(summary);
+					} else debugger;
+				}
+				yield entry;
+			}
+			sw?.stop({ suffix: ` parsed ${count} records` });
+		} catch (_) {
+			_usingCtx11.e = _;
+		} finally {
+			_usingCtx11.d();
+		}
+	}
+	async function* parseAsync(stream) {
+		try {
+			var _usingCtx12 = _usingCtx();
+			const sw = _usingCtx12.u(maybeStopWatch("Git.LogParserWithStats.parseAsync", { log: {
+				onlyExit: true,
+				level: "debug"
+			} }));
+			const records = iterateAsyncByDelimiter(stream, recordSep);
+			let count = 0;
+			let entry;
+			let fields;
+			for await (const record of records) {
+				if (!record.length) continue;
+				count++;
+				entry = {};
+				fields = iterateByDelimiter(record, fieldSep);
+				let fieldCount = 0;
+				let field;
+				while (true) {
+					field = fields.next();
+					if (field.done) break;
+					if (fieldCount < keys.length) entry[keys[fieldCount++]] = field.value;
+					else if (fieldCount === keys.length) {
+						const summary = field.value.startsWith("\n\n") ? field.value.substring(2) : field.value.startsWith("\n") ? field.value.substring(1) : field.value;
+						entry.stats = parseStats(summary);
+					} else debugger;
+				}
+				yield entry;
+			}
+			sw?.stop({ suffix: ` parsed ${count} records` });
+		} catch (_) {
+			_usingCtx12.e = _;
+		} finally {
+			_usingCtx12.d();
+		}
+	}
+	return {
+		arguments: args,
+		separators: {
+			record: recordSep,
+			field: fieldSep
+		},
+		parse,
+		parseAsync
+	};
 }
 function createLogParserWithFiles(mapping) {
-    let format = recordFormatSep;
-    const keys = [];
-    for (const key in mapping) {
-        keys.push(key);
-        format += `${mapping[key]}${fieldFormatSep}`;
-    }
-    const args = [`--format=${format}`, '--name-only'];
-    function parseFileNames(content) {
-        const files = [];
-        if (!content?.length)
-            return files;
-        for (const line of iterateByDelimiter(content, '\n')) {
-            const trimmed = line.trim();
-            if (!trimmed)
-                continue;
-            files.push({ path: trimmed });
-        }
-        return files;
-    }
-    function* parse(data) {
-        const env_12 = { stack: [], error: void 0, hasError: false };
-        try {
-            const sw = __addDisposableResource(env_12, maybeStopWatch('Git.createLogParserWithFiles.parse', { log: { onlyExit: true, level: 'debug' } }), false);
-            if (!data) {
-                sw?.stop({ suffix: ` no data` });
-                return;
-            }
-            const records = iterateByDelimiter(data, recordSep);
-            let count = 0;
-            let entry;
-            let fields;
-            for (const record of records) {
-                if (!record.length)
-                    continue;
-                count++;
-                entry = {};
-                fields = iterateByDelimiter(record, fieldSep);
-                let fieldCount = 0;
-                let field;
-                while (true) {
-                    field = fields.next();
-                    if (field.done)
-                        break;
-                    if (fieldCount < keys.length) {
-                        entry[keys[fieldCount++]] = field.value;
-                    }
-                    else if (fieldCount === keys.length) {
-                        // Slice off the first newlines between the commit data and files, if any
-                        const files = field.value.startsWith('\n\n')
-                            ? field.value.substring(2)
-                            : field.value.startsWith('\n')
-                                ? field.value.substring(1)
-                                : field.value;
-                        entry.files = parseFileNames(files);
-                    }
-                    else {
-                        debugger;
-                    }
-                }
-                yield entry;
-            }
-            sw?.stop({ suffix: ` parsed ${count} records` });
-        }
-        catch (e_12) {
-            env_12.error = e_12;
-            env_12.hasError = true;
-        }
-        finally {
-            __disposeResources(env_12);
-        }
-    }
-    async function* parseAsync(stream) {
-        const env_13 = { stack: [], error: void 0, hasError: false };
-        try {
-            const sw = __addDisposableResource(env_13, maybeStopWatch('Git.createLogParserWithFiles.parseAsync', {
-                log: { onlyExit: true, level: 'debug' },
-            }), false);
-            const records = iterateAsyncByDelimiter(stream, recordSep);
-            let count = 0;
-            let entry;
-            let fields;
-            for await (const record of records) {
-                if (!record.length)
-                    continue;
-                count++;
-                entry = {};
-                fields = iterateByDelimiter(record, fieldSep);
-                let fieldCount = 0;
-                let field;
-                while (true) {
-                    field = fields.next();
-                    if (field.done)
-                        break;
-                    if (fieldCount < keys.length) {
-                        entry[keys[fieldCount++]] = field.value;
-                    }
-                    else if (fieldCount === keys.length) {
-                        // Slice off the first newlines between the commit data and files, if any
-                        const files = field.value.startsWith('\n\n')
-                            ? field.value.substring(2)
-                            : field.value.startsWith('\n')
-                                ? field.value.substring(1)
-                                : field.value;
-                        entry.files = parseFileNames(files);
-                    }
-                    else {
-                        debugger;
-                    }
-                }
-                yield entry;
-            }
-            sw?.stop({ suffix: ` parsed ${count} records` });
-        }
-        catch (e_13) {
-            env_13.error = e_13;
-            env_13.hasError = true;
-        }
-        finally {
-            __disposeResources(env_13);
-        }
-    }
-    return {
-        arguments: args,
-        separators: { record: recordSep, field: fieldSep },
-        parse: parse,
-        parseAsync: parseAsync,
-    };
+	let format = recordFormatSep;
+	const keys = [];
+	for (const key in mapping) {
+		keys.push(key);
+		format += `${mapping[key]}${fieldFormatSep}`;
+	}
+	const args = [`--format=${format}`, "--name-only"];
+	function parseFileNames(content) {
+		const files = [];
+		if (!content?.length) return files;
+		for (const line of iterateByDelimiter(content, "\n")) {
+			const trimmed = line.trim();
+			if (!trimmed) continue;
+			files.push({ path: trimmed });
+		}
+		return files;
+	}
+	function* parse(data) {
+		try {
+			var _usingCtx13 = _usingCtx();
+			const sw = _usingCtx13.u(maybeStopWatch("Git.createLogParserWithFiles.parse", { log: {
+				onlyExit: true,
+				level: "debug"
+			} }));
+			if (!data) {
+				sw?.stop({ suffix: ` no data` });
+				return;
+			}
+			const records = iterateByDelimiter(data, recordSep);
+			let count = 0;
+			let entry;
+			let fields;
+			for (const record of records) {
+				if (!record.length) continue;
+				count++;
+				entry = {};
+				fields = iterateByDelimiter(record, fieldSep);
+				let fieldCount = 0;
+				let field;
+				while (true) {
+					field = fields.next();
+					if (field.done) break;
+					if (fieldCount < keys.length) entry[keys[fieldCount++]] = field.value;
+					else if (fieldCount === keys.length) {
+						const files = field.value.startsWith("\n\n") ? field.value.substring(2) : field.value.startsWith("\n") ? field.value.substring(1) : field.value;
+						entry.files = parseFileNames(files);
+					} else debugger;
+				}
+				yield entry;
+			}
+			sw?.stop({ suffix: ` parsed ${count} records` });
+		} catch (_) {
+			_usingCtx13.e = _;
+		} finally {
+			_usingCtx13.d();
+		}
+	}
+	async function* parseAsync(stream) {
+		try {
+			var _usingCtx14 = _usingCtx();
+			const sw = _usingCtx14.u(maybeStopWatch("Git.createLogParserWithFiles.parseAsync", { log: {
+				onlyExit: true,
+				level: "debug"
+			} }));
+			const records = iterateAsyncByDelimiter(stream, recordSep);
+			let count = 0;
+			let entry;
+			let fields;
+			for await (const record of records) {
+				if (!record.length) continue;
+				count++;
+				entry = {};
+				fields = iterateByDelimiter(record, fieldSep);
+				let fieldCount = 0;
+				let field;
+				while (true) {
+					field = fields.next();
+					if (field.done) break;
+					if (fieldCount < keys.length) entry[keys[fieldCount++]] = field.value;
+					else if (fieldCount === keys.length) {
+						const files = field.value.startsWith("\n\n") ? field.value.substring(2) : field.value.startsWith("\n") ? field.value.substring(1) : field.value;
+						entry.files = parseFileNames(files);
+					} else debugger;
+				}
+				yield entry;
+			}
+			sw?.stop({ suffix: ` parsed ${count} records` });
+		} catch (_) {
+			_usingCtx14.e = _;
+		} finally {
+			_usingCtx14.d();
+		}
+	}
+	return {
+		arguments: args,
+		separators: {
+			record: recordSep,
+			field: fieldSep
+		},
+		parse,
+		parseAsync
+	};
 }
+//#endregion
+export { createLogParser, getCommitsLogParser, getContributorsLogParser, getGraphParser, getShaAndDatesLogParser, getShaAndDatesWithFilesLogParser, getShaAndFileRangeLogParser, getShaAndFileSummaryLogParser, getShaAndFilesAndStatsLogParser, getShaAndStatsLogParser, getShaLogParser, getStashFilesOnlyLogParser, getStashLogParser };
+
 //# sourceMappingURL=logParser.js.map