Original: "The quick brown fox jumps"
Modified: "The fast brown fox leaps"

Myers Result:
- The quick brown fox jumps
+ The fast brown fox leaps
  (Shows "quick" → "fast" and "jumps" → "leaps")

Original:
function oldName() {
  return "hello";
}

Modified:
function newName() {
  return "hello";
}
// Additional code

Patience Result:
- function oldName() {
+ function newName() {
    return "hello";
  }
+ // Additional code

Original: "Hello World"
Modified: "Hello Earth"

Character Diff:
Hello [-W-]{+E+}[-o-]{+a+}r[-l-]{+th+}d

Supported Formats:
- Plain text (.txt)
- Code files (.js, .py, .java, .cpp, etc.)
- Configuration files (.json, .xml, .yaml)
- Documents (.md, .html, .css)
- Log files (.log)

☐ Ignore whitespace changes
☐ Ignore case differences  
☐ Ignore line ending differences (CRLF vs LF)
☐ Ignore empty lines
☐ Ignore leading/trailing spaces

📊 View Mode: Side-by-side / Unified / Inline
🎨 Theme: Light / Dark / High Contrast
📏 Context Lines: 3 / 5 / 10 / All
🔍 Granularity: Line / Word / Character

// Different whitespace scenarios
const scenarios = {
  trailing: {
    original: "hello world   ",
    modified: "hello world"
  },
  indentation: {
    original: "  function hello() {",
    modified: "    function hello() {"
  },
  lineEndings: {
    original: "line1\r\nline2\r\n", // Windows (CRLF)
    modified: "line1\nline2\n"      // Unix (LF)
  },
  tabs: {
    original: "\tindented with tab",
    modified: "    indented with spaces"
  }
};

Ignore All Whitespace: Treats all whitespace as identical
Ignore Whitespace Changes: Ignores amount of whitespace
Ignore Whitespace at EOL: Ignores trailing whitespace
Show Whitespace: Visualize spaces, tabs, line endings

// JavaScript example
Original:
function calculateTotal(items) {
  let total = 0;
  for (let item of items) {
    total += item.price;
  }
  return total;
}

Modified:
function calculateTotal(items) {
  return items.reduce((total, item) => total + item.price, 0);
}

// Tool provides:
// - Syntax highlighting
// - Function-aware diffing
// - Structural change detection

// Original JSON
{
  "name": "John Doe",
  "age": 30,
  "city": "New York"
}

// Modified JSON  
{
  "name": "John Doe",
  "age": 31,
  "city": "Boston",
  "country": "USA"
}

// Smart JSON diff shows:
// - Property changes
// - Added/removed properties
// - Nested object changes

Original:
function A() { ... }
function B() { ... }
function C() { ... }

Modified:
function B() { ... }
function A() { ... }
function C() { ... }

Move Detection:
→ function A() moved from line 1 to line 2
→ function B() moved from line 2 to line 1
  function C() unchanged

Move Detection Sensitivity:
- Low: Only obvious moves
- Medium: Balanced detection (default)
- High: Detect subtle moves
- Off: Disable move detection

Minimum Move Size:
- Characters: 20+
- Words: 5+  
- Lines: 3+

Base Version (common ancestor):
function hello() {
  return "Hello";
}

Your Changes:
function hello() {
  return "Hello World";
}

Their Changes:
function hello() {
  console.log("Debug");
  return "Hello";
}

Auto-Merged Result:
function hello() {
  console.log("Debug");
  return "Hello World";
}

1. Edit-Edit Conflict:
<<<<<< YOUR CHANGES
  return "Hello World";
======
  return "Hello Universe";
>>>>>> THEIR CHANGES

2. Add-Add Conflict:
<<<<<< YOUR CHANGES
  function newFeature() { ... }
======
  function differentFeature() { ... }  
>>>>>> THEIR CHANGES

3. Delete-Edit Conflict:
<<<<<< YOUR CHANGES
  // Function deleted
======
  function modified() { ... }
>>>>>> THEIR CHANGES

// Manual resolution options
const resolutionStrategies = {
  acceptYours: "Use your version",
  acceptTheirs: "Use their version", 
  acceptBoth: "Include both changes",
  custom: "Create custom resolution"
};

// Auto-resolution rules
const autoRules = {
  whitespaceOnly: "auto-resolve whitespace conflicts",
  imports: "merge import statements intelligently",
  comments: "preserve all comments when possible"
};

✅ General text documents
✅ Small to medium files
✅ When performance isn't critical
✅ Standard diff requirements

✅ Source code comparison
✅ Files with moved blocks
✅ Complex restructuring
✅ When quality matters more than speed

✅ Precise change analysis
✅ Small text snippets
✅ Finding exact character differences
✅ Validation and proofreading

// Strategies for large file comparison
const optimizeLargeFiles = {
  chunking: "Process files in smaller chunks",
  sampling: "Compare representative samples first",
  indexing: "Build content indices for faster lookup",
  streaming: "Stream comparison for memory efficiency"
};

// Performance settings
const performanceMode = {
  fast: "Quick comparison, less detail",
  balanced: "Good speed and accuracy (default)",
  thorough: "Maximum accuracy, slower processing"
};

// Memory-efficient diff processing
const efficientDiff = {
  lineBuffering: "Process line by line instead of loading entire file",
  resultStreaming: "Stream diff results as they're computed", 
  cleanup: "Release memory from processed chunks",
  limits: "Set maximum file size limits"
};

// Recommended limits
const limits = {
  fileSize: "100MB maximum per file",
  lines: "1 million lines maximum",
  memory: "Keep memory usage under 2GB"
};

// Improve diff readability
const displayOptimization = {
  contextLines: "Show 3-5 context lines for clarity",
  highlighting: "Use distinct colors for different change types",
  lineNumbers: "Include line numbers for reference",
  wordWrap: "Handle long lines gracefully",
  syntaxHighlighting: "Apply language-specific formatting"
};

// Before code review
const original = `
function calculatePrice(item, discount) {
  const basePrice = item.price;
  return basePrice - (basePrice  discount);
}
`;

// After code review  
const modified = `
function calculatePrice(item, discount = 0) {
  if (!item || typeof item.price !== 'number') {
    throw new Error('Invalid item');
  }
  
  const basePrice = item.price;
  const discountAmount = basePrice  Math.max(0, Math.min(discount, 1));
  return basePrice - discountAmount;
}
`;

// Diff shows:
// + Added parameter validation
// + Added default parameter value
// + Added input sanitization
// + Improved discount calculation

Git integration example
git diff HEAD~1 HEAD > changes.diff

Show diff in our tool for better visualization
- Line-by-line comparison
- Syntax highlighting
- Move detection
- Context expansion

Original Document:
"The project deadline is March 15th. All team members must complete their tasks by March 10th."

Revised Document:
"The project deadline has been moved to March 20th. All team members must complete their tasks by March 17th."

Diff Analysis:
- deadline is March 15th
+ deadline has been moved to March 20th
- by March 10th
+ by March 17th

Contract Comparison:
- Track clause modifications
- Identify added/removed terms
- Highlight monetary changes
- Show date modifications
- Export change summary for review

  
Product Name
  
$99.99
  Buy Now




  
Premium Product Name
  
$99.99
  
$79.99
  Buy Now - Limited Time

Original Post
Introduction
This post covers basic concepts.

Revised Post  
Introduction
This comprehensive post covers advanced concepts with practical examples.

New Section
Here are detailed examples...

Original config.yml
database:
  host: localhost
  port: 5432
  name: myapp_dev

Updated config.yml
database:
  host: prod-db.example.com
  port: 5432  
  name: myapp_prod
  ssl: true
  connection_pool: 20

Diff highlights environment changes

Development .env
DATABASE_URL=localhost:5432
DEBUG=true
LOG_LEVEL=debug

Production .env
DATABASE_URL=prod-server:5432
DEBUG=false
LOG_LEVEL=info
CACHE_ENABLED=true

Shows environment-specific changes

import { diffLines, diffWords, diffChars } from 'diff';

class TextComparator {
  constructor(options = {}) {
    this.options = {
      ignoreWhitespace: false,
      ignoreCase: false,
      ...options
    };
  }
  
  compare(oldText, newText, granularity = 'lines') {
    const diffMethods = {
      lines: diffLines,
      words: diffWords,
      chars: diffChars
    };
    
    const diffMethod = diffMethods[granularity];
    const diff = diffMethod(oldText, newText, this.options);
    
    return this.formatDiff(diff);
  }
  
  formatDiff(diff) {
    return diff.map(part => ({
      type: part.added ? 'addition' : part.removed ? 'deletion' : 'unchanged',
      content: part.value,
      count: part.count
    }));
  }
}

// Usage
const comparator = new TextComparator({ ignoreWhitespace: true });
const result = comparator.compare(originalText, modifiedText, 'lines');

import React, { useState, useEffect } from 'react';
import { diffLines } from 'diff';

const DiffViewer = ({ original, modified }) => {
  const [diff, setDiff] = useState([]);
  
  useEffect(() => {
    const result = diffLines(original, modified);
    setDiff(result);
  }, [original, modified]);
  
  return (
    <div className="diff-viewer">
      {diff.map((part, index) => (
        <div
          key={index}
          className={'diff-line ' + (part.added ? 'addition' : part.removed ? 'deletion' : 'unchanged')}
        >
          <span className="line-prefix">
            {part.added ? '+' : part.removed ? '-' : ' '}
          </span>
          <span className="line-content">{part.value}</span>
        </div>
      ))}
    </div>
  );
};

const express = require('express');
const { diffLines } = require('diff');

const app = express();

app.post('/api/diff', (req, res) => {
  try {
    const { original, modified, options = {} } = req.body;
    
    const diff = diffLines(original, modified, {
      ignoreWhitespace: options.ignoreWhitespace || false,
      ignoreCase: options.ignoreCase || false
    });
    
    const stats = calculateStats(diff);
    
    res.json({
      diff: diff,
      statistics: stats,
      success: true
    });
  } catch (error) {
    res.status(400).json({
      error: error.message,
      success: false
    });
  }
});

const calculateStats = (diff) => {
  return {
    additions: diff.filter(part => part.added).length,
    deletions: diff.filter(part => part.removed).length,
    unchanged: diff.filter(part => !part.added && !part.removed).length,
    totalLines: diff.reduce((sum, part) => sum + part.count, 0)
  };
};

#!/bin/bash

Diff two files with our formatting
compare_files() {
  local file1="$1"
  local file2="$2"
  local output_format="$3"
  
  if [[ ! -f "$file1" ]] || [[ ! -f "$file2" ]]; then
    echo "Error: Both files must exist"
    exit 1
  fi
  
  case "$output_format" in
    "unified")
      diff -u "$file1" "$file2"
      ;;
    "side-by-side")
      diff -y --width=160 "$file1" "$file2"
      ;;
    "html")
      # Generate HTML diff report
      generate_html_diff "$file1" "$file2"
      ;;
    )
      diff "$file1" "$file2"
      ;;
  esac
}

Usage
compare_files "old_version.txt" "new_version.txt" "unified"

// Handle large files efficiently
const handleLargeFile = (file) => {
  const maxSize = 10  1024  1024; // 10MB
  
  if (file.size > maxSize) {
    return {
      strategy: 'chunk',
      chunkSize: 1024  1024, // 1MB chunks
      preview: file.slice(0, 10000) // Show preview only
    };
  }
  
  return { strategy: 'full', content: file };
};

// Handle Unicode properly
const normalizeText = (text) => {
  return text
    .normalize('NFC') // Normalize Unicode
    .replace(/\r\n/g, '\n') // Normalize line endings
    .replace(/\r/g, '\n'); // Handle old Mac line endings
};

// Smart conflict resolution
const resolveConflict = (base, yours, theirs) => {
  // Auto-resolve simple cases
  if (yours === base) return theirs; // Only they changed
  if (theirs === base) return yours; // Only you changed
  if (yours === theirs) return yours; // Both made same change
  
  // Mark as manual conflict
  return {
    conflict: true,
    base: base,
    yours: yours,
    theirs: theirs,
    suggestions: generateSuggestions(base, yours, theirs)
  };
};