@loomhelix/deptrail 0.1.0

package/dist/enrich/registry-client.js

@@ -0,0 +1,123 @@
+import { HttpError } from "./http.js";
+export const CORGI_ACCEPT = 'application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*';
+const UNAUTHORIZED_STATUS = 401;
+const FORBIDDEN_STATUS = 403;
+const MALFORMED_REASON = 'returned a malformed packument';
+const FAILURE_REASON_BY_KIND = {
+    timeout: 'did not respond within 30 s',
+    network: 'is unreachable',
+    'too-large': 'returned more than 50 MB',
+    redirects: 'redirected too many times',
+    aborted: 'request was canceled',
+};
+const SCOPE_PREFIX = '@';
+const ESCAPED_SCOPE_SEPARATOR = '%2f';
+function escapedNamePart(part) {
+    const escaped = encodeURIComponent(part);
+    return /^\.+$/.test(escaped) ? escaped.replace(/\./g, '%252E') : escaped;
+}
+function escapedPackageName(name) {
+    const separator = name.indexOf('/');
+    if (!name.startsWith(SCOPE_PREFIX) || separator <= SCOPE_PREFIX.length)
+        return escapedNamePart(name);
+    const scope = escapedNamePart(name.slice(SCOPE_PREFIX.length, separator));
+    return `${SCOPE_PREFIX}${scope}${ESCAPED_SCOPE_SEPARATOR}${encodeURIComponent(name.slice(separator + 1))}`;
+}
+export function packumentUrl(registry, name) {
+    const base = registry.endsWith('/') ? registry : `${registry}/`;
+    return `${base}${escapedPackageName(name)}`;
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isStringRecord(value) {
+    return isPlainObject(value) && Object.values(value).every((entry) => typeof entry === 'string');
+}
+export function isPackageMeta(value) {
+    return (isPlainObject(value) &&
+        isStringRecord(value.distTags) &&
+        Array.isArray(value.versions) &&
+        value.versions.every((version) => typeof version === 'string') &&
+        isStringRecord(value.deprecated) &&
+        isPlainObject(value.manifests) &&
+        Object.values(value.manifests).every(isStringRecord));
+}
+export function metaCovers(meta, versionsInUse) {
+    const known = new Set(meta.versions);
+    return versionsInUse.every((version) => !known.has(version) || version in meta.manifests);
+}
+export function failureReason(error) {
+    return error instanceof HttpError ? FAILURE_REASON_BY_KIND[error.kind] : FAILURE_REASON_BY_KIND.network;
+}
+function declaredRanges(version) {
+    const merged = {};
+    for (const field of ['peerDependencies', 'optionalDependencies', 'dependencies']) {
+        const ranges = version[field];
+        if (!isPlainObject(ranges))
+            continue;
+        for (const [name, range] of Object.entries(ranges)) {
+            if (typeof range === 'string')
+                merged[name] = range;
+        }
+    }
+    return merged;
+}
+function toPackageMeta(packument, versionsInUse, allManifests) {
+    if (!isPlainObject(packument) || !isPlainObject(packument.versions))
+        return undefined;
+    const distTags = isStringRecord(packument['dist-tags']) ? packument['dist-tags'] : {};
+    const deprecated = {};
+    const manifests = {};
+    const inUse = new Set(versionsInUse);
+    for (const [version, entry] of Object.entries(packument.versions)) {
+        if (!isPlainObject(entry))
+            continue;
+        if (typeof entry.deprecated === 'string')
+            deprecated[version] = entry.deprecated;
+        if (allManifests || inUse.has(version))
+            manifests[version] = declaredRanges(entry);
+    }
+    return { distTags, versions: Object.keys(packument.versions), deprecated, manifests };
+}
+function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function failed(reason, authRejected = false) {
+    return { state: 'failed', reason, authRejected };
+}
+export async function fetchPackageMeta(http, request) {
+    const headers = { Accept: CORGI_ACCEPT };
+    if (request.etag !== undefined)
+        headers['If-None-Match'] = request.etag;
+    let response;
+    try {
+        response = await http.request({
+            url: packumentUrl(request.registry, request.name),
+            headers,
+            authorizationFor: request.authorizationFor,
+        });
+    }
+    catch (error) {
+        return failed(failureReason(error));
+    }
+    if (response.status === 304)
+        return { state: 'not-modified' };
+    if (response.status === 404)
+        return { state: 'not-found' };
+    if (response.status === UNAUTHORIZED_STATUS)
+        return failed(`rejected credentials (${response.status})`, true);
+    if (response.status === FORBIDDEN_STATUS)
+        return failed(`rejected credentials (${response.status})`);
+    if (response.status < 200 || response.status >= 300)
+        return failed(`responded with HTTP ${response.status}`);
+    const meta = toPackageMeta(parseJson(response.text), request.versionsInUse, request.allManifests === true);
+    if (meta === undefined)
+        return failed(MALFORMED_REASON);
+    const etag = response.headers.get('etag') ?? undefined;
+    return etag === undefined ? { state: 'ok', meta } : { state: 'ok', meta, etag };
+}

package/dist/enrich/types.js

@@ -0,0 +1 @@
+export const SEVERITY_ORDER = ['critical', 'high', 'moderate', 'unknown', 'low'];

package/dist/git/blob-reader.js

@@ -0,0 +1,180 @@
+import { InvalidObjectIdError, isObjectId } from "./git-commands.js";
+const NEWLINE = 0x0a;
+const STOPPED_PREFIX = 'git cat-file stopped: ';
+const BLOB_TYPE = 'blob';
+const MISSING_MARKER = 'missing';
+const SEPARATOR_BYTES = 1;
+const MAX_HEADER_BYTES = 512;
+const MALFORMED_RESPONSE = 'malformed response';
+const DIGITS_ONLY = /^\d+$/;
+function describeExit(value) {
+    return typeof value === 'number' ? `exited with code ${value}` : 'exited';
+}
+export function createBlobReader(start, limits) {
+    let current = null;
+    let closed = false;
+    let pending = [];
+    let chunks = [];
+    let bufferedBytes = 0;
+    let bodyBytes = null;
+    let bytesToSkip = 0;
+    let timer = null;
+    const clearTimer = () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = null;
+    };
+    const resetStream = () => {
+        chunks = [];
+        bufferedBytes = 0;
+        bodyBytes = null;
+        bytesToSkip = 0;
+    };
+    const fail = (reason) => {
+        const process = current;
+        const rejected = pending;
+        current = null;
+        pending = [];
+        clearTimer();
+        resetStream();
+        process?.kill('SIGTERM');
+        const error = new Error(`${STOPPED_PREFIX}${reason}`);
+        for (const read of rejected)
+            read.reject(error);
+    };
+    const armTimer = () => {
+        clearTimer();
+        if (pending.length === 0)
+            return;
+        timer = setTimeout(() => fail(`no response within ${limits.responseTimeoutMs} ms`), limits.responseTimeoutMs);
+    };
+    const settle = (blob) => {
+        pending.shift()?.resolve(blob);
+    };
+    const skipBytes = () => {
+        while (bytesToSkip > 0 && chunks.length > 0) {
+            const head = chunks[0];
+            if (head.length <= bytesToSkip) {
+                bytesToSkip -= head.length;
+                bufferedBytes -= head.length;
+                chunks.shift();
+            }
+            else {
+                chunks[0] = head.subarray(bytesToSkip);
+                bufferedBytes -= bytesToSkip;
+                bytesToSkip = 0;
+            }
+        }
+    };
+    const keepRest = (rest) => {
+        chunks = rest.length > 0 ? [rest] : [];
+        bufferedBytes = rest.length;
+    };
+    const readHeader = () => {
+        const merged = Buffer.concat(chunks);
+        const newlineAt = merged.indexOf(NEWLINE);
+        if (newlineAt < 0) {
+            if (merged.length > MAX_HEADER_BYTES)
+                fail(MALFORMED_RESPONSE);
+            else
+                keepRest(merged);
+            return false;
+        }
+        const fields = merged.toString('latin1', 0, newlineAt).split(' ');
+        const [, type, sizeText] = fields;
+        const size = Number(sizeText);
+        const isMissing = fields.length === 2 && type === MISSING_MARKER;
+        const isTyped = fields.length === 3 && DIGITS_ONLY.test(sizeText ?? '') && Number.isSafeInteger(size);
+        if (pending.length === 0 || (!isMissing && !isTyped)) {
+            fail(MALFORMED_RESPONSE);
+            return false;
+        }
+        keepRest(merged.subarray(newlineAt + SEPARATOR_BYTES));
+        if (isMissing) {
+            settle(null);
+            return true;
+        }
+        if (type === BLOB_TYPE && size <= limits.maxBlobBytes) {
+            bodyBytes = size;
+            return true;
+        }
+        settle(null);
+        bytesToSkip = size + SEPARATOR_BYTES;
+        return true;
+    };
+    const readBody = (size) => {
+        if (bufferedBytes < size + SEPARATOR_BYTES)
+            return false;
+        const merged = Buffer.concat(chunks);
+        const body = Buffer.from(merged.subarray(0, size));
+        keepRest(merged.subarray(size + SEPARATOR_BYTES));
+        bodyBytes = null;
+        settle(body);
+        return true;
+    };
+    const drain = () => {
+        for (;;) {
+            skipBytes();
+            if (bytesToSkip > 0 || bufferedBytes === 0)
+                return;
+            const progressed = bodyBytes === null ? readHeader() : readBody(bodyBytes);
+            if (!progressed)
+                return;
+        }
+    };
+    const receive = (chunk) => {
+        chunks.push(chunk);
+        bufferedBytes += chunk.length;
+        drain();
+        armTimer();
+    };
+    const launch = () => {
+        const process = start();
+        current = process;
+        process.stdin.on('error', (error) => {
+            if (current === process)
+                fail(error.message);
+        });
+        process.stdout.on('data', (chunk) => {
+            if (current === process)
+                receive(chunk);
+        });
+        process.on('exit', (code) => {
+            if (current !== process)
+                return;
+            if (pending.length > 0)
+                fail(describeExit(code));
+            else
+                current = null;
+        });
+        process.on('error', (error) => {
+            if (current !== process)
+                return;
+            if (pending.length > 0)
+                fail(error instanceof Error ? error.message : 'process error');
+            else
+                current = null;
+        });
+        return process;
+    };
+    return {
+        read(blobId) {
+            return new Promise((resolve, reject) => {
+                if (!isObjectId(blobId))
+                    throw new InvalidObjectIdError(blobId);
+                if (closed)
+                    throw new Error(`${STOPPED_PREFIX}closed`);
+                const process = current ?? launch();
+                const wasIdle = pending.length === 0;
+                pending.push({ resolve, reject });
+                if (wasIdle)
+                    armTimer();
+                process.stdin.write(`${blobId}\n`);
+            });
+        },
+        close() {
+            closed = true;
+            fail('closed');
+        },
+    };
+}

