1  import { c as _c } from "react/compiler-runtime";
  2  import { diffWordsWithSpace, type StructuredPatchHunk } from 'diff';
  3  import * as React from 'react';
  4  import { useMemo } from 'react';
  5  import type { ThemeName } from 'src/utils/theme.js';
  6  import { stringWidth } from '../../ink/stringWidth.js';
  7  import { Box, NoSelect, Text, useTheme, wrapText } from '../../ink.js';
  8  
  9  /*
 10   * StructuredDiffFallback Component: Word-Level Diff Highlighting Example
 11   *
 12   * This component shows diff changes with word-level highlighting. Here's a walkthrough:
 13   *
 14   * Example:
 15   * ```
 16   * // Original code
 17   * function oldName(param) {
 18   *   return param.oldProperty;
 19   * }
 20   *
 21   * // Changed code
 22   * function newName(param) {
 23   *   return param.newProperty;
 24   * }
 25   * ```
 26   *
 27   * Processing flow:
 28   * 1. Component receives a patch with lines including '+' and '-' prefixes
 29   * 2. Lines are transformed into objects with type (add/remove/nochange)
 30   * 3. Related add/remove lines are paired (e.g., oldName with newName)
 31   * 4. Word-level diffing identifies specific changed parts:
 32   *    [
 33   *      { value: 'function ', added: undefined, removed: undefined },  // Common
 34   *      { value: 'oldName', removed: true },                           // Removed
 35   *      { value: 'newName', added: true },                             // Added
 36   *      { value: '(param) {', added: undefined, removed: undefined }   // Common
 37   *    ]
 38   * 5. Renders with enhanced highlighting:
 39   *    - Common parts are shown normally
 40   *    - Removed words get a darker red background
 41   *    - Added words get a darker green background
 42   *
 43   * This produces a visually clear diff where users can see exactly which words
 44   * changed rather than just which lines were modified.
 45   */
 46  
 47  // Define DiffLine interface to be used throughout the file
 48  interface DiffLine {
 49    code: string;
 50    type: 'add' | 'remove' | 'nochange';
 51    i: number;
 52    originalCode: string;
 53    wordDiff?: boolean; // Flag for word-level diffing
 54    matchedLine?: DiffLine;
 55  }
 56  
 57  // Line object type for internal functions
 58  export interface LineObject {
 59    code: string;
 60    i: number;
 61    type: 'add' | 'remove' | 'nochange';
 62    originalCode: string;
 63    wordDiff?: boolean;
 64    matchedLine?: LineObject;
 65  }
 66  
 67  // Type for word-level diff parts
 68  interface DiffPart {
 69    added?: boolean;
 70    removed?: boolean;
 71    value: string;
 72  }
 73  type Props = {
 74    patch: StructuredPatchHunk;
 75    dim: boolean;
 76    width: number;
 77  };
 78  
 79  // Threshold for when we show a full-line diff instead of word-level diffing
 80  const CHANGE_THRESHOLD = 0.4;
 81  export function StructuredDiffFallback(t0) {
 82    const $ = _c(10);
 83    const {
 84      patch,
 85      dim,
 86      width
 87    } = t0;
 88    const [theme] = useTheme();
 89    let t1;
 90    if ($[0] !== dim || $[1] !== patch.lines || $[2] !== patch.oldStart || $[3] !== theme || $[4] !== width) {
 91      t1 = formatDiff(patch.lines, patch.oldStart, width, dim, theme);
 92      $[0] = dim;
 93      $[1] = patch.lines;
 94      $[2] = patch.oldStart;
 95      $[3] = theme;
 96      $[4] = width;
 97      $[5] = t1;
 98    } else {
 99      t1 = $[5];
100    }
101    const diff = t1;
102    let t2;
103    if ($[6] !== diff) {
104      t2 = diff.map(_temp);
105      $[6] = diff;
106      $[7] = t2;
107    } else {
108      t2 = $[7];
109    }
110    let t3;
111    if ($[8] !== t2) {
112      t3 = <Box flexDirection="column" flexGrow={1}>{t2}</Box>;
113      $[8] = t2;
114      $[9] = t3;
115    } else {
116      t3 = $[9];
117    }
118    return t3;
119  }
120  
121  // Transform lines to line objects with type information
122  function _temp(node, i) {
123    return <Box key={i}>{node}</Box>;
124  }
125  export function transformLinesToObjects(lines: string[]): LineObject[] {
126    return lines.map(code => {
127      if (code.startsWith('+')) {
128        return {
129          code: code.slice(1),
130          i: 0,
131          type: 'add',
132          originalCode: code.slice(1)
133        };
134      }
135      if (code.startsWith('-')) {
136        return {
137          code: code.slice(1),
138          i: 0,
139          type: 'remove',
140          originalCode: code.slice(1)
141        };
142      }
143      return {
144        code: code.slice(1),
145        i: 0,
146        type: 'nochange',
147        originalCode: code.slice(1)
148      };
149    });
150  }
151  
152  // Group adjacent add/remove lines for word-level diffing
153  export function processAdjacentLines(lineObjects: LineObject[]): LineObject[] {
154    const processedLines: LineObject[] = [];
155    let i = 0;
156    while (i < lineObjects.length) {
157      const current = lineObjects[i];
158      if (!current) {
159        i++;
160        continue;
161      }
162  
163      // Find a sequence of remove followed by add (possible word-level diff candidates)
164      if (current.type === 'remove') {
165        const removeLines: LineObject[] = [current];
166        let j = i + 1;
167  
168        // Collect consecutive remove lines
169        while (j < lineObjects.length && lineObjects[j]?.type === 'remove') {
170          const line = lineObjects[j];
171          if (line) {
172            removeLines.push(line);
173          }
174          j++;
175        }
176  
177        // Check if there are add lines following the remove lines
178        const addLines: LineObject[] = [];
179        while (j < lineObjects.length && lineObjects[j]?.type === 'add') {
180          const line = lineObjects[j];
181          if (line) {
182            addLines.push(line);
183          }
184          j++;
185        }
186  
187        // If we have both remove and add lines, perform word-level diffing
188        if (removeLines.length > 0 && addLines.length > 0) {
189          // For word diffing, we'll compare each pair of lines or the closest available match
190          const pairCount = Math.min(removeLines.length, addLines.length);
191  
192          // Add paired lines with word diff info
193          for (let k = 0; k < pairCount; k++) {
194            const removeLine = removeLines[k];
195            const addLine = addLines[k];
196            if (removeLine && addLine) {
197              removeLine.wordDiff = true;
198              addLine.wordDiff = true;
199  
200              // Store the matched pair for later word diffing
201              removeLine.matchedLine = addLine;
202              addLine.matchedLine = removeLine;
203            }
204          }
205  
206          // Add all remove lines (both paired and unpaired)
207          processedLines.push(...removeLines.filter(Boolean));
208  
209          // Then add all add lines (both paired and unpaired)
210          processedLines.push(...addLines.filter(Boolean));
211          i = j; // Skip all the lines we've processed
212        } else {
213          // No matching add lines, just add the current remove line
214          processedLines.push(current);
215          i++;
216        }
217      } else {
218        // Not a remove line, just add it
219        processedLines.push(current);
220        i++;
221      }
222    }
223    return processedLines;
224  }
225  
226  // Calculate word-level diffs between two text strings
227  export function calculateWordDiffs(oldText: string, newText: string): DiffPart[] {
228    // Use diffWordsWithSpace instead of diffWords to preserve whitespace
229    // This ensures spaces between tokens like > and { are preserved
230    const result = diffWordsWithSpace(oldText, newText, {
231      ignoreCase: false
232    });
233    return result;
234  }
235  
236  // Process word-level diffs with manual wrapping support
237  function generateWordDiffElements(item: DiffLine, width: number, maxWidth: number, dim: boolean, overrideTheme?: ThemeName): React.ReactNode[] | null {
238    const {
239      type,
240      i,
241      wordDiff,
242      matchedLine,
243      originalCode
244    } = item;
245    if (!wordDiff || !matchedLine) {
246      return null; // This function only handles word-level diff rendering
247    }
248    const removedLineText = type === 'remove' ? originalCode : matchedLine.originalCode;
249    const addedLineText = type === 'remove' ? matchedLine.originalCode : originalCode;
250    const wordDiffs = calculateWordDiffs(removedLineText, addedLineText);
251  
252    // Check if we should use word-level diffing
253    const totalLength = removedLineText.length + addedLineText.length;
254    const changedLength = wordDiffs.filter(part => part.added || part.removed).reduce((sum, part) => sum + part.value.length, 0);
255    const changeRatio = changedLength / totalLength;
256    if (changeRatio > CHANGE_THRESHOLD || dim) {
257      return null; // Fall back to standard rendering for major changes
258    }
259  
260    // Calculate available width for content
261    const diffPrefix = type === 'add' ? '+' : '-';
262    const diffPrefixWidth = diffPrefix.length;
263    const availableContentWidth = Math.max(1, width - maxWidth - 1 - diffPrefixWidth);
264  
265    // Manually wrap the word diff parts with better space efficiency
266    const wrappedLines: {
267      content: React.ReactNode[];
268      contentWidth: number;
269    }[] = [];
270    let currentLine: React.ReactNode[] = [];
271    let currentLineWidth = 0;
272    wordDiffs.forEach((part, partIndex) => {
273      // Determine if this part should be shown for this line type
274      let shouldShow = false;
275      let partBgColor: 'diffAddedWord' | 'diffRemovedWord' | undefined;
276      if (type === 'add') {
277        if (part.added) {
278          shouldShow = true;
279          partBgColor = 'diffAddedWord';
280        } else if (!part.removed) {
281          shouldShow = true;
282        }
283      } else if (type === 'remove') {
284        if (part.removed) {
285          shouldShow = true;
286          partBgColor = 'diffRemovedWord';
287        } else if (!part.added) {
288          shouldShow = true;
289        }
290      }
291      if (!shouldShow) return;
292  
293      // Use wrapText to wrap this individual part if it's long
294      const partWrapped = wrapText(part.value, availableContentWidth, 'wrap');
295      const partLines = partWrapped.split('\n');
296      partLines.forEach((partLine, lineIdx) => {
297        if (!partLine) return;
298  
299        // Check if we need to start a new line
300        if (lineIdx > 0 || currentLineWidth + stringWidth(partLine) > availableContentWidth) {
301          if (currentLine.length > 0) {
302            wrappedLines.push({
303              content: [...currentLine],
304              contentWidth: currentLineWidth
305            });
306            currentLine = [];
307            currentLineWidth = 0;
308          }
309        }
310        currentLine.push(<Text key={`part-${partIndex}-${lineIdx}`} backgroundColor={partBgColor}>
311            {partLine}
312          </Text>);
313        currentLineWidth += stringWidth(partLine);
314      });
315    });
316    if (currentLine.length > 0) {
317      wrappedLines.push({
318        content: currentLine,
319        contentWidth: currentLineWidth
320      });
321    }
322  
323    // Render each wrapped line as a separate Text element
324    return wrappedLines.map(({
325      content,
326      contentWidth
327    }, lineIndex) => {
328      const key = `${type}-${i}-${lineIndex}`;
329      const lineBgColor = type === 'add' ? dim ? 'diffAddedDimmed' : 'diffAdded' : dim ? 'diffRemovedDimmed' : 'diffRemoved';
330      const lineNum = lineIndex === 0 ? i : undefined;
331      const lineNumStr = (lineNum !== undefined ? lineNum.toString().padStart(maxWidth) : ' '.repeat(maxWidth)) + ' ';
332      // Calculate padding to fill the entire terminal width
333      const usedWidth = lineNumStr.length + diffPrefixWidth + contentWidth;
334      const padding = Math.max(0, width - usedWidth);
335      return <Box key={key} flexDirection="row">
336          <NoSelect fromLeftEdge>
337            <Text color={overrideTheme ? 'text' : undefined} backgroundColor={lineBgColor} dimColor={dim}>
338              {lineNumStr}
339              {diffPrefix}
340            </Text>
341          </NoSelect>
342          <Text color={overrideTheme ? 'text' : undefined} backgroundColor={lineBgColor} dimColor={dim}>
343            {content}
344            {' '.repeat(padding)}
345          </Text>
346        </Box>;
347    });
348  }
349  function formatDiff(lines: string[], startingLineNumber: number, width: number, dim: boolean, overrideTheme?: ThemeName): React.ReactNode[] {
350    // Ensure width is at least 1 to prevent rendering issues with very narrow terminals
351    const safeWidth = Math.max(1, Math.floor(width));
352  
353    // Step 1: Transform lines to line objects with type information
354    const lineObjects = transformLinesToObjects(lines);
355  
356    // Step 2: Group adjacent add/remove lines for word-level diffing
357    const processedLines = processAdjacentLines(lineObjects);
358  
359    // Step 3: Number the diff lines
360    const ls = numberDiffLines(processedLines, startingLineNumber);
361  
362    // Find max line number width for alignment
363    const maxLineNumber = Math.max(...ls.map(({
364      i
365    }) => i), 0);
366    const maxWidth = Math.max(maxLineNumber.toString().length + 1, 0);
367  
368    // Step 4: Render formatting
369    return ls.flatMap((item): React.ReactNode[] => {
370      const {
371        type,
372        code,
373        i,
374        wordDiff,
375        matchedLine
376      } = item;
377  
378      // Handle word-level diffing for add/remove pairs
379      if (wordDiff && matchedLine) {
380        const wordDiffElements = generateWordDiffElements(item, safeWidth, maxWidth, dim, overrideTheme);
381  
382        // word-diff might refuse (e.g. due to lines being substantially different) in which
383        // case we'll fall through to normal renderin gbelow
384        if (wordDiffElements !== null) {
385          return wordDiffElements;
386        }
387      }
388  
389      // Standard rendering for lines without word diffing or as fallback
390      // Calculate available width accounting for line number + space + diff prefix
391      const diffPrefixWidth = 2; // "  " for unchanged, "+ " or "- " for changes
392      const availableContentWidth = Math.max(1, safeWidth - maxWidth - 1 - diffPrefixWidth); // -1 for space after line number
393      const wrappedText = wrapText(code, availableContentWidth, 'wrap');
394      const wrappedLines = wrappedText.split('\n');
395      return wrappedLines.map((line, lineIndex) => {
396        const key = `${type}-${i}-${lineIndex}`;
397        const lineNum = lineIndex === 0 ? i : undefined;
398        const lineNumStr = (lineNum !== undefined ? lineNum.toString().padStart(maxWidth) : ' '.repeat(maxWidth)) + ' ';
399        const sigil = type === 'add' ? '+' : type === 'remove' ? '-' : ' ';
400        // Calculate padding to fill the entire terminal width
401        const contentWidth = lineNumStr.length + 1 + stringWidth(line); // lineNum + sigil + code
402        const padding = Math.max(0, safeWidth - contentWidth);
403        const bgColor = type === 'add' ? dim ? 'diffAddedDimmed' : 'diffAdded' : type === 'remove' ? dim ? 'diffRemovedDimmed' : 'diffRemoved' : undefined;
404  
405        // Gutter (line number + sigil) is wrapped in <NoSelect> so fullscreen
406        // text selection yields clean code. bgColor carries across both boxes
407        // so the visual continuity (solid red/green bar) is unchanged.
408        return <Box key={key} flexDirection="row">
409            <NoSelect fromLeftEdge>
410              <Text color={overrideTheme ? 'text' : undefined} backgroundColor={bgColor} dimColor={dim || type === 'nochange'}>
411                {lineNumStr}
412                {sigil}
413              </Text>
414            </NoSelect>
415            <Text color={overrideTheme ? 'text' : undefined} backgroundColor={bgColor} dimColor={dim}>
416              {line}
417              {' '.repeat(padding)}
418            </Text>
419          </Box>;
420      });
421    });
422  }
423  export function numberDiffLines(diff: LineObject[], startLine: number): DiffLine[] {
424    let i = startLine;
425    const result: DiffLine[] = [];
426    const queue = [...diff];
427    while (queue.length > 0) {
428      const current = queue.shift()!;
429      const {
430        code,
431        type,
432        originalCode,
433        wordDiff,
434        matchedLine
435      } = current;
436      const line = {
437        code,
438        type,
439        i,
440        originalCode,
441        wordDiff,
442        matchedLine
443      };
444  
445      // Update counters based on change type
446      switch (type) {
447        case 'nochange':
448          i++;
449          result.push(line);
450          break;
451        case 'add':
452          i++;
453          result.push(line);
454          break;
455        case 'remove':
456          {
457            result.push(line);
458            let numRemoved = 0;
459            while (queue[0]?.type === 'remove') {
460              i++;
461              const current = queue.shift()!;
462              const {
463                code,
464                type,
465                originalCode,
466                wordDiff,
467                matchedLine
468              } = current;
469              const line = {
470                code,
471                type,
472                i,
473                originalCode,
474                wordDiff,
475                matchedLine
476              };
477              result.push(line);
478              numRemoved++;
479            }
480            i -= numRemoved;
481            break;
482          }
483      }
484    }
485    return result;
486  }
487  //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["diffWordsWithSpace","StructuredPatchHunk","React","useMemo","ThemeName","stringWidth","Box","NoSelect","Text","useTheme","wrapText","DiffLine","code","type","i","originalCode","wordDiff","matchedLine","LineObject","DiffPart","added","removed","value","Props","patch","dim","width","CHANGE_THRESHOLD","StructuredDiffFallback","t0","$","_c","theme","t1","lines","oldStart","formatDiff","diff","t2","map","_temp","t3","node","transformLinesToObjects","startsWith","slice","processAdjacentLines","lineObjects","processedLines","length","current","removeLines","j","line","push","addLines","pairCount","Math","min","k","removeLine","addLine","filter","Boolean","calculateWordDiffs","oldText","newText","result","ignoreCase","generateWordDiffElements","item","maxWidth","overrideTheme","ReactNode","removedLineText","addedLineText","wordDiffs","totalLength","changedLength","part","reduce","sum","changeRatio","diffPrefix","diffPrefixWidth","availableContentWidth","max","wrappedLines","content","contentWidth","currentLine","currentLineWidth","forEach","partIndex","shouldShow","partBgColor","partWrapped","partLines","split","partLine","lineIdx","lineIndex","key","lineBgColor","lineNum","undefined","lineNumStr","toString","padStart","repeat","usedWidth","padding","startingLineNumber","safeWidth","floor","ls","numberDiffLines","maxLineNumber","flatMap","wordDiffElements","wrappedText","sigil","bgColor","startLine","queue","shift","numRemoved"],"sources":["Fallback.tsx"],"sourcesContent":["import { diffWordsWithSpace, type StructuredPatchHunk } from 'diff'\nimport * as React from 'react'\nimport { useMemo } from 'react'\nimport type { ThemeName } from 'src/utils/theme.js'\nimport { stringWidth } from '../../ink/stringWidth.js'\nimport { Box, NoSelect, Text, useTheme, wrapText } from '../../ink.js'\n\n/*\n * StructuredDiffFallback Component: Word-Level Diff Highlighting Example\n *\n * This component shows diff changes with word-level highlighting. Here's a walkthrough:\n *\n * Example:\n * ```\n * // Original code\n * function oldName(param) {\n *   return param.oldProperty;\n * }\n *\n * // Changed code\n * function newName(param) {\n *   return param.newProperty;\n * }\n * ```\n *\n * Processing flow:\n * 1. Component receives a patch with lines including '+' and '-' prefixes\n * 2. Lines are transformed into objects with type (add/remove/nochange)\n * 3. Related add/remove lines are paired (e.g., oldName with newName)\n * 4. Word-level diffing identifies specific changed parts:\n *    [\n *      { value: 'function ', added: undefined, removed: undefined },  // Common\n *      { value: 'oldName', removed: true },                           // Removed\n *      { value: 'newName', added: true },                             // Added\n *      { value: '(param) {', added: undefined, removed: undefined }   // Common\n *    ]\n * 5. Renders with enhanced highlighting:\n *    - Common parts are shown normally\n *    - Removed words get a darker red background\n *    - Added words get a darker green background\n *\n * This produces a visually clear diff where users can see exactly which words\n * changed rather than just which lines were modified.\n */\n\n// Define DiffLine interface to be used throughout the file\ninterface DiffLine {\n  code: string\n  type: 'add' | 'remove' | 'nochange'\n  i: number\n  originalCode: string\n  wordDiff?: boolean // Flag for word-level diffing\n  matchedLine?: DiffLine\n}\n\n// Line object type for internal functions\nexport interface LineObject {\n  code: string\n  i: number\n  type: 'add' | 'remove' | 'nochange'\n  originalCode: string\n  wordDiff?: boolean\n  matchedLine?: LineObject\n}\n\n// Type for word-level diff parts\ninterface DiffPart {\n  added?: boolean\n  removed?: boolean\n  value: string\n}\n\ntype Props = {\n  patch: StructuredPatchHunk\n  dim: boolean\n  width: number\n}\n\n// Threshold for when we show a full-line diff instead of word-level diffing\nconst CHANGE_THRESHOLD = 0.4\n\nexport function StructuredDiffFallback({\n  patch,\n  dim,\n  width,\n}: Props): React.ReactNode {\n  const [theme] = useTheme()\n  const diff = useMemo(\n    () => formatDiff(patch.lines, patch.oldStart, width, dim, theme),\n    [patch.lines, patch.oldStart, width, dim, theme],\n  )\n\n  return (\n    <Box flexDirection=\"column\" flexGrow={1}>\n      {diff.map((node, i) => (\n        <Box key={i}>{node}</Box>\n      ))}\n    </Box>\n  )\n}\n\n// Transform lines to line objects with type information\nexport function transformLinesToObjects(lines: string[]): LineObject[] {\n  return lines.map(code => {\n    if (code.startsWith('+')) {\n      return {\n        code: code.slice(1),\n        i: 0,\n        type: 'add',\n        originalCode: code.slice(1),\n      }\n    }\n    if (code.startsWith('-')) {\n      return {\n        code: code.slice(1),\n        i: 0,\n        type: 'remove',\n        originalCode: code.slice(1),\n      }\n    }\n    return {\n      code: code.slice(1),\n      i: 0,\n      type: 'nochange',\n      originalCode: code.slice(1),\n    }\n  })\n}\n\n// Group adjacent add/remove lines for word-level diffing\nexport function processAdjacentLines(lineObjects: LineObject[]): LineObject[] {\n  const processedLines: LineObject[] = []\n  let i = 0\n\n  while (i < lineObjects.length) {\n    const current = lineObjects[i]\n    if (!current) {\n      i++\n      continue\n    }\n\n    // Find a sequence of remove followed by add (possible word-level diff candidates)\n    if (current.type === 'remove') {\n      const removeLines: LineObject[] = [current]\n      let j = i + 1\n\n      // Collect consecutive remove lines\n      while (j < lineObjects.length && lineObjects[j]?.type === 'remove') {\n        const line = lineObjects[j]\n        if (line) {\n          removeLines.push(line)\n        }\n        j++\n      }\n\n      // Check if there are add lines following the remove lines\n      const addLines: LineObject[] = []\n      while (j < lineObjects.length && lineObjects[j]?.type === 'add') {\n        const line = lineObjects[j]\n        if (line) {\n          addLines.push(line)\n        }\n        j++\n      }\n\n      // If we have both remove and add lines, perform word-level diffing\n      if (removeLines.length > 0 && addLines.length > 0) {\n        // For word diffing, we'll compare each pair of lines or the closest available match\n        const pairCount = Math.min(removeLines.length, addLines.length)\n\n        // Add paired lines with word diff info\n        for (let k = 0; k < pairCount; k++) {\n          const removeLine = removeLines[k]\n          const addLine = addLines[k]\n\n          if (removeLine && addLine) {\n            removeLine.wordDiff = true\n            addLine.wordDiff = true\n\n            // Store the matched pair for later word diffing\n            removeLine.matchedLine = addLine\n            addLine.matchedLine = removeLine\n          }\n        }\n\n        // Add all remove lines (both paired and unpaired)\n        processedLines.push(...removeLines.filter(Boolean))\n\n        // Then add all add lines (both paired and unpaired)\n        processedLines.push(...addLines.filter(Boolean))\n\n        i = j // Skip all the lines we've processed\n      } else {\n        // No matching add lines, just add the current remove line\n        processedLines.push(current)\n        i++\n      }\n    } else {\n      // Not a remove line, just add it\n      processedLines.push(current)\n      i++\n    }\n  }\n\n  return processedLines\n}\n\n// Calculate word-level diffs between two text strings\nexport function calculateWordDiffs(\n  oldText: string,\n  newText: string,\n): DiffPart[] {\n  // Use diffWordsWithSpace instead of diffWords to preserve whitespace\n  // This ensures spaces between tokens like > and { are preserved\n  const result = diffWordsWithSpace(oldText, newText, { ignoreCase: false })\n\n  return result\n}\n\n// Process word-level diffs with manual wrapping support\nfunction generateWordDiffElements(\n  item: DiffLine,\n  width: number,\n  maxWidth: number,\n  dim: boolean,\n  overrideTheme?: ThemeName,\n): React.ReactNode[] | null {\n  const { type, i, wordDiff, matchedLine, originalCode } = item\n\n  if (!wordDiff || !matchedLine) {\n    return null // This function only handles word-level diff rendering\n  }\n\n  const removedLineText =\n    type === 'remove' ? originalCode : matchedLine.originalCode\n  const addedLineText =\n    type === 'remove' ? matchedLine.originalCode : originalCode\n\n  const wordDiffs = calculateWordDiffs(removedLineText, addedLineText)\n\n  // Check if we should use word-level diffing\n  const totalLength = removedLineText.length + addedLineText.length\n  const changedLength = wordDiffs\n    .filter(part => part.added || part.removed)\n    .reduce((sum, part) => sum + part.value.length, 0)\n  const changeRatio = changedLength / totalLength\n\n  if (changeRatio > CHANGE_THRESHOLD || dim) {\n    return null // Fall back to standard rendering for major changes\n  }\n\n  // Calculate available width for content\n  const diffPrefix = type === 'add' ? '+' : '-'\n  const diffPrefixWidth = diffPrefix.length\n  const availableContentWidth = Math.max(\n    1,\n    width - maxWidth - 1 - diffPrefixWidth,\n  )\n\n  // Manually wrap the word diff parts with better space efficiency\n  const wrappedLines: { content: React.ReactNode[]; contentWidth: number }[] =\n    []\n  let currentLine: React.ReactNode[] = []\n  let currentLineWidth = 0\n\n  wordDiffs.forEach((part, partIndex) => {\n    // Determine if this part should be shown for this line type\n    let shouldShow = false\n    let partBgColor: 'diffAddedWord' | 'diffRemovedWord' | undefined\n\n    if (type === 'add') {\n      if (part.added) {\n        shouldShow = true\n        partBgColor = 'diffAddedWord'\n      } else if (!part.removed) {\n        shouldShow = true\n      }\n    } else if (type === 'remove') {\n      if (part.removed) {\n        shouldShow = true\n        partBgColor = 'diffRemovedWord'\n      } else if (!part.added) {\n        shouldShow = true\n      }\n    }\n\n    if (!shouldShow) return\n\n    // Use wrapText to wrap this individual part if it's long\n    const partWrapped = wrapText(part.value, availableContentWidth, 'wrap')\n    const partLines = partWrapped.split('\\n')\n\n    partLines.forEach((partLine, lineIdx) => {\n      if (!partLine) return\n\n      // Check if we need to start a new line\n      if (\n        lineIdx > 0 ||\n        currentLineWidth + stringWidth(partLine) > availableContentWidth\n      ) {\n        if (currentLine.length > 0) {\n          wrappedLines.push({\n            content: [...currentLine],\n            contentWidth: currentLineWidth,\n          })\n          currentLine = []\n          currentLineWidth = 0\n        }\n      }\n\n      currentLine.push(\n        <Text\n          key={`part-${partIndex}-${lineIdx}`}\n          backgroundColor={partBgColor}\n        >\n          {partLine}\n        </Text>,\n      )\n\n      currentLineWidth += stringWidth(partLine)\n    })\n  })\n\n  if (currentLine.length > 0) {\n    wrappedLines.push({ content: currentLine, contentWidth: currentLineWidth })\n  }\n\n  // Render each wrapped line as a separate Text element\n  return wrappedLines.map(({ content, contentWidth }, lineIndex) => {\n    const key = `${type}-${i}-${lineIndex}`\n    const lineBgColor =\n      type === 'add'\n        ? dim\n          ? 'diffAddedDimmed'\n          : 'diffAdded'\n        : dim\n          ? 'diffRemovedDimmed'\n          : 'diffRemoved'\n    const lineNum = lineIndex === 0 ? i : undefined\n    const lineNumStr =\n      (lineNum !== undefined\n        ? lineNum.toString().padStart(maxWidth)\n        : ' '.repeat(maxWidth)) + ' '\n    // Calculate padding to fill the entire terminal width\n    const usedWidth = lineNumStr.length + diffPrefixWidth + contentWidth\n    const padding = Math.max(0, width - usedWidth)\n\n    return (\n      <Box key={key} flexDirection=\"row\">\n        <NoSelect fromLeftEdge>\n          <Text\n            color={overrideTheme ? 'text' : undefined}\n            backgroundColor={lineBgColor}\n            dimColor={dim}\n          >\n            {lineNumStr}\n            {diffPrefix}\n          </Text>\n        </NoSelect>\n        <Text\n          color={overrideTheme ? 'text' : undefined}\n          backgroundColor={lineBgColor}\n          dimColor={dim}\n        >\n          {content}\n          {' '.repeat(padding)}\n        </Text>\n      </Box>\n    )\n  })\n}\n\nfunction formatDiff(\n  lines: string[],\n  startingLineNumber: number,\n  width: number,\n  dim: boolean,\n  overrideTheme?: ThemeName,\n): React.ReactNode[] {\n  // Ensure width is at least 1 to prevent rendering issues with very narrow terminals\n  const safeWidth = Math.max(1, Math.floor(width))\n\n  // Step 1: Transform lines to line objects with type information\n  const lineObjects = transformLinesToObjects(lines)\n\n  // Step 2: Group adjacent add/remove lines for word-level diffing\n  const processedLines = processAdjacentLines(lineObjects)\n\n  // Step 3: Number the diff lines\n  const ls = numberDiffLines(processedLines, startingLineNumber)\n\n  // Find max line number width for alignment\n  const maxLineNumber = Math.max(...ls.map(({ i }) => i), 0)\n  const maxWidth = Math.max(maxLineNumber.toString().length + 1, 0)\n\n  // Step 4: Render formatting\n  return ls.flatMap((item): React.ReactNode[] => {\n    const { type, code, i, wordDiff, matchedLine } = item\n\n    // Handle word-level diffing for add/remove pairs\n    if (wordDiff && matchedLine) {\n      const wordDiffElements = generateWordDiffElements(\n        item,\n        safeWidth,\n        maxWidth,\n        dim,\n        overrideTheme,\n      )\n\n      // word-diff might refuse (e.g. due to lines being substantially different) in which\n      // case we'll fall through to normal renderin gbelow\n      if (wordDiffElements !== null) {\n        return wordDiffElements\n      }\n    }\n\n    // Standard rendering for lines without word diffing or as fallback\n    // Calculate available width accounting for line number + space + diff prefix\n    const diffPrefixWidth = 2 // \"  \" for unchanged, \"+ \" or \"- \" for changes\n    const availableContentWidth = Math.max(\n      1,\n      safeWidth - maxWidth - 1 - diffPrefixWidth,\n    ) // -1 for space after line number\n    const wrappedText = wrapText(code, availableContentWidth, 'wrap')\n    const wrappedLines = wrappedText.split('\\n')\n\n    return wrappedLines.map((line, lineIndex) => {\n      const key = `${type}-${i}-${lineIndex}`\n      const lineNum = lineIndex === 0 ? i : undefined\n      const lineNumStr =\n        (lineNum !== undefined\n          ? lineNum.toString().padStart(maxWidth)\n          : ' '.repeat(maxWidth)) + ' '\n      const sigil = type === 'add' ? '+' : type === 'remove' ? '-' : ' '\n      // Calculate padding to fill the entire terminal width\n      const contentWidth = lineNumStr.length + 1 + stringWidth(line) // lineNum + sigil + code\n      const padding = Math.max(0, safeWidth - contentWidth)\n\n      const bgColor =\n        type === 'add'\n          ? dim\n            ? 'diffAddedDimmed'\n            : 'diffAdded'\n          : type === 'remove'\n            ? dim\n              ? 'diffRemovedDimmed'\n              : 'diffRemoved'\n            : undefined\n\n      // Gutter (line number + sigil) is wrapped in <NoSelect> so fullscreen\n      // text selection yields clean code. bgColor carries across both boxes\n      // so the visual continuity (solid red/green bar) is unchanged.\n      return (\n        <Box key={key} flexDirection=\"row\">\n          <NoSelect fromLeftEdge>\n            <Text\n              color={overrideTheme ? 'text' : undefined}\n              backgroundColor={bgColor}\n              dimColor={dim || type === 'nochange'}\n            >\n              {lineNumStr}\n              {sigil}\n            </Text>\n          </NoSelect>\n          <Text\n            color={overrideTheme ? 'text' : undefined}\n            backgroundColor={bgColor}\n            dimColor={dim}\n          >\n            {line}\n            {' '.repeat(padding)}\n          </Text>\n        </Box>\n      )\n    })\n  })\n}\n\nexport function numberDiffLines(\n  diff: LineObject[],\n  startLine: number,\n): DiffLine[] {\n  let i = startLine\n  const result: DiffLine[] = []\n  const queue = [...diff]\n\n  while (queue.length > 0) {\n    const current = queue.shift()!\n    const { code, type, originalCode, wordDiff, matchedLine } = current\n    const line = {\n      code,\n      type,\n      i,\n      originalCode,\n      wordDiff,\n      matchedLine,\n    }\n\n    // Update counters based on change type\n    switch (type) {\n      case 'nochange':\n        i++\n        result.push(line)\n        break\n      case 'add':\n        i++\n        result.push(line)\n        break\n      case 'remove': {\n        result.push(line)\n        let numRemoved = 0\n        while (queue[0]?.type === 'remove') {\n          i++\n          const current = queue.shift()!\n          const { code, type, originalCode, wordDiff, matchedLine } = current\n          const line = {\n            code,\n            type,\n            i,\n            originalCode,\n            wordDiff,\n            matchedLine,\n          }\n          result.push(line)\n          numRemoved++\n        }\n        i -= numRemoved\n        break\n      }\n    }\n  }\n\n  return result\n}\n"],"mappings":"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","ignoreList":[]}