@gitkraken/core-gitlens 0.6.0 → 0.7.0

package/src/git-cli/parsers/mergeTreeParser.ts

@@ -1,22 +0,0 @@
-import type { MergeConflictFile } from '../../git/models/mergeConflicts.js';
-import { map } from '../../utils/iterable.js';
-import { maybeStopWatch } from '../../utils/stopwatch.js';
-import { iterateByDelimiter } from '../../utils/string.js';
-
-export interface GitMergeConflict {
-	treeOid: string;
-	conflicts: MergeConflictFile[];
-}
-
-export function parseMergeTreeConflict(data: string): GitMergeConflict {
-	using sw = maybeStopWatch(`Git.parseMergeTreeConflict`, { log: { onlyExit: true, level: 'debug' } });
-
-	const lines = iterateByDelimiter(data, '\0');
-	const treeOid = lines.next();
-
-	const conflicts = treeOid.done ? [] : [...map(lines, l => ({ path: l }))];
-
-	sw?.stop({ suffix: ` parsed ${conflicts.length} conflicts` });
-
-	return { treeOid: treeOid.value, conflicts: conflicts };
-}

package/src/git-cli/parsers/refParser.ts

@@ -1,110 +0,0 @@
-import type { FilteredGitFeatures } from '../../git/features.js';
-import type { RefRecord } from '../../git/models/reference.js';
-import { maybeStopWatch } from '../../utils/stopwatch.js';
-import { iterateByDelimiter } from '../../utils/string.js';
-import type { ExtractAll } from '../../utils/types.js';
-import type { Parser } from './logParser.js';
-
-/**
- * Unified `for-each-ref` mapping covering branches, remotes, and tags in a single pass.
- * Fields inapplicable to a given ref-type come back as empty strings from git.
- *
- * NOTE: When adding a new field that is gated on a git feature flag, mirror the entry in
- * `refMappingSupportsWorktreePath` (and any future variants) — both maps MUST stay aligned
- * so callers can switch parsers based on `git.supported('git:for-each-ref')` without losing
- * field positions.
- */
-const refMapping = {
-	current: `%(HEAD)`,
-	name: `%(refname)`,
-	objectname: `%(objectname)`,
-	peeledObjectname: `%(*objectname)`,
-	upstream: `%(upstream)`,
-	upstreamTracking: `%(upstream:track)`,
-	committerDate: `%(committerdate:iso8601)`,
-	creatorDate: `%(creatordate:iso8601)`,
-	authorDate: `%(authordate:iso8601)`,
-	subject: `%(subject)`,
-	worktreePath: undefined,
-};
-
-const refMappingSupportsWorktreePath = {
-	...refMapping,
-	worktreePath: '%(worktreepath)',
-};
-
-type RefParser = Parser<RefRecord>;
-
-let _refParser: RefParser | undefined;
-let _refParserWithWorktree: RefParser | undefined;
-
-export function getRefParser(supportedFeatures: FilteredGitFeatures<'git:for-each-ref'>[]): RefParser {
-	if (supportedFeatures.includes('git:for-each-ref:worktreePath')) {
-		_refParserWithWorktree ??= createRefParser(refMappingSupportsWorktreePath);
-		return _refParserWithWorktree;
-	}
-
-	_refParser ??= createRefParser(refMapping);
-	return _refParser;
-}
-
-const recordSep = '\x1E'; // ASCII Record Separator character
-const recordFormatSep = '%1E';
-const fieldSep = '\x1D'; // ASCII Group Separator character
-const fieldFormatSep = '%1D';
-
-function createRefParser<T extends Record<string, string | undefined>>(
-	mapping: ExtractAll<T, string | undefined>,
-): Parser<T> {
-	let format = recordFormatSep;
-	const keys: (keyof ExtractAll<T, string>)[] = [];
-	for (const key in mapping) {
-		const value = mapping[key];
-		if (!value) continue;
-
-		keys.push(key);
-		format += `${mapping[key]}${fieldFormatSep}`;
-	}
-
-	const args = [`--format=${format}`];
-
-	function* parse(data: string | Iterable<string> | undefined): Generator<T> {
-		using sw = maybeStopWatch('Git.RefParser.parse', { log: { onlyExit: true, level: 'debug' } });
-
-		if (!data) {
-			sw?.stop({ suffix: ` no data` });
-			return;
-		}
-
-		const records = iterateByDelimiter(data, recordSep);
-
-		let count = 0;
-		let entry: T;
-		let fields: IterableIterator<string>;
-
-		for (const record of records) {
-			if (!record.length) continue;
-
-			count++;
-			entry = {} as unknown as T;
-			fields = iterateByDelimiter(record, fieldSep);
-
-			let fieldCount = 0;
-			let field;
-
-			while (true) {
-				field = fields.next();
-				if (field.done) break;
-				if (fieldCount >= keys.length) continue; // Handle extra newlines at the end
-
-				entry[keys[fieldCount++]] = field.value as T[keyof T];
-			}
-
-			yield entry;
-		}
-
-		sw?.stop({ suffix: ` parsed ${count} records` });
-	}
-
-	return { arguments: args, separators: { record: recordSep, field: fieldSep }, parse: parse };
-}