package/dist/git/git-commands.js

@@ -0,0 +1,32 @@
+export const OBJECT_ID = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+export function isObjectId(value) {
+    return OBJECT_ID.test(value);
+}
+export class InvalidObjectIdError extends Error {
+    constructor(value) {
+        super(`not a git object id: ${value}`);
+        this.name = 'InvalidObjectIdError';
+    }
+}
+function requireObjectId(value) {
+    if (!isObjectId(value))
+        throw new InvalidObjectIdError(value);
+    return value;
+}
+export const REF_FORMAT = '%(refname)%00%(objecttype)%00%(objectname)%00%(*objecttype)%00%(*objectname)%00%(committerdate:unix)%00%(*committerdate:unix)%00%(symref)';
+export const GIT_COMMANDS = {
+    version: ['--version'],
+    detect: ['rev-parse', '--show-toplevel', '--show-prefix', '--git-common-dir'],
+    symbolicHead: ['symbolic-ref', '-q', 'HEAD'],
+    headCommit: ['rev-parse', '-q', '--verify', 'HEAD^{commit}'],
+    refs: ['for-each-ref', `--format=${REF_FORMAT}`, 'refs/heads', 'refs/remotes', 'refs/tags'],
+    blobs: ['cat-file', '--batch'],
+};
+export function treeArgs(commit) {
+    return ['ls-tree', '-r', '-t', '-z', '--full-tree', '--end-of-options', requireObjectId(commit)];
+}
+export function mergeBaseArgs(left, right) {
+    return ['merge-base', '--end-of-options', requireObjectId(left), requireObjectId(right)];
+}
+export const GIT_TIMEOUTS = { quick: 10_000, refs: 30_000, slow: 120_000, blob: 60_000 };
+export const GIT_LIMITS = { treeEntries: 2_000_000, blobBytes: 268_435_456, outputBytes: 536_870_912 };

