diff

function computeLCS<T>(oldSeq: T[], newSeq: T[], equals?: EqualityFn<T>): number[][]

Longest Common Subsequence (LCS) using dynamic programming Time complexity: O(n * m) Space complexity: O(n * m)

function backtrackLCS<T>(dp: number[][], oldSeq: T[], newSeq: T[], equals?: EqualityFn<T>): Array<{
    oldIndex: number;
    newIndex: number;
}>

Backtrack LCS to find actual common subsequence

function buildChangesFromMatches<T>(oldSeq: T[], newSeq: T[], matches: Array<{
    oldIndex: number;
    newIndex: number;
}>): DiffChange[]

Convert edit operations to DiffChange array Merges consecutive operations of the same type into single changes

function mergeConsecutiveChanges(changes: DiffChange[]): DiffChange[]

Merge consecutive changes of the same type Combines adjacent additions or deletions into single changes

function editDistance(oldStr: string, newStr: string): number

Calculate edit distance (Levenshtein distance) Number of single-character edits needed to transform one string into another

function similarity(str1: string, str2: string): number

Calculate similarity score between two strings Returns value between 0 (completely different) and 1 (identical)

function normalizeText(text: string, ignoreWhitespace?: boolean, ignoreCase?: boolean): string

Normalize text for comparison

function myersDiff<T>(oldSeq: T[], newSeq: T[], equals?: EqualityFn<T>): DiffResult

Myers diff algorithm for sequences Finds the shortest edit script to transform oldSeq into newSeq.

function myersDiffString(oldStr: string, newStr: string): DiffResult

Myers diff for strings Convenience function that operates on strings instead of arrays.

function myersDiff<T>(oldSeq: T[], newSeq: T[], equals?: EqualityFn<T>): DiffResult

Myers diff algorithm for sequences Finds the shortest edit script to transform oldSeq into newSeq.

function myersDiffString(oldStr: string, newStr: string): DiffResult

Myers diff for strings Convenience function that operates on strings instead of arrays.

function patienceDiff<T>(oldSeq: T[], newSeq: T[], equals?: EqualityFn<T>): DiffResult

Patience diff algorithm for sequences

function patienceDiffString(oldStr: string, newStr: string): DiffResult

Patience diff for strings Convenience function that operates on strings instead of arrays

function patienceDiff<T>(oldSeq: T[], newSeq: T[], equals?: EqualityFn<T>): DiffResult

Patience diff algorithm for sequences

function patienceDiffString(oldStr: string, newStr: string): DiffResult

Patience diff for strings Convenience function that operates on strings instead of arrays

function computeLCS<T>(oldSeq: T[], newSeq: T[], equals?: EqualityFn<T>): number[][]

Longest Common Subsequence (LCS) using dynamic programming Time complexity: O(n * m) Space complexity: O(n * m)

function backtrackLCS<T>(dp: number[][], oldSeq: T[], newSeq: T[], equals?: EqualityFn<T>): Array<{
    oldIndex: number;
    newIndex: number;
}>

Backtrack LCS to find actual common subsequence

function buildChangesFromMatches<T>(oldSeq: T[], newSeq: T[], matches: Array<{
    oldIndex: number;
    newIndex: number;
}>): DiffChange[]

Convert edit operations to DiffChange array Merges consecutive operations of the same type into single changes

function mergeConsecutiveChanges(changes: DiffChange[]): DiffChange[]

Merge consecutive changes of the same type Combines adjacent additions or deletions into single changes

function editDistance(oldStr: string, newStr: string): number

Calculate edit distance (Levenshtein distance) Number of single-character edits needed to transform one string into another

function similarity(str1: string, str2: string): number

Calculate similarity score between two strings Returns value between 0 (completely different) and 1 (identical)

function normalizeText(text: string, ignoreWhitespace?: boolean, ignoreCase?: boolean): string

Normalize text for comparison

function createPatch(oldStr: string, newStr: string, oldFileName?: string, newFileName?: string, options?: PatchOptions): ParsedPatch

Create a patch from two strings Generates a unified diff patch that can be applied with `patch` command.

function createTwoFilesPatch(oldStr: string, newStr: string, oldPath: string, newPath: string, oldHeader?: string, newHeader?: string, options?: PatchOptions): string