package/src/git-cli/parsers/reflogParser.ts

@@ -1,153 +0,0 @@
-import type { GitReflog } from '../../git/models/reflog.js';
-import { GitReflogRecord } from '../../git/models/reflog.js';
-import { maybeStopWatch } from '../../utils/stopwatch.js';
-import type { LogParser } from './logParser.js';
-import { createLogParser } from './logParser.js';
-
-// Layer 1 — Raw parser: extracts fields using binary separators via createLogParser
-
-const reflogMapping = {
-	sha: '%H',
-	selector: '%gD',
-	subject: '%gs',
-};
-
-type ReflogLogParser = LogParser<typeof reflogMapping>;
-let _reflogParser: ReflogLogParser | undefined;
-
-export function getReflogParser(): ReflogLogParser {
-	_reflogParser ??= createLogParser(reflogMapping);
-	return _reflogParser;
-}
-
-// Layer 2 — Smart parser: correlates raw entries into GitReflogRecords
-
-function isHEADSelector(selector: string): boolean {
-	return selector === 'HEAD' || selector.endsWith('/HEAD');
-}
-
-export function parseGitRefLog(
-	parser: ReflogLogParser,
-	data: string,
-	repoPath: string,
-	commands: string[],
-	limit: number,
-	totalLimit: number,
-): GitReflog | undefined {
-	using sw = maybeStopWatch(`Git.parseRefLog(${repoPath})`, { log: { onlyExit: true, level: 'debug' } });
-	if (!data) {
-		sw?.stop({ suffix: ` no data` });
-		return undefined;
-	}
-
-	const records: GitReflogRecord[] = [];
-
-	let sha: string;
-	let selector: string;
-	let date: string;
-	let command: string;
-	let commandArgs: string | undefined;
-	let details: string | undefined;
-
-	let head: string | undefined;
-	let headDate: string | undefined;
-	let headSha: string | undefined;
-
-	let count = 0;
-	let total = 0;
-	let recordDate: string | undefined;
-	let record: GitReflogRecord | undefined;
-
-	let idx: number;
-
-	for (const entry of parser.parse(data)) {
-		// Parse selector: "refs/heads/main@{date}" → selector + date
-		idx = entry.selector.indexOf('@{');
-		if (idx === -1) continue;
-
-		selector = entry.selector.substring(0, idx);
-		date = entry.selector.substring(idx + 2, entry.selector.length - 1);
-		sha = entry.sha;
-
-		// Extract command early (everything before the first space or colon)
-		// to allow skipping the full subject parse for filtered-out entries
-		const subject = entry.subject;
-		const spaceIdx = subject.indexOf(' ');
-		const colonIdx = subject.indexOf(':');
-
-		if (spaceIdx === -1 && colonIdx === -1) {
-			command = subject;
-		} else if (colonIdx !== -1 && (spaceIdx === -1 || colonIdx < spaceIdx)) {
-			command = subject.substring(0, colonIdx);
-		} else {
-			command = subject.substring(0, spaceIdx);
-		}
-
-		total++;
-
-		if (record !== undefined) {
-			// If the next record has the same sha as the previous, use it if it is not pointing to just HEAD and the previous is
-			if (
-				sha === record.sha &&
-				(date !== recordDate || !isHEADSelector(record.selector) || isHEADSelector(selector))
-			) {
-				continue;
-			}
-
-			if (sha !== record.sha) {
-				if (
-					head != null &&
-					headDate === recordDate &&
-					headSha === record.sha &&
-					isHEADSelector(record.selector)
-				) {
-					record.update(sha, head);
-				} else {
-					record.update(sha);
-				}
-
-				records.push(record);
-				record = undefined;
-				recordDate = undefined;
-
-				count++;
-				if (limit !== 0 && count >= limit) break;
-			}
-		}
-
-		if (command === 'HEAD') {
-			head = selector;
-			headDate = date;
-			headSha = sha;
-
-			continue;
-		}
-
-		if (commands.includes(command)) {
-			// Only parse args/details when we're actually creating a record
-			if (colonIdx === -1) {
-				commandArgs = spaceIdx !== -1 ? subject.substring(spaceIdx + 1) : undefined;
-				details = undefined;
-			} else {
-				const commandAndArgs = subject.substring(0, colonIdx);
-				idx = commandAndArgs.indexOf(' ');
-				commandArgs = idx !== -1 ? commandAndArgs.substring(idx + 1) : undefined;
-				details = colonIdx < subject.length - 1 ? subject.substring(colonIdx + 1).trimStart() : undefined;
-			}
-
-			record = new GitReflogRecord(repoPath, sha, selector, new Date(date), command, commandArgs, details);
-			recordDate = date;
-		}
-	}
-
-	sw?.stop({ suffix: ` parsed ${records.length} records` });
-
-	return {
-		repoPath: repoPath,
-		records: records,
-		count: count,
-		total: total,
-		limit: limit,
-		hasMore: (limit !== 0 && count >= limit) || (totalLimit !== 0 && total >= totalLimit),
-	};
-}

