@types/diff

method castInput

castInput: (value: any, options: any) => any;

method diff

diff: (
    oldString: string,
    newString: string,
    options?:
        | Callback<Change[]>
        | (ArrayOptions<any, any> & Partial<CallbackOptions<Change[]>>)
) => Change[];

method equals

equals: (left: any, right: any, options: any) => boolean;

method extractCommon

extractCommon: (
    basePath: BestPath,
    newString: string,
    oldString: string,
    diagonalPath: number
) => number;

method join

join: (tokens: string[]) => string;

method postProcess

postProcess: (changes: Change[], options: any) => Change[];

method pushComponent

pushComponent: (components: Change[], added: boolean, removed: boolean) => void;

method removeEmpty

removeEmpty: (array: any[]) => any[];

method tokenize

tokenize: (value: string, options: any) => any;

method complete

complete: (err: any) => void;

method loadFile

loadFile: (
    index: ParsedDiff,
    callback: (err: any, data: string) => void
) => void;

method patched

patched: (
    index: ParsedDiff,
    content: string,
    callback: (err: any) => void
) => void;

property autoConvertLineEndings

autoConvertLineEndings?: boolean | undefined;

• If true, and if the file to be patched consistently uses different line endings to the patch (i.e. either the file always uses Unix line endings while the patch uses Windows ones, or vice versa), then applyPatch will behave as if the line endings in the patch were the same as those in the source file. (If false, the patch will usually fail to apply in such circumstances since lines deleted in the patch won't be considered to match those in the source file.) Defaults to true.

property compareLine

compareLine?:
    | ((
          lineNumber: number,
          line: string,
          operation: '-' | ' ',
          patchContent: string
      ) => boolean)
    | undefined;

• Callback used to compare to given lines to determine if they should be considered equal when patching. Should return false if the lines should be rejected.

  strict equality

property fuzzFactor

fuzzFactor?: number | undefined;

• Number of lines that are allowed to differ before rejecting a patch. 0

property added

added?: boolean | undefined;

property count

count?: number | undefined;

property removed

removed?: boolean | undefined;

property value

value: T[];

property comparator

comparator?: ((left: TLeft, right: TRight) => boolean) | undefined;

• Comparator for custom equality checks.

property ignoreCase

ignoreCase?: boolean | undefined;

• true to ignore casing difference. false

property maxEditLength

maxEditLength?: number | undefined;

• a number specifying the maximum edit distance to consider between the old and new texts. If the edit distance is higher than this, jsdiff will return undefined instead of a diff. You can use this to limit the computational cost of diffing large, very different texts by giving up early if the cost will be huge. Works for functions that return change objects and also for structuredPatch, but not other patch-generation functions.

property oneChangePerToken

oneChangePerToken?: boolean | undefined;

• if true, the array of change objects returned will contain one change object per token (e.g. one per line if calling diffLines), instead of runs of consecutive tokens that are all added / all removed / all conserved being combined into a single change object.

property components

components: Change[];

property newPos

newPos: number;

property callback

callback: Callback<T>;

• if provided, the diff will be computed in async mode to avoid blocking the event loop while the diff is calculated. The value of the callback option should be a function and will be passed the computed diff or patch as its first argument.

property added

added: boolean;

• true if the value was inserted into the new string, otherwise false

property count

count?: number | undefined;

property removed

removed: boolean;

• true if the value was removed from the old string, otherwise false

property value

value: string;

• Text content.

property lines

lines: string[];

property newLines

newLines: number;

property newStart

newStart: number;

property oldLines

oldLines: number;

property oldStart

oldStart: number;

property stringifyReplacer

stringifyReplacer?: ((key: string, value: any) => any) | undefined;

• Replacer used to stringify the properties of the passed objects.

property undefinedReplacement

undefinedReplacement?: any;

• The value to use when undefined values in the passed objects are encountered during stringification. Will only be used if stringifyReplacer option wasn't specified. undefined

property ignoreNewlineAtEof

ignoreNewlineAtEof?: boolean | undefined;

• true to ignore a missing newline character at the end of the last line when comparing it to other lines. (By default, the line 'b\n' in text 'a\nb\nc' is not considered equal to the line 'b' in text 'a\nb'; this option makes them be considered equal.) Ignored if ignoreWhitespace or newlineIsToken are also true.

property ignoreWhitespace

ignoreWhitespace?: boolean | undefined;

• true to ignore leading and trailing whitespace. This is the same as diffTrimmedLines().

property newlineIsToken

newlineIsToken?: boolean | undefined;

• true to treat newline characters as separate tokens. This allows for changes to the newline structure to occur independently of the line content and to be treated as such. In general this is the more human friendly form of diffLines() and diffLines() is better suited for patches and other computer friendly output.

property hunks

hunks: Hunk[];

property index

index?: string | undefined;

property newFileName

newFileName?: string | undefined;

property newHeader

newHeader?: string | undefined;

property oldFileName

oldFileName?: string | undefined;

property oldHeader

oldHeader?: string | undefined;

property context

context?: number | undefined;

• Describes how many lines of context should be included. 4

property ignoreWhitespace

ignoreWhitespace?: boolean | undefined;

• true to ignore leading and trailing whitespace. This is the same as diffWords().

property intlSegmenter

intlSegmenter?: Intl.Segmenter | undefined;

• An optional [Intl.Segmenter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter) object (which must have a granularity of 'word') for diffWords to use to split the text into words.

  By default, diffWords does not use an Intl.Segmenter, just some regexes for splitting text into words. This will tend to give worse results than Intl.Segmenter would, but ensures the results are consistent across environments; Intl.Segmenter behaviour is only loosely specced and the implementations in browsers could in principle change dramatically in future. If you want to use diffWords with an Intl.Segmenter but ensure it behaves the same whatever environment you run it in, use an Intl.Segmenter polyfill instead of the JavaScript engine's native Intl.Segmenter implementation.

  Using an Intl.Segmenter should allow better word-level diffing of non-English text than the default behaviour. For instance, Intl.Segmenters can generally identify via built-in dictionaries which sequences of adjacent Chinese characters form words, allowing word-level diffing of Chinese. By specifying a language when instantiating the segmenter (e.g. new Intl.Segmenter('sv', {granularity: 'word'})) you can also support language-specific rules, like treating Swedish's colon separated contractions (like *k:a* for *kyrka*) as single words; by default this would be seen as two words separated by a colon.