"use strict";

const diffview = function diffview_(options : any): [string, number, number]{

const tab: string = (function diffview_tab(): string {

let a: number = 0;

const output: string[] = [];

if (options.indent_char === "" || options.indent_size < 1) {

return "";

}

do {

output.push(options.indent_char);

a = a + 1;

} while (a < options.indent_size);

return output.join("");

}()),

// translates source code from a string to an array by splitting on line breaks

stringAsLines = function diffview_stringAsLines(str : string): string[]{

const lines = (options.diff_format === "text")

? str

: str

.replace(/&/g, "&amp;")

.replace(/&#lt;/g, "$#lt;")

.replace(/&#gt;/g, "$#gt;")

.replace(/</g, "$#lt;")

.replace(/>/g, "$#gt;");

if (options.crlf === true) {

return lines.split("\r\n");

}

return lines.split("\n");

},

// array representation of base source

baseTextArray: string[] = (typeof options.source === "string")

? stringAsLines(options.source)

: options.source,

// array representation of new source

newTextArray: string[] = (typeof options.diff === "string")

? stringAsLines(options.diff)

: options.diff,

codeBuild = function diffview_opcodes(): opcodes {

const table: difftable = {},

one: string[] = baseTextArray,

two: string[] = newTextArray;

let lena: number = one.length,

lenb: number = two.length,

a: number = 0,

b: number = 0,

c: number = 0,

d: number = 0,

codes: opcodes = [],

clean = function diffview_opcodes_clean(ln:string): string|void {

if (ln === undefined) { return; }

return options.diff_space_ignore === true ? ln.replace(/\s+/g, '') : ln;

},

fix = function diffview_opcodes_fix(code:codes): void {

let len:number = codes.length - 1,

prior:[string, number, number, number, number] = codes[len];

if (prior !== undefined) {

if (prior[0] === code[0]) {

if (code[0] === "replace" || code[0] === "equal") {

prior[2] = code[2];

prior[4] = code[4];

} else if (code[0] === "delete") {

prior[2] = code[2];

} else if (code[0] === "insert") {

prior[4] = code[4];

}

if (codes.length > 1 && prior[2] === code[2] && prior[4] === code[4]) {

if (prior[0] === "insert" && clean(two[codes[codes.length - 2][4] - (prior[4] - prior[3])]) === clean(one[codes[codes.length - 2][1]])) {

codes.pop();

len = len - 1;

codes[len] = ["insert", -1, -1, codes[len][3], codes[len][4] - (prior[4] - prior[3])];

if (codes[len][4] < 0) {

codes[len][4] = prior[4] - prior[3];

}

do {

// one-sided replacement undo, more like undelete

table[one[c]][0] = table[one[c]][0] + 1;

c = c - 1;

} while (c > codes[codes.length - 2][2]);

d = codes[len][4] - 1;

}

}

return;

}

if (prior[0] === "insert" && prior[4] - prior[3] === 1) {

if (code[2] - code[1] === 1) {

if (code[0] === "replace") {

codes[len] = ["replace", code[1], code[2], prior[3], prior[4]];

prior = codes[len];

code = ["insert", -1, -2, code[3], code[4]];

} else if (code[0] === "delete") {

code = ["replace", code[1], code[2], prior[3], prior[4]];

codes.pop();

len = len - 1;

prior = codes[len];

if (codes[len][0] === "replace") {

prior[2] = code[2];

prior[4] = code[4];

return;

}

}

} else if (code[0] === "delete") {

codes[len] = ["replace", code[1], code[1] + 1, prior[3], prior[4]];

prior = codes[len];

code[1] = code[1] + 1;

} else if (code[0] === "replace") {

codes[len] = ["replace", code[1], code[1] + 1, prior[3], prior[4]];

prior = codes[len];

c = (prior[2] > 0)

? prior[2]

: 0;

d = (prior[4] > 0)

? prior[4]

: 0;

return;

}

} else if (prior[0] === "insert" && code[0] === "delete" && code[2] - code[1] === 1) {

prior[4] = prior[4] - 1;

code = ["replace", code[1], code[2], prior[4], prior[4] + 1];

} else if (prior[0] === "delete" && prior[2] - prior[1] === 1) {

if (code[4] - code[3] === 1) {

if (code[0] === "replace") {

codes[len] = ["replace", prior[1], prior[2], code[3], code[4]];

prior = codes[len];

code = ["delete", code[1], code[2], -1, -1];

} else if (code[0] === "insert") {

code = ["replace", prior[1], prior[2], code[3], code[4]];

codes.pop();

len = len - 1;

prior = codes[len];

if (codes[len][0] === "replace") {

prior[2] = code[2];

prior[4] = code[4];

return;

}

}

} else if (code[0] === "insert") {

codes[len] = ['replace', prior[1], prior[2], code[3], code[3] + 1];

prior = codes[len];

code[3] = code[3] + 1;

} else if (code[0] === "replace") {

codes[len] = ["replace", prior[1], prior[2], code[3], code[4] + 1];

c = (prior[2] > 0)

? prior[2]

: 0;

d = (prior[4] > 0)

? prior[4]

: 0;

return;

}

} else if (prior[0] === "delete" && code[0] === "insert" && code[4] - code[3] === 1) {

prior[2] = prior[2] - 1;

code = ["replace", prior[2], prior[2] + 1, code[3], code[4]];

} else if (prior[0] === "replace") {

if (code[0] === "delete" && code[2] - 1 > a) {

c = (code[2] - 1 > 0)

? code[2] - 1

: 0;

d = (prior[3] > 0)

? prior[3]

: 0;

codes[len] = ["delete", prior[1], code[2] - 1, -1, -1];

return;

}

if (code[0] === "insert" && code[4] - 1 > b) {

c = (prior[1] > 0)

? prior[1]

: 0;

d = (code[4] - 1 > 0)

? code[4] - 1

: 0;

codes[len] = ["insert", -1, -1, prior[3], code[4] - 1];

return;

}

}

}

if (codes.length > 1 && codes[codes.length - 2][0] === codes[len][0]) {

codes[codes.length - 2][2] = codes[len][2];

codes[codes.length - 2][4] = codes[len][4];

codes.pop();

diffview_opcodes_fix(code);

} else {

codes.push(code);

}

},

equality = function diffview_opcodes_equality(): void {

do {

table[one[c]][0] = table[one[c]][0] - 1;

table[one[c]][1] = table[one[c]][1] - 1;

c = c + 1;

d = d + 1;

} while (c < lena && d < lenb && clean(one[c]) === clean(two[d]));

fix(["equal", a, c, b, d]);

b = d - 1;

a = c - 1;

},

deletion = function diffview_opcodes_deletion(): void {

do {

table[one[c]][0] = table[one[c]][0] - 1;

c = c + 1;

} while (c < lena && table[one[c]][1] < 1);

fix(["delete", a, c, -1, -1]);

a = c - 1;

b = d - 1;

},

deletionStatic = function diffview_opcodes_deletionStatic(): void {

table[one[a]][0] = table[one[a]][0] - 1;

fix([

"delete", a, a + 1,

-1,

-1

]);

a = c;

b = d - 1;

},

insertion = function diffview_opcodes_insertion(): void {

do {

table[two[d]][1] = table[two[d]][1] - 1;

d = d + 1;

} while (d < lenb && table[two[d]][0] < 1);

fix(["insert", -1, -1, b, d]);

a = c - 1;

b = d - 1;

},

insertionStatic = function diffview_opcodes_insertionStatic(): void {

table[two[b]][1] = table[two[b]][1] - 1;

fix([

"insert", -1, -1, b, b + 1

]);

a = c - 1;

b = d;

},

replacement = function diffview_opcodes_replacement(): void {

do {

table[one[c]][0] = table[one[c]][0] - 1;

table[two[d]][1] = table[two[d]][1] - 1;

c = c + 1;

d = d + 1;

} while (c < lena && d < lenb && table[one[c]][1] > 0 && table[two[d]][0] > 0);

fix(["replace", a, c, b, d]);

a = c - 1;

b = d - 1;

},

replaceUniques = function diffview_opcodes_replaceUniques(): void {

do {

table[one[c]][0] = table[one[c]][0] - 1;

c = c + 1;

d = d + 1;

} while (c < lena && d < lenb && table[one[c]][1] < 1 && table[two[d]][0] < 1);

fix(["replace", a, c, b, d]);

a = c - 1;

b = d - 1;

};

// * First Pass, account for lines from first file

// * build the table from the second file

do {

if (table[two[b]] === undefined) {

table[two[b]] = [0, 1];

} else {

table[two[b]][1] = table[two[b]][1] + 1;

}

b = b + 1;

} while (b < lenb);

// * Second Pass, account for lines from second file

// * build the table from the first file

lena = one.length;

a = 0;

do {

if (table[one[a]] === undefined) {

table[one[a]] = [1, 0];

} else {

table[one[a]][0] = table[one[a]][0] + 1;

}

a = a + 1;

} while (a < lena);

a = 0;

b = 0;

// find all equality... differences are what's left over solve only for the

// second set test removing reverse test removing undefined checks for table

// refs

do {

c = a;

d = b;

if (clean(one[a]) === clean(two[b])) {

equality();

} else if (table[one[a]][1] < 1 && table[two[b]][0] < 1) {

replaceUniques();

} else if (table[one[a]][1] < 1 && clean(one[a + 1]) !== clean(two[b + 2])) {

deletion();

} else if (table[two[b]][0] < 1 && clean(one[a + 2]) !== clean(two[b + 1])) {

insertion();

} else if (table[one[a]][0] - table[one[a]][1] === 1 && clean(one[a + 1]) !== clean(two[b + 2])) {

deletionStatic();

} else if (table[two[b]][1] - table[two[b]][0] === 1 && clean(one[a + 2]) !== clean(two[b + 1])) {

insertionStatic();

} else if (clean(one[a + 1]) === clean(two[b])) {

deletion();

} else if (clean(one[a]) === clean(two[b + 1])) {

insertion();

} else {

replacement();

}

a = a + 1;

b = b + 1;

} while (a < lena && b < lenb);

if (lena - a === lenb - b) {

if (clean(one[a]) === clean(two[b])) {

fix(["equal", a, lena, b, lenb]);

} else {

fix(["replace", a, lena, b, lenb]);

}

} else if (a < lena) {

fix(["delete", a, lena, -1, -1]);

} else if (b < lenb) {

fix(["insert", -1, -1, b, lenb]);

}

return codes;

};

let errorout: number = 0,

// diffline is a count of lines that are not equal

diffline: number = 0,

// tab is a construct of a standard indentation for code

opcodes: opcodes = [];

if (Array.isArray(options.source) === false && typeof options.source !== "string") {

return ["Error: source value is not a string or array!", 0, 0];

}

if (Array.isArray(options.diff) === false && typeof options.diff !== "string") {

return ["Error: diff value is not a string or array!", 0, 0];

}

opcodes = codeBuild();

// diffview application contains three primary parts

// 1. opcodes - performs the 'largest common subsequence' calculation to

// determine which lines are different. I did not write this logic. I have

// rewritten it for performance, but original logic is still intact.

// 2. charcomp - performs the 'largest common subsequence' upon characters

// of two compared lines.

// 3. The construction of the output into the 'node' array errorout is a count

// of differences after the opcodes generate the other two core pieces of logic

// are quaranteened into an anonymous function.

return(function diffview_report(): [string, number, number]{

let a: number = 0,

i: number = 0,

node: string[] = ["<div class='diff'>"],

diffplural: string = "s",

linesplural: string = "s",

baseStart: number = 0,

baseEnd: number = 0,

newStart: number = 0,

newEnd: number = 0,

rowcnt: number = 0,

rowItem: number = -1,

rcount: number = 0,

foldcount: number = 0,

foldstart: number = -1,

jump: number = 0,

change: string = "",

btest: boolean = false,

ntest: boolean = false,

repeat: boolean = false,

ctest: boolean = true,

code: codes,

baseItem:string = "",

newItem:string = "",

charcompOutput: [

string, string

],

finaldoc: string = "";

const data: [

string[], string[], string[], string[]

] = [

[], [], [], []

],

json: diffJSON = [],

clidata: string[] = [],

tabFix: RegExp = new RegExp(`^((${tab.replace(/\\/g, "\\")})+)`),

noTab = function diffview_report_noTab(str : string[]): string[]{

let b: number = 0;

const strLen: number = str.length,

output: string[] = [];

if (strLen < 1) {

return output;

}

do {

output.push(str[b].replace(tabFix, ""));

b = b + 1;

} while (b < strLen);

return output;

},

htmlfix = function diffview_report_htmlfix(item:string): string {

if (item === undefined) {

return "";

}

return item

.replace(/&/g, "&amp;")

.replace(/</g, "&lt;")

.replace(/>/g, "&gt;");

},

baseTab: string[] = (tab === "")

? []

: noTab(baseTextArray),

newTab: string[] = (tab === "")

? []

: noTab(newTextArray),

opcodesLength: number = opcodes.length,

// this is the character comparison logic that performs the 'largest common

// subsequence' between two lines of code

charcomp = function diffview_report_charcomp(lineA:string, lineB:string): [string, string]{

let b: number = 0,

currentdiff = [],

dataMinLength: number = 0,

dataA: string[] = [],

dataB: string[] = [];

const cleanedA: string = (options.diff_format === "text")

? lineA

: lineA

.replace(/&#160;/g, " ")

.replace(/&nbsp;/g, " ")

.replace(/&lt;/g, "<")

.replace(/&gt;/g, ">")

.replace(/\$#lt;/g, "<")

.replace(/\$#gt;/g, ">")

.replace(/&amp;/g, "&"),

cleanedB: string = (options.diff_format === "text")

? lineB

: lineB

.replace(/&#160;/g, " ")

.replace(/&nbsp;/g, " ")

.replace(/&lt;/g, "<")

.replace(/&gt;/g, ">")

.replace(/\$#lt;/g, "<")

.replace(/\$#gt;/g, ">")

.replace(/&amp;/g, "&"),

regStart: RegExp = (/_pdiffdiff\u005f/g),

regEnd: RegExp = (/_epdiffdiff\u005f/g),

strStart: string = "_pdiffdiff\u005f",

strEnd: string = "_epdiffdiff\u005f",

tabdiff: [string, string, string, string] = (function diffview_report_charcomp_tabdiff(): [string, string, string, string]{

let tabMatchA: string = "",

tabMatchB: string = "",

splitA: string = "",

splitB: string = "",

matchListA: string[] | null = cleanedA.match(tabFix),

matchListB: string[] | null = cleanedB.match(tabFix);

if (matchListA === null || matchListB === null || (matchListA[0] === "" && matchListA.length === 1) || (matchListB[0] === "" && matchListB.length === 1)) {

return ["", "", cleanedA, cleanedB];

}

tabMatchA = matchListA[0];

tabMatchB = matchListB[0];

splitA = cleanedA.split(tabMatchA)[1];

splitB = cleanedB.split(tabMatchB)[1];

if (tabMatchA.length > tabMatchB.length) {

tabMatchA = tabMatchA.slice(0, tabMatchB.length) + strStart + tabMatchA.slice(tabMatchB.length) + strEnd;

} else {

tabMatchB = tabMatchB.slice(0, tabMatchA.length) + strStart + tabMatchB.slice(tabMatchA.length) + strEnd;

}

return [tabMatchA, tabMatchB, splitA, splitB];

}()),

whiteout = function diffview_report_charcomp_whiteout(whitediff : string): string {

const spacetest: RegExp = (/<((em)|(pd))>\u0020+<\/((em)|(pd))>/),

crtest: RegExp = (/<((em)|(pd))>\r+<\/((em)|(pd))>/);

if (spacetest.test(whitediff) === true) {

return whitediff;

}

if (crtest.test(whitediff) === true) {

return whitediff.replace(/\s+/, "(carriage return)");

}

return whitediff.replace(/\s+/, "(white space differences)");

},

// 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];

y = store[0][1];

} else {

y = store[0][0];

x = store[0][1];

}

// package the output

if (dataA[y] === dataB[x]) {

if (dataA[y - 1] === dataB[x - 1] && x !== start) {

x = x - 1;

y = y - 1;

}

if (options.diff_space_ignore === true && ((whitetest.test(dataA[y - 1]) === true && y - start > 0) || (whitetest.test(dataB[x - 1]) === true && x - start > 0))) {

whitespace = true;