package/src/git-cli/parsers/remoteParser.ts

@@ -1,95 +0,0 @@
-import type { GitRemoteType } from '../../git/models/remote.js';
-import { GitRemote } from '../../git/models/remote.js';
-import type { RemoteProviderMatcher } from '../../git/models/remoteProvider.js';
-import { parseGitRemoteUrl } from '../../git/utils/remote.utils.js';
-import { maybeStopWatch } from '../../utils/stopwatch.js';
-import { iterateByDelimiter } from '../../utils/string.js';
-
-export function parseGitRemotes(
-	data: string,
-	repoPath: string,
-	remoteProviderMatcher: RemoteProviderMatcher | undefined,
-	defaultRemoteName?: string,
-): GitRemote[] {
-	using sw = maybeStopWatch(`Git.parseRemotes(${repoPath})`, { log: { onlyExit: true, level: 'debug' } });
-	if (!data) {
-		sw?.stop({ suffix: ` no data` });
-		return [];
-	}
-
-	// Format: <name>\t<url> (<type>)
-
-	const remotes = new Map<string, GitRemote>();
-
-	let name: string;
-	let url: string;
-	let type: GitRemoteType;
-
-	let scheme: string;
-	let domain: string;
-	let path: string;
-
-	let remote: GitRemote | undefined;
-
-	let startIndex: number;
-	let endIndex: number;
-
-	for (let line of iterateByDelimiter(data, '\n')) {
-		line = line.trim();
-		if (!line) continue;
-
-		// Parse name
-		startIndex = 0;
-		endIndex = line.indexOf('\t');
-		if (endIndex === -1) continue;
-
-		name = line.substring(startIndex, endIndex);
-
-		// Parse url
-		startIndex = endIndex + 1;
-		endIndex = line.lastIndexOf(' (');
-		if (endIndex === -1) continue;
-
-		url = line.substring(startIndex, endIndex);
-
-		// Parse type
-		startIndex = endIndex + 2;
-		endIndex = line.lastIndexOf(')');
-		if (endIndex === -1) continue;
-
-		type = line.substring(startIndex, endIndex) as GitRemoteType;
-
-		[scheme, domain, path] = parseGitRemoteUrl(url);
-
-		const isDefault = name === defaultRemoteName;
-
-		remote = remotes.get(name);
-		if (remote == null) {
-			const provider = remoteProviderMatcher?.(url, domain, path, scheme);
-			remote = new GitRemote(
-				repoPath,
-				name,
-				scheme,
-				domain,
-				path,
-				[{ url: url, type: type }],
-				provider,
-				isDefault,
-			);
-			remotes.set(name, remote);
-		} else {
-			remote.urls.push({ url: url, type: type });
-			if (remote.provider != null && type !== 'push') continue;
-
-			const provider = remoteProviderMatcher?.(url, domain, path, scheme);
-			if (provider == null) continue;
-
-			remote = new GitRemote(repoPath, name, scheme, domain, path, remote.urls, provider, isDefault);
-			remotes.set(name, remote);
-		}
-	}
-
-	sw?.stop({ suffix: ` parsed ${remotes.size} remotes` });
-
-	return [...remotes.values()];
-}

