Function compare

api/diffview.ts:470–554

(start : number)

                        },
                        // compare is the fuzzy string comparison algorithm
                        compare = function diffview_report_charcomp_compare(start : number): [number, number, number, boolean]{
                            let x: number = 0,
                                y: number = 0,
                                whitespace: boolean = false,
                                wordtest: boolean = false,
                                store: compareStore = [];
                            const max: number = Math.max(dataA.length, dataB.length),
                                sorta = function diffview_report_charcomp_compare_sorta(a : number[], b : number[]): 1 | -1 {
                                    if(a[1] - a[0] < b[1] - b[0]) {
                                        return 1;
                                    }
                                    return -1;
                                },
                                sortb = function diffview_report_charcomp_compare_sortb(a : number[], b : number[]): 1 | -1 {
                                    if(a[0] + a[1] > b[0] + b[1]) {
                                        return 1;
                                    }
                                    return -1;
                                },
                                whitetest: RegExp = (/^(\s+)$/);
                            // first gather a list of all matching indexes into an array
                            x = start;
                            do {
                                y = start;
                                do {
                                    if (dataA[x] === dataB[y] || dataB[x] === dataA[y]) {
                                        store.push([x, y]);
                                        if (dataA[y] === dataB[x] && dataA[y + 1] === dataB[x + 1] && whitetest.test(dataB[x - 1]) === true) {
                                            wordtest = true;
                                            store = [[x, y]];
                                        }
                                        if (dataA[x] === dataB[y] && dataA[x + 1] === dataB[y + 1] && whitetest.test(dataB[y - 1]) === true) {
                                            wordtest = true;
                                            store = [[x, y]];
                                        }
                                        break;
                                    }
                                    y = y + 1;
                                } while (y < max);
                                if (wordtest === true) {
                                    break;
                                }
                                x = x + 1;
                            } while (x < dataMinLength);
                            // if there are no character matches then quit out
                            if (store.length === 0) {
                                return [dataMinLength, max, 0, whitespace];
                            }
                            // take the list of matches and sort it first sort by size of change with
                            // shortest up front second sort by sum of change start and end the second sort
                            // results in the smallest change from the earliest point
                            store.sort(sorta);
                            if (dataMinLength - start < 5000) {
                                store.sort(sortb);
                            }
                            // x should always be the shorter index (change start)
                            if (store[0][0] < store[0][1]) {
                                x = store[0][0];