package/dist/git/git-process.js

@@ -0,0 +1,71 @@
+import { spawn as nodeSpawn } from 'node:child_process';
+export class GitFailure extends Error {
+    kind;
+    constructor(kind, message) {
+        super(message);
+        this.name = 'GitFailure';
+        this.kind = kind;
+    }
+}
+const GIT_VARIABLE_PREFIX = 'GIT_';
+const BYTES_PER_MEGABYTE = 1024 * 1024;
+const MILLISECONDS_PER_SECOND = 1000;
+const NOT_STARTED_EXIT_CODE = 1;
+const FIXED_GIT_ENVIRONMENT = { GIT_TERMINAL_PROMPT: '0', GIT_OPTIONAL_LOCKS: '0', GIT_NO_LAZY_FETCH: '1', LC_ALL: 'C' };
+const running = new Set();
+const defaultSpawn = (command, args, options) => nodeSpawn(command, [...args], options);
+export function gitEnvironment(env) {
+    const cleaned = {};
+    for (const [name, value] of Object.entries(env)) {
+        if (value !== undefined && !name.startsWith(GIT_VARIABLE_PREFIX))
+            cleaned[name] = value;
+    }
+    return { ...cleaned, ...FIXED_GIT_ENVIRONMENT };
+}
+export function startGit(options, args) {
+    const spawn = options.spawn ?? defaultSpawn;
+    const child = spawn('git', args, { cwd: options.cwd, env: gitEnvironment(options.env), shell: false, stdio: ['pipe', 'pipe', 'pipe'] });
+    running.add(child);
+    child.once('close', () => running.delete(child));
+    child.once('error', () => running.delete(child));
+    return child;
+}
+export function runGit(options, args, limits) {
+    return new Promise((resolve, reject) => {
+        const child = startGit(options, args);
+        child.stdin?.on('error', () => undefined);
+        child.stdin?.end();
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        let stdoutBytes = 0;
+        let finished = false;
+        const finish = (settleOutcome) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            running.delete(child);
+            settleOutcome();
+        };
+        const abort = (failure) => finish(() => {
+            child.kill('SIGTERM');
+            reject(failure);
+        });
+        const timer = setTimeout(() => abort(new GitFailure('timeout', `git did not finish within ${limits.timeoutMs / MILLISECONDS_PER_SECOND} s`)), limits.timeoutMs);
+        child.stdout?.on('data', (chunk) => {
+            stdoutBytes += chunk.length;
+            if (stdoutBytes > limits.maxBytes) {
+                abort(new GitFailure('too-large', `git output exceeded ${limits.maxBytes / BYTES_PER_MEGABYTE} MB`));
+                return;
+            }
+            stdoutChunks.push(chunk);
+        });
+        child.stderr?.on('data', (chunk) => stderrChunks.push(chunk));
+        child.on('error', (error) => finish(() => reject(error.code === 'ENOENT' ? new GitFailure('not-found', 'git was not found') : new GitFailure('spawn', error.message))));
+        child.on('close', (code) => finish(() => resolve({ code: code ?? NOT_STARTED_EXIT_CODE, stdout: Buffer.concat(stdoutChunks), stderr: Buffer.concat(stderrChunks).toString('utf8') })));
+    });
+}
+export function killGitProcesses() {
+    for (const child of running)
+        child.kill('SIGTERM');
+}