package/src/git-cli/parsers/shortlogParser.ts

@@ -1,59 +0,0 @@
-import { GitContributor } from '../../git/models/contributor.js';
-import type { GitShortLog } from '../../git/models/shortlog.js';
-import type { GitUser } from '../../git/models/user.js';
-import { isUserMatch } from '../../git/utils/user.utils.js';
-import { iterateByDelimiter } from '../../utils/string.js';
-import type { Mutable } from '../../utils/types.js';
-
-export function parseShortlog(data: string, repoPath: string, currentUser: GitUser | undefined): GitShortLog {
-	if (!data) return { repoPath: repoPath, contributors: [] };
-
-	// Format: [count] [name] [<email>]
-
-	const contributors = new Map<string, Mutable<GitContributor>>();
-
-	for (let line of iterateByDelimiter(data, '\n')) {
-		line = line.trim();
-		if (!line) continue;
-
-		// Find the first tab to separate the count from the rest
-		let index = line.indexOf('\t');
-		if (index === -1) continue;
-
-		// Extract the count portion and the rest of the line
-		const count = parseInt(line.substring(0, index), 10);
-		if (isNaN(count)) continue;
-
-		// Skip any additional spaces between count and name
-		index++;
-		while (index < line.length && line[index] === ' ') {
-			index++;
-		}
-
-		// Look for email enclosed in angle brackets
-		let name: string;
-		let email: string | undefined;
-
-		const emailStartIndex = line.lastIndexOf(' <');
-		const emailEndIndex = line.lastIndexOf('>');
-
-		if (emailStartIndex !== -1 && emailEndIndex !== -1 && emailEndIndex > emailStartIndex) {
-			name = line.substring(index, emailStartIndex);
-			email = line.substring(emailStartIndex + 2, emailEndIndex); // +2 to skip ' <'
-		} else {
-			name = line.substring(index);
-			email = undefined;
-		}
-
-		const key = `${name}|${email ?? ''}`;
-		let contributor = contributors.get(key);
-		if (contributor == null) {
-			contributor = new GitContributor(repoPath, name, email, isUserMatch(currentUser, name, email), count);
-			contributors.set(key, contributor);
-		} else {
-			contributor.contributionCount += count;
-		}
-	}
-
-	return { repoPath: repoPath, contributors: [...contributors.values()] };
-}

package/src/git-cli/parsers/signatureParser.ts

