@xynogen/pix-pretty 1.3.3 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-pretty",
-	"version": "1.3.3",
+	"version": "1.4.0",
 	"description": "Enhanced tool output rendering with syntax highlighting, file icons, tree views, FFF search, and paste chip formatting",
 	"type": "module",
 	"main": "src/index.ts",

package/src/fff.ts

@@ -1,15 +1,8 @@
-import { spawn } from "node:child_process";
 import { join } from "node:path";
 
 import type { GrepCursor, GrepMatch } from "@ff-labs/fff-node";
 
-import type {
-	ConstraintParseResult,
-	FffBackedFinder,
-	MultiGrepRipgrepFallbackParams,
-	MultiGrepRipgrepFallbackResult,
-	OptionalFffModule,
-} from "./types.js";
+import type { FffBackedFinder, OptionalFffModule } from "./types.js";
 
 export interface FffState {
 	module: OptionalFffModule | null;
@@ -159,257 +152,3 @@ export function fffFormatGrepText(items: GrepMatch[], limit: number): string {
 
 	return lines.join("\n");
 }
-
-// ---------------------------------------------------------------------------
-// Multi-grep ripgrep fallback
-// ---------------------------------------------------------------------------
-
-const GLOB_META_RE = /[*?[{]/;
-
-function trimSlashes(value: string): string {
-	return value.replace(/^\/+/, "").replace(/\/+$/, "");
-}
-
-function normalizeConstraintPath(value: string): string {
-	let normalized = value.replace(/\\/g, "/").trim();
-	while (normalized.startsWith("./")) normalized = normalized.slice(2);
-	return normalized;
-}
-
-function tokenizeConstraints(constraints: string): ConstraintParseResult {
-	const tokens: string[] = [];
-	let current = "";
-	let quote: '"' | "'" | null = null;
-
-	for (let i = 0; i < constraints.length; i++) {
-		const char = constraints[i];
-		if (quote) {
-			if (char === quote) quote = null;
-			else current += char;
-			continue;
-		}
-
-		if (char === '"' || char === "'") {
-			quote = char;
-			continue;
-		}
-
-		if (/\s/.test(char)) {
-			if (current) {
-				tokens.push(current);
-				current = "";
-			}
-			continue;
-		}
-
-		current += char;
-	}
-
-	if (quote) return { ok: false, error: "unterminated quoted constraint" };
-	if (current) tokens.push(current);
-
-	return { ok: true, globs: [], tokens };
-}
-
-function tokenToRipgrepGlob(
-	token: string,
-): { ok: true; glob: string } | { ok: false; error: string } {
-	let negated = false;
-	let body = token;
-
-	if (body.startsWith("!")) {
-		negated = true;
-		body = body.slice(1);
-	}
-
-	body = normalizeConstraintPath(body);
-	if (!body) return { ok: false, error: `empty constraint token: ${token}` };
-	if (body.includes("\0"))
-		return {
-			ok: false,
-			error: `invalid NUL byte in constraint token: ${token}`,
-		};
-
-	let glob: string;
-	if (body.endsWith("/")) {
-		const dir = trimSlashes(body);
-		if (!dir)
-			return { ok: false, error: `empty directory constraint: ${token}` };
-		glob = `**/${dir}/**`;
-	} else if (GLOB_META_RE.test(body) || body.includes("/")) {
-		glob = body.replace(/^\/+/, "");
-	} else if (body.includes(".")) {
-		glob = `**/${body}`;
-	} else {
-		glob = `**/${body}/**`;
-	}
-
-	return { ok: true, glob: negated ? `!${glob}` : glob };
-}
-
-export function parseMultiGrepConstraints(
-	constraints: string | undefined,
-): ConstraintParseResult {
-	const trimmed = constraints?.trim();
-	if (!trimmed) return { ok: true, globs: [], tokens: [] };
-
-	const tokenized = tokenizeConstraints(trimmed);
-	if (!tokenized.ok) return tokenized;
-
-	const globs: string[] = [];
-	for (const token of tokenized.tokens) {
-		const parsed = tokenToRipgrepGlob(token);
-		if (!parsed.ok) return parsed;
-		globs.push(parsed.glob);
-	}
-
-	return { ok: true, globs, tokens: tokenized.tokens };
-}
-
-function isRipgrepMatchLine(line: string): boolean {
-	return /^.+?:\d+:/.test(line);
-}
-
-function buildRipgrepArgs(
-	params: MultiGrepRipgrepFallbackParams,
-	globs: string[],
-): string[] {
-	const args = [
-		"--line-number",
-		"--with-filename",
-		"--color=never",
-		"--hidden",
-		"--fixed-strings",
-	];
-
-	if (params.ignoreCase) args.push("--ignore-case");
-	if (params.context && params.context > 0)
-		args.push("--context", String(params.context));
-
-	for (const glob of globs) args.push("--glob", glob);
-	for (const pattern of params.patterns) args.push("-e", pattern);
-
-	const searchPath = params.path?.trim();
-	if (searchPath) args.push("--", searchPath);
-
-	return args;
-}
-
-export function getMultiGrepRipgrepArgs(
-	params: MultiGrepRipgrepFallbackParams,
-): ConstraintParseResult & { args?: string[] } {
-	const parsed = parseMultiGrepConstraints(params.constraints);
-	if (!parsed.ok) return parsed;
-	return { ...parsed, args: buildRipgrepArgs(params, parsed.globs) };
-}
-
-export async function runMultiGrepRipgrepFallback(
-	params: MultiGrepRipgrepFallbackParams,
-): Promise<MultiGrepRipgrepFallbackResult> {
-	const parsed = parseMultiGrepConstraints(params.constraints);
-	if (!parsed.ok) throw new Error(`unsupported constraints: ${parsed.error}`);
-
-	const args = buildRipgrepArgs(params, parsed.globs);
-
-	return new Promise((resolve, reject) => {
-		if (params.signal?.aborted) {
-			reject(new Error("Operation aborted"));
-			return;
-		}
-
-		const child = spawn("rg", args, {
-			cwd: params.cwd,
-			stdio: ["ignore", "pipe", "pipe"],
-		});
-		const outputLines: string[] = [];
-		let stderr = "";
-		let buffer = "";
-		let matchCount = 0;
-		let limitReached = false;
-		let killedForLimit = false;
-		let settled = false;
-
-		const settle = (fn: () => void): void => {
-			if (settled) return;
-			settled = true;
-			fn();
-		};
-
-		const stopChild = (dueToLimit = false): void => {
-			if (!child.killed) {
-				killedForLimit = dueToLimit;
-				child.kill();
-			}
-		};
-
-		const onAbort = (): void => stopChild(false);
-		params.signal?.addEventListener("abort", onAbort, { once: true });
-
-		const cleanup = (): void => {
-			params.signal?.removeEventListener("abort", onAbort);
-		};
-
-		const handleLine = (line: string): void => {
-			if (limitReached) return;
-			outputLines.push(line);
-			if (isRipgrepMatchLine(line)) {
-				matchCount++;
-				if (matchCount >= params.limit) {
-					limitReached = true;
-					stopChild(true);
-				}
-			}
-		};
-
-		child.stdout?.on("data", (chunk: Buffer) => {
-			buffer += chunk.toString("utf8");
-			let newlineIndex = buffer.indexOf("\n");
-			while (newlineIndex >= 0) {
-				const line = buffer.slice(0, newlineIndex).replace(/\r$/, "");
-				buffer = buffer.slice(newlineIndex + 1);
-				handleLine(line);
-				newlineIndex = buffer.indexOf("\n");
-			}
-		});
-
-		child.stderr?.on("data", (chunk: Buffer) => {
-			stderr += chunk.toString("utf8");
-		});
-
-		child.on("error", (error: NodeJS.ErrnoException) => {
-			cleanup();
-			const message =
-				error.code === "ENOENT"
-					? "ripgrep (rg) is not available"
-					: `Failed to run ripgrep: ${error.message}`;
-			settle(() => reject(new Error(message)));
-		});
-
-		child.on("close", (code) => {
-			cleanup();
-
-			if (params.signal?.aborted) {
-				settle(() => reject(new Error("Operation aborted")));
-				return;
-			}
-
-			if (buffer && !limitReached) handleLine(buffer.replace(/\r$/, ""));
-
-			if (!killedForLimit && code !== 0 && code !== 1) {
-				const message = stderr.trim() || `ripgrep exited with code ${code}`;
-				settle(() => reject(new Error(message)));
-				return;
-			}
-
-			settle(() =>
-				resolve({
-					text: outputLines.length
-						? outputLines.join("\n")
-						: "No matches found",
-					matchCount,
-					limitReached,
-				}),
-			);
-		});
-	});
-}

package/src/index.ts

@@ -16,7 +16,7 @@
  *   fff.ts            Fast File Finder + cursor store + multi-grep fallback
  *   diff.ts           unified diff parser
  *   diff-render.ts    split/word-level diff renderer
- *   tools/            per-tool registrars (read/bash/ls/find/grep/multi-grep/edit/write)
+ *   tools/            per-tool registrars (read/bash/ls/find/grep/edit/write)
  *   commands/         slash command registrars (fff)
  */
 
@@ -40,7 +40,6 @@ import {
 	fffEnsureFinder,
 	fffState,
 	getPiPrettyFffDir,
-	runMultiGrepRipgrepFallback,
 } from "./fff.js";
 import { clearHighlightCache } from "./highlight.js";
 import { registerBashTool } from "./tools/bash.js";
@@ -49,7 +48,6 @@ import { registerEditTool } from "./tools/edit.js";
 import { registerFindTool } from "./tools/find.js";
 import { registerGrepTool } from "./tools/grep.js";
 import { registerLsTool } from "./tools/ls.js";
-import { registerMultiGrepTool } from "./tools/multi-grep.js";
 import { registerReadTool } from "./tools/read.js";
 import { registerWriteTool } from "./tools/write.js";
 import type {
@@ -134,9 +132,6 @@ export default function piPrettyExtension(
 	const cwd = process.cwd();
 	const home = process.env.HOME ?? "";
 	const sp = (p: string) => shortPath(cwd, home, p);
-	const multiGrepRipgrepFallback =
-		deps?.multiGrepRipgrepFallback ?? runMultiGrepRipgrepFallback;
-
 	// Respect PRETTY_DISABLE_TOOLS env var
 	const disabledTools = new Set(
 		(process.env.PRETTY_DISABLE_TOOLS ?? "")
@@ -224,7 +219,6 @@ export default function piPrettyExtension(
 		TextComponent: TextComponent!,
 		fffState,
 		cursorStore,
-		multiGrepRipgrepFallback,
 	};
 
 	// ── Register tools ──────────────────────────────────────────────────
@@ -244,9 +238,6 @@ export default function piPrettyExtension(
 	if (isToolEnabled("grep") && createGrepTool) {
 		registerGrepTool(pi, createGrepTool, toolCtx);
 	}
-	if (isToolEnabled("multi_grep") && (fffState.module || createGrepTool)) {
-		registerMultiGrepTool(pi, createGrepTool ?? null, toolCtx);
-	}
 	if (isToolEnabled("edit") && createEditTool) {
 		registerEditTool(pi, createEditTool, toolCtx, trackInvalidator);
 	}

package/src/tools/bash.test.ts

@@ -46,11 +46,6 @@ describe("registerBashTool", () => {
 					TextComponent: MockTextComponent as any,
 					fffState: {} as any,
 					cursorStore: {} as any,
-					multiGrepRipgrepFallback: async () => ({
-						text: "",
-						matchCount: 0,
-						limitReached: false,
-					}),
 				},
 			);
 

package/src/tools/context.ts

@@ -1,5 +1,5 @@
 import type { CursorStore, FffState } from "../fff.js";
-import type { MultiGrepRipgrepFallback, TextComponentCtor } from "../types.js";
+import type { TextComponentCtor } from "../types.js";
 
 // ── Shared context passed to each tool registrar ───────────────────────
 
@@ -14,6 +14,4 @@ export interface ToolContext {
 	fffState: FffState;
 	/** FFF cursor store */
 	cursorStore: CursorStore;
-	/** Ripgrep fallback for multi_grep */
-	multiGrepRipgrepFallback: MultiGrepRipgrepFallback;
 }

package/src/types.ts

@@ -20,35 +20,6 @@ export type BundledLanguage = string;
 
 export type BundledTheme = string;
 
-// ---------------------------------------------------------------------------
-// Multi-grep ripgrep fallback contracts
-// ---------------------------------------------------------------------------
-
-export type ConstraintParseResult =
-	| { ok: true; globs: string[]; tokens: string[] }
-	| { ok: false; error: string };
-
-export type MultiGrepRipgrepFallbackParams = {
-	cwd: string;
-	patterns: string[];
-	path?: string;
-	constraints?: string;
-	context?: number;
-	limit: number;
-	ignoreCase: boolean;
-	signal?: AbortSignal;
-};
-
-export type MultiGrepRipgrepFallbackResult = {
-	text: string;
-	matchCount: number;
-	limitReached: boolean;
-};
-
-export type MultiGrepRipgrepFallback = (
-	params: MultiGrepRipgrepFallbackParams,
-) => Promise<MultiGrepRipgrepFallbackResult>;
-
 // ---------------------------------------------------------------------------
 // Config
 // ---------------------------------------------------------------------------
@@ -203,14 +174,6 @@ export type FindParams = FindToolInput;
 
 export type GrepParams = GrepToolInput;
 
-export type MultiGrepParams = {
-	patterns: string[];
-	path?: string;
-	constraints?: string;
-	context?: number;
-	limit?: number;
-};
-
 export type EditRenderState = {
 	_pk?: string;
 	_pt?: string;
@@ -322,5 +285,4 @@ export interface PiPrettyDeps {
 	sdk: PiPrettySdk;
 	TextComponent: TextComponentCtor;
 	fffModule?: OptionalFffModule;
-	multiGrepRipgrepFallback?: MultiGrepRipgrepFallback;
 }

package/src/utils.ts

@@ -258,34 +258,3 @@ export function trimToUndefined(value: string | undefined): string | undefined {
 	const trimmed = value?.trim();
 	return trimmed ? trimmed : undefined;
 }
-
-function escapeRegexLiteral(text: string): string {
-	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-export function buildLiteralAlternationPattern(patterns: string[]): string {
-	return patterns
-		.map(escapeRegexLiteral)
-		.sort((a, b) => b.length - a.length)
-		.join("|");
-}
-
-export function shouldIgnoreCaseForPatterns(patterns: string[]): boolean {
-	return patterns.every((pattern) => pattern.toLowerCase() === pattern);
-}
-
-export function getConstraintBackedPath(
-	constraints: string | undefined,
-): string | undefined {
-	const trimmed = trimToUndefined(constraints);
-	if (
-		!trimmed ||
-		/\s/.test(trimmed) ||
-		trimmed.includes("!") ||
-		trimmed.endsWith("/") ||
-		/[*?[{]/.test(trimmed)
-	) {
-		return undefined;
-	}
-	return trimmed;
-}

package/src/tools/multi-grep.ts

@@ -1,311 +0,0 @@
-import type {
-	ExtensionContext,
-	GrepToolInput,
-	ToolRenderResultOptions,
-} from "@earendil-works/pi-coding-agent";
-
-import { fffFormatGrepText } from "../fff.js";
-import type {
-	GrepResultDetails,
-	MultiGrepParams,
-	PiPrettyApi,
-	RenderContextLike,
-	ThemeLike,
-	ToolFactory,
-	ToolResultLike,
-} from "../types.js";
-import {
-	appendNotices,
-	buildLiteralAlternationPattern,
-	countRipgrepMatches,
-	fillToolBackground,
-	getConstraintBackedPath,
-	getErrorMessage,
-	getTextContent,
-	makeTextResult,
-	normalizeLineEndings,
-	pluralize,
-	renderDimPreview,
-	renderToolError,
-	shouldIgnoreCaseForPatterns,
-	trimToUndefined,
-} from "../utils.js";
-import type { ToolContext } from "./context.js";
-
-export function registerMultiGrepTool(
-	pi: PiPrettyApi,
-	createGrepTool: ToolFactory<GrepToolInput> | null,
-	ctx: ToolContext,
-): void {
-	const {
-		cwd,
-		sp,
-		TextComponent,
-		fffState,
-		cursorStore,
-		multiGrepRipgrepFallback,
-	} = ctx;
-	const multiGrepFallback = createGrepTool ? createGrepTool(cwd) : null;
-
-	pi.registerTool({
-		name: "multi_grep",
-		label: "multi_grep",
-		renderShell: "self",
-		description: [
-			"Search file contents for lines matching ANY of multiple patterns (OR logic).",
-			"Uses SIMD-accelerated Aho-Corasick multi-pattern matching when FFF is available.",
-			"Falls back to ripgrep while preserving literal OR semantics and file constraints when needed.",
-			"Patterns are literal text — never escape special characters.",
-			"Use path to scope a directory/file and constraints for file filtering ('*.rs', 'src/', '!test/').",
-		].join(" "),
-		promptSnippet:
-			"Multi-pattern OR search across file contents (FFF-accelerated with grep fallback)",
-		promptGuidelines: [
-			"Use multi_grep when you need to find multiple identifiers at once (OR logic).",
-			"Include all naming conventions: snake_case, PascalCase, camelCase variants.",
-			"Patterns are literal text. Never escape special characters.",
-			"Use path to scope a directory or file when you need fresh on-disk results.",
-			"Use the constraints parameter for additional file filtering, not inside patterns.",
-		],
-
-		parameters: {
-			type: "object",
-			properties: {
-				patterns: {
-					type: "array",
-					items: { type: "string" },
-					description:
-						"Patterns to search for (OR logic — matches lines containing ANY pattern).",
-				},
-				path: {
-					type: "string",
-					description:
-						"Directory or file path to search (default: current directory)",
-				},
-				constraints: {
-					type: "string",
-					description:
-						"File constraints, e.g. '*.{ts,tsx} !test/' to filter files.",
-				},
-				context: {
-					type: "number",
-					description:
-						"Number of context lines before and after each match (default: 0)",
-				},
-				limit: {
-					type: "number",
-					description: "Maximum number of matches to return (default: 100)",
-				},
-			},
-			required: ["patterns"],
-		},
-
-		async execute(
-			tid: string,
-			params: MultiGrepParams,
-			sig: AbortSignal | undefined,
-			upd: unknown,
-			toolCtx: ExtensionContext,
-		) {
-			if (sig?.aborted) return makeTextResult("Aborted", {});
-
-			if (!params.patterns || params.patterns.length === 0) {
-				return makeTextResult(
-					"Error: patterns array must have at least 1 element",
-					{ error: "empty patterns" },
-				);
-			}
-
-			const effectiveLimit = Math.max(1, params.limit ?? 100);
-			const pattern = buildLiteralAlternationPattern(params.patterns);
-			const requestedPath = trimToUndefined(params.path);
-			const requestedConstraints = trimToUndefined(params.constraints);
-			const effectivePath =
-				requestedPath ?? getConstraintBackedPath(requestedConstraints);
-			const hasNativeConstraints = Boolean(
-				requestedPath || requestedConstraints,
-			);
-
-			// FFF path (no constraints — constrained searches use ripgrep)
-			if (
-				fffState.finder &&
-				!fffState.finder.isDestroyed &&
-				!hasNativeConstraints
-			) {
-				try {
-					const grepResult = fffState.finder.multiGrep({
-						patterns: params.patterns,
-						maxMatchesPerFile: Math.min(effectiveLimit, 50),
-						smartCase: true,
-						cursor: null,
-						beforeContext: params.context ?? 0,
-						afterContext: params.context ?? 0,
-					});
-
-					if (!grepResult.ok) {
-						return makeTextResult(`multi_grep error: ${grepResult.error}`, {
-							error: grepResult.error,
-						});
-					}
-
-					const grep = grepResult.value;
-					const notices: string[] = [];
-					if (fffState.partialIndex)
-						notices.push("Warning: partial file index");
-					if (grep.items.length >= effectiveLimit)
-						notices.push(`${effectiveLimit} limit reached`);
-					if (grep.nextCursor) {
-						const cursorId = cursorStore.store(grep.nextCursor);
-						notices.push(`More results: cursor="${cursorId}"`);
-					}
-
-					const textContent = appendNotices(
-						fffFormatGrepText(grep.items, effectiveLimit),
-						notices,
-					);
-					return makeTextResult<GrepResultDetails>(textContent, {
-						_type: "grepResult",
-						text: textContent,
-						pattern,
-						matchCount: Math.min(grep.items.length, effectiveLimit),
-					});
-				} catch {
-					/* fall through to SDK */
-				}
-			}
-
-			// Ripgrep path (constrained, or FFF unavailable)
-			if (requestedConstraints || !multiGrepFallback) {
-				try {
-					const pathBackedConstraint = Boolean(
-						requestedConstraints &&
-							!requestedPath &&
-							requestedConstraints === effectivePath,
-					);
-					const constraintsForRipgrep = pathBackedConstraint
-						? undefined
-						: requestedConstraints;
-					const notices: string[] = [];
-
-					if (!fffState.finder || fffState.finder.isDestroyed)
-						notices.push("FFF unavailable, used ripgrep fallback");
-					else if (hasNativeConstraints)
-						notices.push("Used ripgrep fallback for constrained search");
-					else notices.push("Used ripgrep fallback");
-
-					const rgResult = await multiGrepRipgrepFallback({
-						cwd,
-						patterns: params.patterns,
-						path: effectivePath,
-						constraints: constraintsForRipgrep,
-						ignoreCase: shouldIgnoreCaseForPatterns(params.patterns),
-						context: params.context,
-						limit: effectiveLimit,
-						signal: sig,
-					});
-					const textContent =
-						normalizeLineEndings(rgResult.text) || "No matches found";
-					if (rgResult.limitReached)
-						notices.push(`${effectiveLimit} limit reached`);
-					const finalText = appendNotices(textContent, notices);
-
-					return makeTextResult<GrepResultDetails>(finalText, {
-						_type: "grepResult",
-						text: finalText,
-						pattern,
-						matchCount: rgResult.matchCount,
-					});
-				} catch (error: unknown) {
-					const message = getErrorMessage(error);
-					return makeTextResult(`multi_grep error: ${message}`, {
-						error: message,
-					});
-				}
-			}
-
-			// SDK grep fallback
-			try {
-				const notices: string[] = [];
-				if (!fffState.finder || fffState.finder.isDestroyed)
-					notices.push("FFF unavailable, used SDK grep fallback");
-
-				const result = await multiGrepFallback.execute(
-					tid,
-					{
-						pattern,
-						path: effectivePath,
-						ignoreCase: shouldIgnoreCaseForPatterns(params.patterns),
-						context: params.context,
-						limit: params.limit,
-					},
-					sig,
-					upd as never,
-					toolCtx,
-				);
-				const textContent =
-					normalizeLineEndings(getTextContent(result)) || "No matches found";
-				const finalText = appendNotices(textContent, notices);
-
-				return makeTextResult<GrepResultDetails>(finalText, {
-					_type: "grepResult",
-					text: finalText,
-					pattern,
-					matchCount: textContent ? countRipgrepMatches(textContent) : 0,
-				});
-			} catch (error: unknown) {
-				const message = getErrorMessage(error);
-				return makeTextResult(`multi_grep error: ${message}`, {
-					error: message,
-				});
-			}
-		},
-
-		renderCall(
-			args: MultiGrepParams,
-			theme: ThemeLike,
-			renderCtx: RenderContextLike,
-		) {
-			const patterns = args.patterns ?? [];
-			const path = args.path
-				? ` ${theme.fg("muted", `in ${sp(args.path)}`)}`
-				: "";
-			const constraints = args.constraints;
-			const text = renderCtx.lastComponent ?? new TextComponent("", 0, 0);
-			let content =
-				theme.fg("toolTitle", theme.bold("multi_grep")) +
-				" " +
-				theme.fg("accent", patterns.map((p) => `"${p}"`).join(", "));
-			content += path;
-			if (constraints) content += theme.fg("muted", ` (${constraints})`);
-			text.setText(fillToolBackground(content));
-			return text;
-		},
-
-		renderResult(
-			result: ToolResultLike<GrepResultDetails | { error?: string }>,
-			_opt: ToolRenderResultOptions,
-			theme: ThemeLike,
-			renderCtx: RenderContextLike,
-		) {
-			const text = renderCtx.lastComponent ?? new TextComponent("", 0, 0);
-
-			if (renderCtx.isError) {
-				text.setText(renderToolError(getTextContent(result) || "Error", theme));
-				return text;
-			}
-
-			const d = result.details;
-			const isGrep = d && "_type" in d && d._type === "grepResult";
-			const output = getTextContent(result) || "searched";
-			text.setText(
-				renderDimPreview(output, theme, {
-					header: isGrep
-						? pluralize(d.matchCount, "match", "matches")
-						: undefined,
-					highlight: isGrep ? d.pattern : undefined,
-				}),
-			);
-			return text;
-		},
-	});
-}