Create a two-file patch (with file headers)

function formatPatch(patch: ParsedPatch, oldHeader?: string, newHeader?: string): string

Format a parsed patch as unified diff string

function applyPatch(source: string, patch: ParsedPatch | string, options?: {
    fuzzFactor?: number;
}): string | null

Apply patch result to a string

function applyPatches(source: string, patches: (ParsedPatch | string)[], options?: {
    fuzzFactor?: number;
}): string | null

Apply multiple patches to a source

function parsePatch(patchContent: string): ParsedPatch[]

Parse a unified diff patch string Parses patches in unified diff format (git diff output).

function parseMultiplePatches(content: string): ParsedPatch[]

Parse multiple patch files Parses a string containing multiple patch files.

function validatePatch(patch: ParsedPatch): boolean

Validate a parsed patch Checks if a patch is valid and can be applied.

function createPatch(oldStr: string, newStr: string, oldFileName?: string, newFileName?: string, options?: PatchOptions): ParsedPatch

Create a patch from two strings Generates a unified diff patch that can be applied with `patch` command.

function createTwoFilesPatch(oldStr: string, newStr: string, oldPath: string, newPath: string, oldHeader?: string, newHeader?: string, options?: PatchOptions): string

Create a two-file patch (with file headers)

function formatPatch(patch: ParsedPatch, oldHeader?: string, newHeader?: string): string

Format a parsed patch as unified diff string

function applyPatch(source: string, patch: ParsedPatch | string, options?: {
    fuzzFactor?: number;
}): string | null

Apply patch result to a string

function applyPatches(source: string, patches: (ParsedPatch | string)[], options?: {
    fuzzFactor?: number;
}): string | null

Apply multiple patches to a source

function parsePatch(patchContent: string): ParsedPatch[]

Parse a unified diff patch string Parses patches in unified diff format (git diff output).

function parseMultiplePatches(content: string): ParsedPatch[]

Parse multiple patch files Parses a string containing multiple patch files.

function validatePatch(patch: ParsedPatch): boolean

Validate a parsed patch Checks if a patch is valid and can be applied.

function diffLines(oldText: string, newText: string, options?: DiffOptions): DiffResult

Diff two texts line by line This is the most commonly used diff function, comparing text line-by-line. Used by Git, testing frameworks, and most diff tools.

function diffLinesPatiently(oldText: string, newText: string, options?: DiffOptions): DiffResult

Diff two texts line by line using Patience algorithm Produces more readable diffs, especially for code with moved sections

function diffLinesHistogram(oldText: string, newText: string, options?: DiffOptions): DiffResult

Diff two texts line by line using Histogram algorithm Balanced between speed and output quality

function diffWords(oldText: string, newText: string, options?: DiffOptions): DiffResult

Diff two texts word by word Useful for comparing sentences or paragraphs where you want to see which words changed, not which characters.

function diffChars(oldText: string, newText: string, options?: DiffOptions): DiffResult

Diff two texts character by character Finest-grained diff showing exactly which characters changed. Most useful for short strings or when you need precise differences.

function diffSentences(oldText: string, newText: string, options?: DiffOptions): DiffResult

Diff two texts sentence by sentence Useful for comparing paragraphs or documents where you want to see which sentences changed.

function diffLines(oldText: string, newText: string, options?: DiffOptions): DiffResult

Diff two texts line by line This is the most commonly used diff function, comparing text line-by-line. Used by Git, testing frameworks, and most diff tools.

function diffLinesPatiently(oldText: string, newText: string, options?: DiffOptions): DiffResult

Diff two texts line by line using Patience algorithm Produces more readable diffs, especially for code with moved sections

function diffLinesHistogram(oldText: string, newText: string, options?: DiffOptions): DiffResult

Diff two texts line by line using Histogram algorithm Balanced between speed and output quality

function diffWords(oldText: string, newText: string, options?: DiffOptions): DiffResult

Diff two texts word by word Useful for comparing sentences or paragraphs where you want to see which words changed, not which characters.

function diffChars(oldText: string, newText: string, options?: DiffOptions): DiffResult

Diff two texts character by character Finest-grained diff showing exactly which characters changed. Most useful for short strings or when you need precise differences.

