@gitkraken/core-gitlens 0.1.0

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

@@ -0,0 +1,1166 @@
+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 { iterateAsyncByDelimiter, iterateByDelimiter } from '../../utils/string.js';
+const commitsMapping = {
+    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;
+}
+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;
+}
+const graphMapping = {
+    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;
+}
+let _shaParser;
+export 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' };
+let _shaAndDatesParser;
+let _shaAndDatesAndTipsParser;
+export 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;
+}
+const shaMapping = { sha: '%H' };
+let _shaAndFilesAndStatsParser;
+export function getShaAndFilesAndStatsLogParser() {
+    _shaAndFilesAndStatsParser ??= createLogParserWithFilesAndStats(shaMapping);
+    return _shaAndFilesAndStatsParser;
+}
+let _shaAndFileRangeParser;
+export function getShaAndFileRangeLogParser() {
+    _shaAndFileRangeParser ??= createLogParserWithPatch(shaMapping);
+    return _shaAndFileRangeParser;
+}
+let _shaAndFileSummaryParser;
+export function getShaAndFileSummaryLogParser() {
+    _shaAndFileSummaryParser ??= createLogParserWithFileSummary(shaMapping);
+    return _shaAndFileSummaryParser;
+}
+let _shaAndStatsParser;
+export function getShaAndStatsLogParser() {
+    _shaAndStatsParser ??= createLogParserWithStats(shaMapping);
+    return _shaAndStatsParser;
+}
+const stashMapping = {
+    sha: '%H',
+    authorDate: '%at',
+    committedDate: '%ct',
+    parents: '%P',
+    stashName: '%gd',
+    summary: '%gs',
+};
+let _stashParser;
+let _stashParserWithFiles;
+export function getStashLogParser(includeFiles) {
+    if (includeFiles) {
+        _stashParserWithFiles ??= createLogParserWithFilesAndStats(stashMapping);
+        return _stashParserWithFiles;
+    }
+    _stashParser ??= createLogParser(stashMapping);
+    return _stashParser;
+}
+let _stashFilesOnlyParser;
+export 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';
+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;
+                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);
+        }
+    }
+    return {
+        arguments: args,
+        separators: { record: recordSep, field: fieldSep },
+        parse: parse,
+        parseAsync: parseAsync,
+    };
+}
+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_3 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sw = __addDisposableResource(env_3, 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_3) {
+            env_3.error = e_3;
+            env_3.hasError = true;
+        }
+        finally {
+            __disposeResources(env_3);
+        }
+    }
+    async function* parseAsync(stream) {
+        const env_4 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sw = __addDisposableResource(env_4, 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;
+                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);
+        }
+    }
+    return {
+        arguments: args,
+        separators: { record: recordSep, field: fieldSep },
+        parse: parse,
+        parseAsync: 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_5 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sw = __addDisposableResource(env_5, 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_5) {
+            env_5.error = e_5;
+            env_5.hasError = true;
+        }
+        finally {
+            __disposeResources(env_5);
+        }
+    }
+    return {
+        arguments: args,
+        separators: { record: recordSep, field: fieldSep },
+        parse: 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()),
+    };
+}
+function createLogParserSingle(field) {
+    const args = ['-z', `--format=${field}`];
+    function parse(data) {
+        const env_6 = { stack: [], error: void 0, hasError: false };
+        try {
+            const _sw = __addDisposableResource(env_6, maybeStopWatch('Git.LogParserSingle.parse', { log: { onlyExit: true, level: 'debug' } }), false);
+            return data ? iterateByDelimiter(data, '\0') : [];
+        }
+        catch (e_6) {
+            env_6.error = e_6;
+            env_6.hasError = true;
+        }
+        finally {
+            __disposeResources(env_6);
+        }
+    }
+    return { arguments: args, separators: { record: '\0', field: '\0' }, parse: 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_7 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sw = __addDisposableResource(env_7, 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_7) {
+            env_7.error = e_7;
+            env_7.hasError = true;
+        }
+        finally {
+            __disposeResources(env_7);
+        }
+    }
+    async function* parseAsync(stream) {
+        const env_8 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sw = __addDisposableResource(env_8, 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;
+                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);
+        }
+    }
+    return {
+        arguments: args,
+        separators: { record: recordSep, field: fieldSep },
+        parse: parse,
+        parseAsync: 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_9 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sw = __addDisposableResource(env_9, 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_9) {
+            env_9.error = e_9;
+            env_9.hasError = true;
+        }
+        finally {
+            __disposeResources(env_9);
+        }
+    }
+    async function* parseAsync(stream) {
+        const env_10 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sw = __addDisposableResource(env_10, 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_10) {
+            env_10.error = e_10;
+            env_10.hasError = true;
+        }
+        finally {
+            __disposeResources(env_10);
+        }
+    }
+    return {
+        arguments: args,
+        separators: { record: recordSep, field: fieldSep },
+        parse: parse,
+        parseAsync: 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_11 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sw = __addDisposableResource(env_11, 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_11) {
+            env_11.error = e_11;
+            env_11.hasError = true;
+        }
+        finally {
+            __disposeResources(env_11);
+        }
+    }
+    async function* parseAsync(stream) {
+        const env_12 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sw = __addDisposableResource(env_12, 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_12) {
+            env_12.error = e_12;
+            env_12.hasError = true;
+        }
+        finally {
+            __disposeResources(env_12);
+        }
+    }
+    return {
+        arguments: args,
+        separators: { record: recordSep, field: fieldSep },
+        parse: parse,
+        parseAsync: parseAsync,
+    };
+}
+//# sourceMappingURL=logParser.js.map