package/dist/git/git-repository.js

@@ -0,0 +1,136 @@
+import { readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { createBlobReader } from "./blob-reader.js";
+import { GIT_COMMANDS, GIT_LIMITS, GIT_TIMEOUTS, mergeBaseArgs, treeArgs } from "./git-commands.js";
+import { GitFailure, runGit, startGit } from "./git-process.js";
+import { parseRefs } from "./ref-list.js";
+import { parseTree } from "./tree-index.js";
+const QUICK_OUTPUT_BYTES = 1024 * 1024;
+const MINIMUM_VERSION = [2, 24, 0];
+const LAZY_FETCH_VERSION = [2, 44, 0];
+const VERSION_PATTERN = /git version (\d+)\.(\d+)(?:\.(\d+))?/;
+const NOT_A_REPOSITORY = 'not a git repository';
+const PROMISOR_SUFFIX = '.promisor';
+const NO_MERGE_BASE_EXIT_CODE = 1;
+const DETECT_LINE_COUNT = 3;
+export function parseGitVersion(output) {
+    const match = VERSION_PATTERN.exec(output);
+    if (!match)
+        return undefined;
+    return [Number(match[1]), Number(match[2]), Number(match[3] ?? 0)];
+}
+export function isGitRepository(value) {
+    return !('unavailable' in value);
+}
+function isBelow(version, limit) {
+    for (let index = 0; index < limit.length; index++) {
+        if (version[index] !== limit[index])
+            return version[index] < limit[index];
+    }
+    return false;
+}
+async function listDirectoryOrEmpty(directory) {
+    try {
+        return await readdir(directory);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+}
+function firstLine(text) {
+    return text.split('\n')[0]?.trim() ?? '';
+}
+function failureMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export async function openGitRepository(options) {
+    const { redact, listDir = listDirectoryOrEmpty, ...processOptions } = options;
+    const quickLimits = { timeoutMs: GIT_TIMEOUTS.quick, maxBytes: QUICK_OUTPUT_BYTES };
+    const failedWith = (result) => new Error(firstLine(redact(result.stderr)) || `git exited with code ${result.code}`);
+    let versionResult;
+    let detectResult;
+    try {
+        versionResult = await runGit(processOptions, GIT_COMMANDS.version, quickLimits);
+    }
+    catch (error) {
+        if (error instanceof GitFailure && error.kind === 'not-found')
+            return { unavailable: 'git was not found on the PATH', quiet: false };
+        return { unavailable: error instanceof GitFailure ? error.message : redact(failureMessage(error)), quiet: false };
+    }
+    const version = parseGitVersion(versionResult.stdout.toString('utf8'));
+    if (!version) {
+        return { unavailable: `Could not read the git version from "${redact(firstLine(versionResult.stdout.toString('utf8')))}"`, quiet: false };
+    }
+    const versionText = version.join('.');
+    if (isBelow(version, MINIMUM_VERSION)) {
+        return { unavailable: `git 2.24 or later is required (found ${versionText})`, quiet: false };
+    }
+    try {
+        detectResult = await runGit(processOptions, GIT_COMMANDS.detect, quickLimits);
+    }
+    catch (error) {
+        return { unavailable: error instanceof GitFailure ? error.message : redact(failureMessage(error)), quiet: false };
+    }
+    if (detectResult.code !== 0) {
+        if (detectResult.stderr.includes(NOT_A_REPOSITORY))
+            return { unavailable: 'This directory is not in a git repository', quiet: true };
+        return { unavailable: firstLine(redact(detectResult.stderr)) || `git exited with code ${detectResult.code}`, quiet: false };
+    }
+    const lines = detectResult.stdout.toString('utf8').split('\n');
+    const prefix = lines[1] ?? '';
+    const commonDirectory = path.resolve(processOptions.cwd, lines[2] ?? '');
+    if (lines.length < DETECT_LINE_COUNT)
+        return { unavailable: 'git printed an unexpected repository description', quiet: false };
+    if (isBelow(version, LAZY_FETCH_VERSION)) {
+        const packFiles = await listDir(path.join(commonDirectory, 'objects', 'pack'));
+        if (packFiles.some((name) => name.endsWith(PROMISOR_SUFFIX))) {
+            return {
+                unavailable: `This is a partial clone, and git ${versionText} could download missing objects while reading. Use git 2.44 or later.`,
+                quiet: false,
+            };
+        }
+    }
+    const blobReader = createBlobReader(() => startGit(processOptions, GIT_COMMANDS.blobs), {
+        maxBlobBytes: GIT_LIMITS.blobBytes,
+        responseTimeoutMs: GIT_TIMEOUTS.blob,
+    });
+    return {
+        prefix,
+        async head() {
+            const symbolic = await runGit(processOptions, GIT_COMMANDS.symbolicHead, quickLimits);
+            const commit = await runGit(processOptions, GIT_COMMANDS.headCommit, quickLimits);
+            if (commit.code !== 0)
+                return undefined;
+            const head = { commit: commit.stdout.toString('utf8').trim() };
+            if (symbolic.code === 0)
+                head.branch = symbolic.stdout.toString('utf8').trim();
+            return head;
+        },
+        async refs() {
+            const result = await runGit(processOptions, GIT_COMMANDS.refs, { timeoutMs: GIT_TIMEOUTS.refs, maxBytes: GIT_LIMITS.outputBytes });
+            if (result.code !== 0)
+                throw failedWith(result);
+            return parseRefs(result.stdout.toString('utf8'));
+        },
+        async tree(commit) {
+            const args = treeArgs(commit);
+            const result = await runGit(processOptions, args, { timeoutMs: GIT_TIMEOUTS.slow, maxBytes: GIT_LIMITS.outputBytes });
+            if (result.code !== 0)
+                throw failedWith(result);
+            return parseTree(result.stdout, prefix, GIT_LIMITS.treeEntries);
+        },
+        async mergeBase(left, right) {
+            const args = mergeBaseArgs(left, right);
+            const result = await runGit(processOptions, args, { timeoutMs: GIT_TIMEOUTS.slow, maxBytes: QUICK_OUTPUT_BYTES });
+            if (result.code === 0)
+                return result.stdout.toString('utf8').trim();
+            if (result.code === NO_MERGE_BASE_EXIT_CODE)
+                return undefined;
+            throw new Error(firstLine(result.stderr) || `git exited with code ${result.code}`);
+        },
+        readBlob: (blobId) => blobReader.read(blobId),
+        close: () => blobReader.close(),
+    };
+}

package/dist/git/ref-list.js

@@ -0,0 +1,78 @@
+import { isObjectId } from "./git-commands.js";
+const PREFIXES = [
+    { prefix: 'refs/heads/', kind: 'branch' },
+    { prefix: 'refs/remotes/', kind: 'remote' },
+    { prefix: 'refs/tags/', kind: 'tag' },
+];
+const KIND_ORDER = { branch: 0, remote: 1, tag: 2 };
+const REMOTE_HEAD = /^refs\/remotes\/[^/]+\/HEAD$/;
+function toFields(record) {
+    const parts = record.split('\0');
+    if (parts.length < 8)
+        return null;
+    const [name, objectType, objectId, peeledType, peeledId, committerSeconds, peeledSeconds, symref] = parts;
+    return { name, objectType, objectId, peeledType, peeledId, committerSeconds, peeledSeconds, symref };
+}
+function toIso(seconds) {
+    if (!/^\d+$/.test(seconds))
+        return null;
+    const date = new Date(Number(seconds) * 1000);
+    return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+function toRef(fields) {
+    const matched = PREFIXES.find(({ prefix }) => fields.name.startsWith(prefix));
+    if (!matched)
+        return null;
+    const short = fields.name.slice(matched.prefix.length);
+    if (short.startsWith('-'))
+        return null;
+    let commit;
+    let seconds;
+    if (fields.objectType === 'commit') {
+        commit = fields.objectId;
+        seconds = fields.committerSeconds;
+    }
+    else if (fields.objectType === 'tag' && fields.peeledType === 'commit') {
+        commit = fields.peeledId;
+        seconds = fields.peeledSeconds;
+    }
+    else
+        return null;
+    if (!isObjectId(commit))
+        return null;
+    const committedAt = toIso(seconds);
+    if (committedAt === null)
+        return null;
+    return { name: fields.name, short, kind: matched.kind, commit, committedAt };
+}
+function compareRefs(left, right) {
+    if (left.kind !== right.kind)
+        return KIND_ORDER[left.kind] - KIND_ORDER[right.kind];
+    if (left.committedAt !== right.committedAt)
+        return left.committedAt < right.committedAt ? 1 : -1;
+    return left.name < right.name ? -1 : left.name > right.name ? 1 : 0;
+}
+export function parseRefs(output) {
+    const refs = [];
+    const remoteHeadTargets = [];
+    for (const record of output.split('\n')) {
+        if (record === '')
+            continue;
+        const fields = toFields(record);
+        if (!fields)
+            continue;
+        if (fields.symref !== '') {
+            if (REMOTE_HEAD.test(fields.name))
+                remoteHeadTargets.push(fields.symref);
+            continue;
+        }
+        const ref = toRef(fields);
+        if (ref)
+            refs.push(ref);
+    }
+    refs.sort(compareRefs);
+    const listed = new Set(refs.map((ref) => ref.name));
+    const defaultBranch = remoteHeadTargets.find((target) => listed.has(target)) ??
+        ['refs/heads/main', 'refs/heads/master'].find((name) => listed.has(name));
+    return { refs, defaultBranch };
+}