@@ -1,162 +0,0 @@
-import type { CommitSignature, SignatureStatus, SigningFormat, TrustLevel } from '../../git/models/signature.js';
-
-const hexFingerprintRegex = /^[0-9A-Fa-f]{16,40}$/;
-const hexKeyIdRegex = /^[0-9A-Fa-f]{8,16}$/;
-
-/**
- * Git format specifiers for signature information:
- * - %G?: Signature status (G/B/U/X/Y/R/E/N)
- * - %GS: Signer name
- * - %GK: Key ID
- * - %GF: Key fingerprint
- * - %GP: Primary key fingerprint (preferred over %GF)
- * - %GT: Trust level
- * - %GG: Raw verification message
- *
- * Fields separated by ASCII 0x1D (Group Separator)
- */
-export const signatureFormat = '%G?%x1D%GS%x1D%GK%x1D%GF%x1D%GP%x1D%GT%x1D%GG';
-
-const fieldSeparator = '\x1D';
-
-/**
- * Maps Git signature status codes to SignatureStatus enum
- * @param statusCode Git status code from %G?
- * @returns SignatureStatus or undefined for unsigned commits
- */
-function mapStatusCode(statusCode: string): SignatureStatus | undefined {
-	switch (statusCode) {
-		case 'G': // Good signature
-			return 'good';
-		case 'B': // Bad signature
-			return 'bad';
-		case 'U': // Good signature with unknown validity
-			return 'unknown';
-		case 'X': // Good signature that has expired
-		case 'Y': // Good signature made by expired key
-			return 'expired';
-		case 'R': // Good signature made by revoked key
-			return 'revoked';
-		case 'E': // Signature cannot be checked (e.g., missing key)
-			return 'error';
-		case 'N': // No signature
-			return undefined;
-		default:
-			return undefined;
-	}
-}
-
-/**
- * Infers the signing format from signature data patterns
- * @param signer Signer identity string
- * @param keyId Key ID
- * @param fingerprint Key fingerprint
- * @returns Inferred SigningFormat or undefined
- */
-function inferSigningFormat(
-	signer: string | undefined,
-	keyId: string | undefined,
-	fingerprint: string | undefined,
-): SigningFormat | undefined {
-	// X.509: Distinguished Name format with slashes (e.g., "/C=US/O=Org/CN=Name")
-	if (signer?.startsWith('/') && signer.includes('/CN=')) {
-		return 'x509';
-	}
-
-	// SSH: key ID or fingerprint starts with "SHA256:" or "SHA512:" prefix
-	if (
-		keyId?.startsWith('SHA256:') ||
-		keyId?.startsWith('SHA512:') ||
-		fingerprint?.startsWith('SHA256:') ||
-		fingerprint?.startsWith('SHA512:')
-	) {
-		return 'ssh';
-	}
-
-	// GPG/OpenPGP: fingerprints are hex strings (typically 16-40 chars)
-	// Signer format is "Name <email@example.com>"
-	if (fingerprint && hexFingerprintRegex.test(fingerprint)) {
-		return 'gpg';
-	}
-
-	// If signer has angle bracket email format, likely GPG
-	if (signer?.includes('<') && signer?.includes('>')) {
-		return 'gpg';
-	}
-
-	// If keyId looks like a hex GPG key ID (8-16 hex chars)
-	if (keyId && hexKeyIdRegex.test(keyId)) {
-		return 'gpg';
-	}
-
-	return undefined;
-}
-
-/**
- * Maps Git trust level string to TrustLevel enum
- * @param trustStr Git trust level from %GT
- * @returns TrustLevel
- */
-function mapTrustLevel(trustStr: string | undefined): TrustLevel {
-	if (!trustStr) return 'unknown';
-
-	const normalized = trustStr.toLowerCase().trim();
-	switch (normalized) {
-		case 'ultimate':
-			return 'ultimate';
-		case 'fully':
-			return 'full';
-		case 'marginal':
-			return 'marginal';
-		case 'never':
-			return 'never';
-		case 'undefined':
-		case 'unknown':
-		case '':
-			return 'unknown';
-		default:
-			return 'unknown';
-	}
-}
-
-/**
- * Parses Git signature output from format specifiers
- * @param output Raw Git output using signatureFormat
- * @returns CommitSignature or undefined if unsigned
- */
-export function parseSignatureOutput(output: string): CommitSignature | undefined {
-	const trimmed = output.trim();
-	if (!trimmed) return undefined;
-
-	// Split by field separator
-	const fields = trimmed.split(fieldSeparator);
-	if (fields.length !== 7) return undefined;
-
-	const [statusCode, signer, keyId, subkeyFingerprint, primaryFingerprint, trustStr, rawMessage] = fields;
-
-	// Map status code
-	const status = mapStatusCode(statusCode);
-	if (status === undefined) return undefined; // Unsigned commit (N)
-
-	// Prefer primary key fingerprint over subkey fingerprint
-	const fingerprint = primaryFingerprint || subkeyFingerprint || undefined;
-
-	// Map trust level
-	const trustLevel = mapTrustLevel(trustStr);
-
-	// Use raw message as error message for non-good signatures
-	const errorMessage = status !== 'good' && rawMessage ? rawMessage.trim() : undefined;
-
-	// Infer signing format from signature data
-	const format = inferSigningFormat(signer, keyId, fingerprint);
-
-	return {
-		status: status,
-		format: format,
-		signer: signer || undefined,
-		keyId: keyId || undefined,
-		fingerprint: fingerprint,
-		trustLevel: trustLevel,
-		errorMessage: errorMessage,
-	};
-}

package/src/git-cli/parsers/sshSignatureParser.ts

