zidane 5.6.14 → 5.7.4

package/dist/edit-utils-DnfNoj16.js

@@ -0,0 +1,574 @@
+//#region src/compact/utils.ts
+/**
+* Shared utilities for the compact module — extracted so the runner
+* (`compact.ts`) and the restoration helper (`restore.ts`) don't carry
+* redundant copies of the same low-level math.
+*
+* Kept zero-dependency by design: no Node/Bun imports, no zidane types
+* either. Both `utf8ByteLength` and `estimateTokens` are total
+* functions of a single `string` argument, so they're trivially
+* portable to a worker/browser context if the compact module ever
+* needs to render outside Node.
+*/
+/**
+* UTF-8 byte length, matching `Buffer.byteLength(text, 'utf-8')` but
+* without pulling `node:buffer` for a one-liner. Stable for surrogate
+* pairs — a high+low surrogate pair counts as a single 4-byte sequence
+* (not 2 × 3-byte). Cheap to call in hot loops.
+*
+* Pure. Identical bytes for identical input across every JS runtime.
+*/
+function utf8ByteLength(text) {
+	let bytes = 0;
+	for (let i = 0; i < text.length; i++) {
+		const code = text.charCodeAt(i);
+		if (code < 128) bytes += 1;
+		else if (code < 2048) bytes += 2;
+		else if (code >= 55296 && code <= 56319) {
+			bytes += 4;
+			i++;
+		} else bytes += 3;
+	}
+	return bytes;
+}
+/** Same constant Claude Code's `CONTEXT_MANAGEMENT.md` documents. */
+const BYTES_PER_TOKEN = 4;
+/**
+* Approximate token count for `text`. Mirrors Claude Code's
+* `BYTES_PER_TOKEN = 4` heuristic — acceptable for budget arithmetic
+* (sizing summarization scopes, enforcing per-file caps in restoration).
+*
+* Accurate to ~10% on English + code. Use a real tokenizer when exact
+* counts matter (cost reporting, hard caps); this is for budget gates
+* where being off by 10% is fine.
+*
+* Pure. Exported so callers (TUI, SDK consumers) can do their own
+* pre-budgeting against the same heuristic the harness uses internally.
+*/
+function estimateTokens(text) {
+	return Math.ceil(text.length / 4);
+}
+//#endregion
+//#region src/chat/context-breakdown.ts
+/**
+* Context-usage breakdown — pure transforms.
+*
+* Turns a {@link ContextSnapshot} (the raw pieces the agent assembled for a
+* run: system prompt, wire tools, deferred tools, MCP tools/instructions,
+* skills catalog, ...) plus the real last-turn token total into a categorized
+* {@link ContextBreakdown} the TUI panel / GUI popover render.
+*
+* No React, no node — a browser-context renderer imports these via
+* `zidane/chat/pure`. The snapshot is captured main-side (TUI direct, GUI in
+* `main/chat`) because building it reads provider/agent state; only the pure
+* shaping lives here.
+*
+* Accuracy: per-category counts are estimates when no provider `countTokens`
+* is available — the heuristic ({@link estimateTokens}, ~4 bytes/token) sizes
+* each static segment and the bar is reconciled so it always sums to the real
+* last-turn total (`conversation = realTotal - sum(static)`). When a provider
+* exposes exact counts (Anthropic, OpenAI), the caller passes them in via
+* {@link ContextSnapshot.exact} and the corresponding categories drop their
+* `estimated` flag. Exact buckets (free space, autocompact buffer) are never
+* estimated.
+*/
+const LABELS = {
+	systemPrompt: "System prompt",
+	rules: "Rules (AGENTS.md)",
+	tools: "Tool definitions",
+	mcpTools: "MCP tools",
+	mcpInstructions: "MCP instructions",
+	skills: "Skills",
+	subagentDefs: "Subagent definitions",
+	conversation: "Conversation",
+	mcpToolsDeferred: "MCP tools (deferred)",
+	toolsDeferred: "System tools (deferred)",
+	autocompactBuffer: "Autocompact buffer",
+	freeSpace: "Free space"
+};
+/** Sum the heuristic token sizes of a list of strings. */
+function sumEstimate(parts) {
+	let total = 0;
+	for (const p of parts) total += estimateTokens(p);
+	return total;
+}
+function mcpGroupTokens(group) {
+	const items = group.tools.map((t) => ({
+		id: `${group.server}:${t.name}`,
+		label: t.name,
+		tokens: estimateTokens(t.json),
+		estimated: true
+	}));
+	let total = 0;
+	for (const it of items) total += it.tokens;
+	return {
+		total,
+		items
+	};
+}
+/**
+* Shape a {@link ContextSnapshot} into a render-ready {@link ContextBreakdown}.
+*
+* Live categories (system prompt, tools, MCP tools/instructions, skills,
+* memory, subagent defs, conversation) sum to `snapshot.used` — `conversation`
+* absorbs the remainder so the bar matches the provider-reported total exactly.
+* Deferred + autocompact + free-space buckets follow.
+*
+* When `snapshot.exact` carries provider counts, the matching categories use
+* them (system, tools) and drop their `estimated` flag; everything else stays
+* on the heuristic.
+*/
+function buildContextBreakdown(snapshot) {
+	const exact = snapshot.exact;
+	const systemExact = typeof exact?.system === "number";
+	const rulesTokens = snapshot.rulesBlock ? estimateTokens(snapshot.rulesBlock) : 0;
+	const rulesItems = (snapshot.rulesFiles ?? []).map((f) => ({
+		id: f.path,
+		label: f.path,
+		tokens: 0,
+		estimated: false
+	}));
+	const skillsTokens = snapshot.skillsCatalog ? estimateTokens(snapshot.skillsCatalog) : 0;
+	const mcpInstructionsTokens = snapshot.mcpInstructions ? estimateTokens(snapshot.mcpInstructions) : 0;
+	const subagentTokens = snapshot.subagentDefs ? estimateTokens(snapshot.subagentDefs) : 0;
+	const embeddedSubsections = rulesTokens + skillsTokens + mcpInstructionsTokens + subagentTokens;
+	const systemTotal = systemExact ? exact.system : estimateTokens(snapshot.system);
+	const baseSystemTokens = Math.max(0, systemTotal - embeddedSubsections);
+	const nativeToolsEst = sumEstimate(snapshot.toolsJson);
+	const mcpDisclosed = snapshot.mcpGroups.map(mcpGroupTokens);
+	const mcpToolsEst = mcpDisclosed.reduce((a, g) => a + g.total, 0);
+	let nativeToolsTokens = nativeToolsEst;
+	let mcpToolsTokens = mcpToolsEst;
+	let toolsEstimated = true;
+	if (systemExact && typeof exact?.systemAndTools === "number") {
+		const exactToolsTotal = Math.max(0, exact.systemAndTools - exact.system);
+		const estTotal = nativeToolsEst + mcpToolsEst;
+		if (estTotal > 0) {
+			nativeToolsTokens = Math.round(exactToolsTotal * (nativeToolsEst / estTotal));
+			mcpToolsTokens = exactToolsTotal - nativeToolsTokens;
+		} else {
+			nativeToolsTokens = exactToolsTotal;
+			mcpToolsTokens = 0;
+		}
+		toolsEstimated = false;
+	}
+	const live = [];
+	const push = (id, tokens, estimated, items) => {
+		if (tokens <= 0 && !items?.length) return;
+		live.push({
+			id,
+			label: LABELS[id],
+			tokens: Math.max(0, tokens),
+			estimated,
+			...items?.length ? { items } : {}
+		});
+	};
+	push("systemPrompt", baseSystemTokens, !systemExact);
+	push("rules", rulesTokens, true, rulesItems);
+	push("skills", skillsTokens, true);
+	push("mcpInstructions", mcpInstructionsTokens, true);
+	push("subagentDefs", subagentTokens, true);
+	push("tools", nativeToolsTokens, toolsEstimated);
+	push("mcpTools", mcpToolsTokens, toolsEstimated, mcpDisclosed.flatMap((g) => g.items));
+	const accountedStatic = live.reduce((a, c) => a + c.tokens, 0);
+	push("conversation", Math.max(0, snapshot.used - accountedStatic), !(systemExact && !toolsEstimated));
+	const deferred = [];
+	const deferredNativeTools = sumEstimate(snapshot.deferredToolsJson);
+	if (deferredNativeTools > 0) deferred.push({
+		id: "toolsDeferred",
+		label: LABELS.toolsDeferred,
+		tokens: deferredNativeTools,
+		estimated: true,
+		deferred: true
+	});
+	const deferredMcp = snapshot.deferredMcpGroups.map(mcpGroupTokens);
+	const deferredMcpTotal = deferredMcp.reduce((a, g) => a + g.total, 0);
+	if (deferredMcpTotal > 0) deferred.push({
+		id: "mcpToolsDeferred",
+		label: LABELS.mcpToolsDeferred,
+		tokens: deferredMcpTotal,
+		estimated: true,
+		deferred: true,
+		items: deferredMcp.flatMap((g) => g.items)
+	});
+	if (snapshot.autocompactBuffer > 0) deferred.push({
+		id: "autocompactBuffer",
+		label: LABELS.autocompactBuffer,
+		tokens: snapshot.autocompactBuffer,
+		estimated: false,
+		deferred: true
+	});
+	const free = Math.max(0, snapshot.effectiveWindow - snapshot.used);
+	deferred.push({
+		id: "freeSpace",
+		label: LABELS.freeSpace,
+		tokens: free,
+		estimated: false,
+		deferred: true
+	});
+	const categories = [...live, ...deferred];
+	const hasEstimates = live.some((c) => c.estimated && c.tokens > 0);
+	const fraction = snapshot.effectiveWindow > 0 ? Math.max(0, Math.min(1, snapshot.used / snapshot.effectiveWindow)) : 0;
+	return {
+		modelId: snapshot.modelId,
+		used: snapshot.used,
+		effectiveWindow: snapshot.effectiveWindow,
+		fraction,
+		categories,
+		hasEstimates,
+		...snapshot.usage ? { usage: snapshot.usage } : {},
+		...snapshot.activeSkills?.length ? { activeSkills: snapshot.activeSkills } : {}
+	};
+}
+//#endregion
+//#region src/chat/format.ts
+/**
+* Resolve the user's home directory from env (no static os-module import),
+* so this module stays node-free and importable from a browser-context
+* renderer (Electron's renderer, Vite) via `zidane/chat/pure`. Reads the
+* platform env vars Node/Electron populate; returns '' when unavailable
+* (renderer), in which case `compactPath` falls back to the verbatim path.
+*/
+function resolveHome() {
+	const env = globalThis.process?.env;
+	return env?.HOME ?? env?.USERPROFILE ?? "";
+}
+/** Compact token formatter — 12_415 → "12.4k", 1_234_567 → "1.23M". */
+function fmtTokens(n) {
+	if (n < 1e3) return String(n);
+	if (n < 1e6) return `${(n / 1e3).toFixed(n < 1e4 ? 2 : 1)}k`;
+	return `${(n / 1e6).toFixed(2)}M`;
+}
+/** Compact relative-time formatter — "just now / 5m / 3h / 2d". */
+function ageString(ts, now = Date.now()) {
+	const m = Math.floor((now - ts) / 6e4);
+	if (m < 1) return "just now";
+	if (m < 60) return `${m}m ago`;
+	const h = Math.floor(m / 60);
+	if (h < 24) return `${h}h ago`;
+	return `${Math.floor(h / 24)}d ago`;
+}
+/** Six-char short form of a session id for headers and lists. */
+function shortId(id) {
+	return id.replace(/-/g, "").slice(0, 6);
+}
+/**
+* Single-line preview of a multi-line string, capped at `max` chars and
+* ellipsis-terminated when truncated.
+*
+* Whitespace runs (newlines, tabs, multiple spaces) collapse into one
+* space so the rendered output stays on a single visual row no matter
+* how the input was shaped. Used by every transcript "preview" surface
+* (spawn-start task, `tool: shell (background): <command>`,
+* `<task-notification>` summary line, etc.) — without the whitespace
+* collapse, a 60-char `slice` on a string with an inline `\n\n` paints
+* the second paragraph below the first, producing the visible
+* "preview text spills onto multiple lines" bug (and, downstream,
+* misaligned spawn markers when the wrapped lines collide with
+* other events).
+*
+* Reserves one slot for the `…` so the displayed width is exactly
+* `max` when truncation kicks in.
+*/
+function previewLine(s, max) {
+	const single = s.replace(/\s+/g, " ").trim();
+	if (single.length <= max) return single;
+	return `${single.slice(0, max - 1)}…`;
+}
+/**
+* Compact human-readable duration formatter shared by background-task
+* surfaces (the `<task-notification>` summary, the TUI banner, the
+* `shell_kill` tool result, etc.).
+*
+* Format ladder:
+*   - `< 1s`   →  `"Nms"`
+*   - `< 10s`  →  `"N.Ns"` (one decimal)
+*   - `< 1m`   →  `"Ns"`   (whole seconds)
+*   - `< 1h`   →  `"NmNs"` / `"Nm"` when seconds round to 0
+*   - `≥ 1h`   →  `"NhNm"` / `"Nh"` when minutes round to 0
+*
+* Single source of truth so a 60s task renders the same across the
+* model-facing XML summary and the user-facing banner. Earlier
+* separate formatters disagreed (XML said `"60.0s"`, banner said `"1m"`)
+* which was confusing to the user reading both side by side.
+*/
+function formatDuration(ms) {
+	if (ms < 0) ms = 0;
+	if (ms < 1e3) return `${ms}ms`;
+	if (ms < 6e4) return `${(ms / 1e3).toFixed(ms < 1e4 ? 1 : 0)}s`;
+	const minutes = Math.floor(ms / 6e4);
+	const seconds = Math.floor(ms % 6e4 / 1e3);
+	if (minutes < 60) return seconds > 0 ? `${minutes}m${seconds}s` : `${minutes}m`;
+	const hours = Math.floor(minutes / 60);
+	const remMinutes = minutes % 60;
+	return remMinutes > 0 ? `${hours}h${remMinutes}m` : `${hours}h`;
+}
+/**
+* Status label for a terminated background task — `"exited <code>"`
+* for natural exits, `"killed"` (with the signal name when known)
+* for our-issued SIGTERMs.
+*
+* Pulled out as its own function so the `<task-notification>` XML
+* summary, the TUI banner header, the `shell_kill` tool result, and
+* future surfaces all read the same string.
+*/
+function formatTaskStatus(info) {
+	return info.status === "killed" ? `killed${info.signal ? ` (${info.signal})` : ""}` : `exited ${info.exitCode}`;
+}
+/**
+* One-line summary of a terminated background task — the shape used by
+* the `<task-notification>` XML's `<summary>` tag AND the TUI banner's
+* `event.text` fallback string. Three dot-separated segments:
+*
+*   `<command preview · status · duration>`
+*
+* Centralizes the format so live + replay + wire all agree, and so a
+* future cosmetic tweak (separator glyph, segment ordering) lands in
+* exactly one place.
+*/
+function formatTaskSummary(info, maxCommandChars = 80) {
+	return `${previewLine(info.command, maxCommandChars)} · ${formatTaskStatus(info)} · ${formatDuration(info.durationMs)}`;
+}
+/**
+* Compact an absolute path for display: replace the user's `$HOME`
+* prefix with `~` (so `/Users/yael/Code/zidane` → `~/Code/zidane`),
+* and optionally left-truncate with an ellipsis when the result
+* still exceeds `maxWidth` (so the path's *tail* — the part the user
+* recognizes — stays visible: `…/zidane` rather than `/Users/yaeluil…`).
+*
+* `maxWidth` is the maximum *display width* in cells. Omit to skip
+* truncation. Paths outside `$HOME` are returned verbatim modulo
+* truncation. The ellipsis (`…`) counts as one cell.
+*
+* `home` overrides `os.homedir()` for tests; production callers leave
+* it undefined and pay the cheap one-syscall lookup per call.
+*/
+function compactPath(path, maxWidth, home) {
+	const h = home ?? resolveHome();
+	let display = path;
+	if (h) {
+		if (path === h) display = "~";
+		else if (path.startsWith(`${h}/`)) display = `~${path.slice(h.length)}`;
+	}
+	if (maxWidth !== void 0 && maxWidth > 1 && display.length > maxWidth) return `…${display.slice(display.length - maxWidth + 1)}`;
+	return display;
+}
+//#endregion
+//#region src/tools/edit-utils.ts
+/**
+* Internal helpers shared between the `edit` and `multi_edit` tools.
+*
+* Not part of the public API — intentionally not re-exported from `tools/index.ts`
+* or the package barrel.
+*/
+/**
+* Count exact (non-overlapping) occurrences of `needle` in `haystack`.
+* Returns 0 for an empty needle — both edit tools reject empty `old_string`
+* up front, so this branch is defensive rather than semantic.
+*/
+function countExactMatches(haystack, needle) {
+	if (needle.length === 0) return 0;
+	let count = 0;
+	let idx = 0;
+	while (true) {
+		const next = haystack.indexOf(needle, idx);
+		if (next === -1) break;
+		count++;
+		idx = next + needle.length;
+	}
+	return count;
+}
+/** Map curly quotes (any of the four) to their straight ASCII equivalents. */
+function normalizeQuotes(str) {
+	return str.replaceAll("‘", "'").replaceAll("’", "'").replaceAll("“", "\"").replaceAll("”", "\"");
+}
+/**
+* Substitutions Anthropic's API applies to assistant output before the model
+* sees it. The model emits the sanitized form; the file on disk contains the
+* unsanitized form. We undo the substitutions on `old_string` so the search
+* lands on the actual file contents.
+*
+* Verbatim from `claude-code/tools/FileEditTool/utils.ts`.
+*/
+const DESANITIZATIONS = [
+	["<fnr>", "<function_results>"],
+	["<n>", "<name>"],
+	["</n>", "</name>"],
+	["<o>", "<output>"],
+	["</o>", "</output>"],
+	["<e>", "<error>"],
+	["</e>", "</error>"],
+	["<s>", "<system>"],
+	["</s>", "</system>"],
+	["<r>", "<result>"],
+	["</r>", "</result>"],
+	["< META_START >", "<META_START>"],
+	["< META_END >", "<META_END>"],
+	["< EOT >", "<EOT>"],
+	["< META >", "<META>"],
+	["< SOS >", "<SOS>"],
+	["\n\nH:", "\n\nHuman:"],
+	["\n\nA:", "\n\nAssistant:"]
+];
+/**
+* Apply the SDK desanitization table to a string. Exported so the edit tools
+* can apply it to `new_string` whenever `old_string` matched via a
+* desanitize-class fallback — keeps the file's unsanitized form on disk
+* instead of writing the model's abbreviated form back.
+*/
+function desanitize(s) {
+	let out = s;
+	for (const [from, to] of DESANITIZATIONS) out = out.replaceAll(from, to);
+	return out;
+}
+/**
+* Strip line-number prefixes from each line of a needle, used as a recovery
+* fallback when the model pastes a `read_file` chunk verbatim into
+* `old_string` — the on-disk file doesn't carry the metadata prefix.
+*
+* Accepts three separator characters so a model that learned on a different
+* agent stack still works here: `\t` (Claude Code compact, our default),
+* `|`, and `→`. Pattern: optional leading whitespace, 1-9 digits, then one
+* of `\t | →`. The 9-digit ceiling covers files up to ~1B lines without
+* overshooting into legitimate `\d{N}<sep>` content like Markdown table
+* cells with long numeric IDs.
+*/
+const LINE_NUMBER_PREFIX_RE = /^[ \t]*\d{1,9}[\t|\u2192]/gm;
+function stripLineNumberPrefixes(s) {
+	return s.replace(LINE_NUMBER_PREFIX_RE, "");
+}
+/**
+* Search `target` in `normFile` and slice the matching span out of the
+* original `haystack`, counting all non-overlapping occurrences. `normFile`
+* is the haystack with whatever transform (quotes / desanitize / combined)
+* was applied to make the indices align — slicing the original haystack
+* preserves the file's actual typography so `replace_all` writes back the
+* file's form, not the model's.
+*
+* Pre-condition: `normFile.length === haystack.length` (every transform
+* we use is one-to-one). Returns null on miss.
+*/
+function locateAndCount(haystack, normFile, target, via) {
+	const idx = normFile.indexOf(target);
+	if (idx === -1) return null;
+	const actual = haystack.slice(idx, idx + target.length);
+	let occ = 0;
+	let cursor = 0;
+	while (true) {
+		const next = normFile.indexOf(target, cursor);
+		if (next === -1) break;
+		occ++;
+		cursor = next + target.length;
+	}
+	return {
+		actual,
+		occurrences: occ,
+		via
+	};
+}
+function resolveOldString(haystack, needle) {
+	const exact = countExactMatches(haystack, needle);
+	if (exact > 0) return {
+		actual: needle,
+		occurrences: exact,
+		via: "exact"
+	};
+	const normNeedle = normalizeQuotes(needle);
+	const normFile = normalizeQuotes(haystack);
+	if (normNeedle !== needle || normFile !== haystack) {
+		const m = locateAndCount(haystack, normFile, normNeedle, "quotes");
+		if (m) return m;
+	}
+	const desan = desanitize(needle);
+	if (desan !== needle) {
+		const desanCount = countExactMatches(haystack, desan);
+		if (desanCount > 0) return {
+			actual: desan,
+			occurrences: desanCount,
+			via: "desanitize"
+		};
+	}
+	const combo = desanitize(normNeedle);
+	if (combo !== needle) {
+		const m = locateAndCount(haystack, normFile, combo, "quotes+desanitize");
+		if (m) return m;
+	}
+	const stripped = stripLineNumberPrefixes(needle);
+	if (stripped !== needle && stripped.trim().length > 0) {
+		const count = countExactMatches(haystack, stripped);
+		if (count > 0) return {
+			actual: stripped,
+			occurrences: count,
+			via: "line-numbers"
+		};
+		const strippedNorm = normalizeQuotes(stripped);
+		if (strippedNorm !== stripped || normFile !== haystack) {
+			const m = locateAndCount(haystack, normFile, strippedNorm, "quotes+line-numbers");
+			if (m) return m;
+		}
+	}
+	return null;
+}
+/**
+* Apply the same recovery transforms used to find `old_string` to
+* `new_string`, so the file gets back its native form: desanitize when
+* the model emitted `<n>` for `<name>`, strip line-number prefixes when
+* the match required them, then re-curlify when the match required
+* quote normalization. Shared between `edit` and `multi_edit`.
+*/
+function styleReplacementForVia(replacement, via, actual) {
+	let out = replacement;
+	if (via === "desanitize" || via === "quotes+desanitize") out = desanitize(out);
+	if (via === "line-numbers" || via === "quotes+line-numbers") out = stripLineNumberPrefixes(out);
+	if (via === "quotes" || via === "quotes+desanitize" || via === "quotes+line-numbers") out = preserveQuoteStyle(actual, out);
+	return out;
+}
+/**
+* When `old_string` matched via curly-quote normalization, re-style
+* `new_string` so the file's typography is preserved across the edit.
+* Detects whether the matched file region had curly singles, doubles, or
+* both, and applies the matching curlification to the replacement.
+*
+* Apostrophes in contractions (`don't`, `it's`) get the right-single curly
+* quote regardless of opening context — that's the canonical typographer's
+* convention for English. Other quotes use a simple
+* preceded-by-whitespace-or-opening-punctuation heuristic.
+*/
+function preserveQuoteStyle(actual, replacement) {
+	const hasDouble = actual.includes("“") || actual.includes("”");
+	const hasSingle = actual.includes("‘") || actual.includes("’");
+	if (!hasDouble && !hasSingle) return replacement;
+	let out = replacement;
+	if (hasDouble) out = applyCurly(out, "\"", "“", "”", false);
+	if (hasSingle) out = applyCurly(out, "'", "‘", "’", true);
+	return out;
+}
+function applyCurly(s, straight, left, right, contractionAware) {
+	const chars = [...s];
+	const result = [];
+	for (let i = 0; i < chars.length; i++) {
+		if (chars[i] !== straight) {
+			result.push(chars[i]);
+			continue;
+		}
+		if (contractionAware) {
+			const prev = i > 0 ? chars[i - 1] : "";
+			const next = i < chars.length - 1 ? chars[i + 1] : "";
+			if (/\p{L}/u.test(prev) && /\p{L}/u.test(next)) {
+				result.push(right);
+				continue;
+			}
+		}
+		result.push(isOpeningContext(chars, i) ? left : right);
+	}
+	return result.join("");
+}
+function isOpeningContext(chars, i) {
+	if (i === 0) return true;
+	const prev = chars[i - 1];
+	return prev === " " || prev === "	" || prev === "\n" || prev === "\r" || prev === "(" || prev === "[" || prev === "{" || prev === "—" || prev === "–";
+}
+//#endregion
+export { compactPath as a, formatTaskStatus as c, shortId as d, buildContextBreakdown as f, utf8ByteLength as h, ageString as i, formatTaskSummary as l, estimateTokens as m, stripLineNumberPrefixes as n, fmtTokens as o, BYTES_PER_TOKEN as p, styleReplacementForVia as r, formatDuration as s, resolveOldString as t, previewLine as u };
+
+//# sourceMappingURL=edit-utils-DnfNoj16.js.map