function diffSentences(oldText: string, newText: string, options?: DiffOptions): DiffResult

Diff two texts sentence by sentence Useful for comparing paragraphs or documents where you want to see which sentences changed.

function diffJson(oldValue: unknown, newValue: unknown, options?: DiffOptions): DiffResult

Diff two JSON-serializable values Stringifies the values with pretty-printing and diffs line by line. Useful for comparing configuration objects, API responses, etc.

function diffJsonString(oldJson: string, newJson: string, options?: DiffOptions): DiffResult

Diff two JSON strings Parses the JSON strings and diffs them.

function diffArrays<T>(oldArray: T[], newArray: T[], equals?: EqualityFn<T>): DiffResult

Diff two arrays element by element Uses Myers algorithm to find the minimal edit script. Supports custom equality function for complex element types.

function diffPrimitiveArrays<T extends string | number | boolean>(oldArray: T[], newArray: T[]): DiffResult

Diff two arrays of primitives (shorthand)

function diffObjects(oldObj: Record<string, unknown>, newObj: Record<string, unknown>, path?: (string | number)[]): StructuredDiffChange[]

Diff two objects and return structured changes Returns an array of changes with operations: - CREATE: Property was added - REMOVE: Property was removed - CHANGE: Property value changed This is similar to the microdiff package but with deep comparison support.

function applyChanges(obj: Record<string, unknown>, changes: StructuredDiffChange[]): Record<string, unknown>

Apply structured changes to an object Takes an array of changes and applies them to create a new object.

function diffJson(oldValue: unknown, newValue: unknown, options?: DiffOptions): DiffResult

Diff two JSON-serializable values Stringifies the values with pretty-printing and diffs line by line. Useful for comparing configuration objects, API responses, etc.

function diffJsonString(oldJson: string, newJson: string, options?: DiffOptions): DiffResult

Diff two JSON strings Parses the JSON strings and diffs them.

function diffArrays<T>(oldArray: T[], newArray: T[], equals?: EqualityFn<T>): DiffResult

Diff two arrays element by element Uses Myers algorithm to find the minimal edit script. Supports custom equality function for complex element types.

function diffPrimitiveArrays<T extends string | number | boolean>(oldArray: T[], newArray: T[]): DiffResult

Diff two arrays of primitives (shorthand)

function diffObjects(oldObj: Record<string, unknown>, newObj: Record<string, unknown>, path?: (string | number)[]): StructuredDiffChange[]

Diff two objects and return structured changes Returns an array of changes with operations: - CREATE: Property was added - REMOVE: Property was removed - CHANGE: Property value changed This is similar to the microdiff package but with deep comparison support.

function applyChanges(obj: Record<string, unknown>, changes: StructuredDiffChange[]): Record<string, unknown>

Apply structured changes to an object Takes an array of changes and applies them to create a new object.

function tokenizeLines(text: string): string[]

Tokenize text into lines Preserves line endings in the tokens for accurate reconstruction

function tokenizeWords(text: string): string[]

Tokenize text into words Preserves whitespace as separate tokens for accurate reconstruction

function tokenizeChars(text: string): string[]

Tokenize text into characters Handles Unicode properly using spread operator

function tokenizeSentences(text: string): string[]

Tokenize text into sentences Splits on sentence-ending punctuation (., !, ?)

function stripNewline(line: string): string

Remove trailing newline from a line Useful when you want to compare line content without line endings

function joinTokens(tokens: string[]): string

Join tokens back into text Simple utility to reconstruct text from tokens

function tokenizeLines(text: string): string[]

Tokenize text into lines Preserves line endings in the tokens for accurate reconstruction

function tokenizeWords(text: string): string[]

Tokenize text into words Preserves whitespace as separate tokens for accurate reconstruction

function tokenizeChars(text: string): string[]

Tokenize text into characters Handles Unicode properly using spread operator

function tokenizeSentences(text: string): string[]

Tokenize text into sentences Splits on sentence-ending punctuation (., !, ?)

function stripNewline(line: string): string

Remove trailing newline from a line Useful when you want to compare line content without line endings

function joinTokens(tokens: string[]): string

Join tokens back into text Simple utility to reconstruct text from tokens