@@ -1,85 +0,0 @@
-import type { SshPublicKey } from '../../git/models/signature.js';
-import { isValidSshKeyData, isValidSshKeyType } from '../../git/utils/sshKey.utils.js';
-
-const sshSigMagic = 'SSHSIG';
-const gpgSigHeaderRegex = /^gpgsig(?:-sha256)? /;
-const sshSigArmorRegex = /-----BEGIN SSH SIGNATURE-----\n([\s\S]*?)\n-----END SSH SIGNATURE-----/;
-// A commit header line: `committer Display Name <email> <unix-ts> <tz>`.
-const committerRegex = /^committer (.*) <([^>]*)> \d+ [-+]\d+$/m;
-
-/**
- * Extracts the committer's name and raw email from a commit object. The raw email (not a mailmapped one) is the
- * principal Git checks an SSH signature against, so it's what an `allowed_signers` entry must use.
- */
-export function extractCommitterFromCommitObject(commitObject: string): { name: string; email: string } | undefined {
-	const match = committerRegex.exec(commitObject);
-	if (match == null) return undefined;
-
-	return { name: match[1], email: match[2] };
-}
-
-/**
- * Extracts the signer's full SSH public key from a commit object's `gpgsig` SSH signature.
- *
- * A commit signed with `gpg.format=ssh` stores an armored `-----BEGIN SSH SIGNATURE-----` (SSHSIG) blob in its
- * `gpgsig` header, and the SSHSIG wire format embeds the signer's full public key — exactly what an `allowed_signers`
- * entry requires. (`git log`'s signature fields only expose the key fingerprint, never the full key.)
- *
- * @param commitObject Raw commit object text, as produced by `git cat-file commit <sha>`
- * @returns The key type and base64 public-key blob, or `undefined` if the commit isn't SSH-signed or can't be parsed.
- */
-export function extractSshPublicKeyFromCommitObject(commitObject: string): SshPublicKey | undefined {
-	const armored = extractArmoredSignature(commitObject);
-	if (armored == null) return undefined;
-
-	const buffer = Buffer.from(armored, 'base64');
-
-	// SSHSIG wire format (see OpenSSH PROTOCOL.sshsig):
-	//   byte[6] MAGIC "SSHSIG" | uint32 version | string publickey | string namespace | ...
-	// where each `string` is a big-endian uint32 length followed by that many bytes.
-	if (buffer.length < 10 || buffer.toString('latin1', 0, 6) !== sshSigMagic) return undefined;
-
-	// `publickey` is the first length-prefixed string, after the 6-byte magic and 4-byte version.
-	const pubKeyBlob = readSshString(buffer, 10);
-	if (pubKeyBlob == null) return undefined;
-
-	// The public-key blob itself begins with its key type as a length-prefixed string.
-	const keyType = readSshString(pubKeyBlob, 0)?.toString('utf8');
-	if (!keyType) return undefined;
-
-	const keyData = pubKeyBlob.toString('base64');
-	// The signature blob is attacker-controllable (Git stores it verbatim and never verifies it on read), so reject
-	// anything that isn't a recognized key type / well-formed base64 before it can become an `allowed_signers` entry.
-	if (!isValidSshKeyType(keyType) || !isValidSshKeyData(keyData)) return undefined;
-
-	return { keyType: keyType, keyData: keyData };
-}
-
-/** Extracts and concatenates the base64 body of the armored SSH signature from a commit's `gpgsig` header. */
-function extractArmoredSignature(commitObject: string): string | undefined {
-	const lines = commitObject.split('\n');
-	const start = lines.findIndex(l => gpgSigHeaderRegex.test(l));
-	if (start === -1) return undefined;
-
-	// The header value, followed by continuation lines (each indented with a single leading space).
-	const block = [lines[start].replace(gpgSigHeaderRegex, '')];
-	for (let i = start + 1; i < lines.length; i++) {
-		if (!lines[i].startsWith(' ')) break;
-
-		block.push(lines[i].slice(1));
-	}
-
-	const match = sshSigArmorRegex.exec(block.join('\n'));
-	return match != null ? match[1].replace(/\s+/g, '') : undefined;
-}
-
-/** Reads a length-prefixed SSH wire-format string (big-endian uint32 length + bytes) at `offset`. */
-function readSshString(buffer: Buffer, offset: number): Buffer | undefined {
-	if (offset + 4 > buffer.length) return undefined;
-
-	const start = offset + 4;
-	const end = start + buffer.readUInt32BE(offset);
-	if (end > buffer.length) return undefined;
-
-	return buffer.subarray(start, end);
-}