admin08077/Githubgemini
0
1{"version":3,"file":"diff-CqM5-8zX.js","sources":["../../node_modules/diff/lib/index.mjs"],"sourcesContent":["function Diff() {}\nDiff.prototype = {\n diff: function diff(oldString, newString) {\n var _options$timeout;\n\n var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n var callback = options.callback;\n\n if (typeof options === 'function') {\n callback = options;\n options = {};\n }\n\n this.options = options;\n var self = this;\n\n function done(value) {\n if (callback) {\n setTimeout(function () {\n callback(undefined, value);\n }, 0);\n return true;\n } else {\n return value;\n }\n } // Allow subclasses to massage the input prior to running\n\n\n oldString = this.castInput(oldString);\n newString = this.castInput(newString);\n oldString = this.removeEmpty(this.tokenize(oldString));\n newString = this.removeEmpty(this.tokenize(newString));\n var newLen = newString.length,\n oldLen = oldString.length;\n var editLength = 1;\n var maxEditLength = newLen + oldLen;\n\n if (options.maxEditLength) {\n maxEditLength = Math.min(maxEditLength, options.maxEditLength);\n }\n\n var maxExecutionTime = (_options$timeout = options.timeout) !== null && _options$timeout !== void 0 ? _options$timeout : Infinity;\n var abortAfterTimestamp = Date.now() + maxExecutionTime;\n var bestPath = [{\n oldPos: -1,\n lastComponent: undefined\n }]; // Seed editLength = 0, i.e. the content starts with the same values\n\n var newPos = this.extractCommon(bestPath[0], newString, oldString, 0);\n\n if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {\n // Identity per the equality and tokenizer\n return done([{\n value: this.join(newString),\n count: newString.length\n }]);\n } // Once we hit the right edge of the edit graph on some diagonal k, we can\n // definitely reach the end of the edit graph in no more than k edits, so\n // there's no point in considering any moves to diagonal k+1 any more (from\n // which we're guaranteed to need at least k+1 more edits).\n // Similarly, once we've reached the bottom of the edit graph, there's no\n // point considering moves to lower diagonals.\n // We record this fact by setting minDiagonalToConsider and\n // maxDiagonalToConsider to some finite value once we've hit the edge of\n // the edit graph.\n // This optimization is not faithful to the original algorithm presented in\n // Myers's paper, which instead pointlessly extends D-paths off the end of\n // the edit graph - see page 7 of Myers's paper which notes this point\n // explicitly and illustrates it with a diagram. This has major performance\n // implications for some common scenarios. For instance, to compute a diff\n // where the new text simply appends d characters on the end of the\n // original text of length n, the true Myers algorithm will take O(n+d^2)\n // time while this optimization needs only O(n+d) time.\n\n\n var minDiagonalToConsider = -Infinity,\n maxDiagonalToConsider = Infinity; // Main worker method. checks all permutations of a given edit length for acceptance.\n\n function execEditLength() {\n for (var diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {\n var basePath = void 0;\n var removePath = bestPath[diagonalPath - 1],\n addPath = bestPath[diagonalPath + 1];\n\n if (removePath) {\n // No one else is going to attempt to use this value, clear it\n bestPath[diagonalPath - 1] = undefined;\n }\n\n var canAdd = false;\n\n if (addPath) {\n // what newPos will be after we do an insertion:\n var addPathNewPos = addPath.oldPos - diagonalPath;\n canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;\n }\n\n var canRemove = removePath && removePath.oldPos + 1 < oldLen;\n\n if (!canAdd && !canRemove) {\n // If this path is a terminal then prune\n bestPath[diagonalPath] = undefined;\n continue;\n } // Select the diagonal that we want to branch from. We select the prior\n // path whose position in the old string is the farthest from the origin\n // and does not pass the bounds of the diff graph\n // TODO: Remove the `+ 1` here to make behavior match Myers algorithm\n // and prefer to order removals before insertions.\n\n\n if (!canRemove || canAdd && removePath.oldPos + 1 < addPath.oldPos) {\n basePath = self.addToPath(addPath, true, undefined, 0);\n } else {\n basePath = self.addToPath(removePath, undefined, true, 1);\n }\n\n newPos = self.extractCommon(basePath, newString, oldString, diagonalPath);\n\n if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {\n // If we have hit the end of both strings, then we are done\n return done(buildValues(self, basePath.lastComponent, newString, oldString, self.useLongestToken));\n } else {\n bestPath[diagonalPath] = basePath;\n\n if (basePath.oldPos + 1 >= oldLen) {\n maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);\n }\n\n if (newPos + 1 >= newLen) {\n minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);\n }\n }\n }\n\n editLength++;\n } // Performs the length of edit iteration. Is a bit fugly as this has to support the\n // sync and async mode which is never fun. Loops over execEditLength until a value\n // is produced, or until the edit length exceeds options.maxEditLength (if given),\n // in which case it will return undefined.\n\n\n if (callback) {\n (function exec() {\n setTimeout(function () {\n if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {\n return callback();\n }\n\n if (!execEditLength()) {\n exec();\n }\n }, 0);\n })();\n } else {\n while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {\n var ret = execEditLength();\n\n if (ret) {\n return ret;\n }\n }\n }\n },\n addToPath: function addToPath(path, added, removed, oldPosInc) {\n var last = path.lastComponent;\n\n if (last && last.added === added && last.removed === removed) {\n return {\n oldPos: path.oldPos + oldPosInc,\n lastComponent: {\n count: last.count + 1,\n added: added,\n removed: removed,\n previousComponent: last.previousComponent\n }\n };\n } else {\n return {\n oldPos: path.oldPos + oldPosInc,\n lastComponent: {\n count: 1,\n added: added,\n removed: removed,\n previousComponent: last\n }\n };\n }\n },\n extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) {\n var newLen = newString.length,\n oldLen = oldString.length,\n oldPos = basePath.oldPos,\n newPos = oldPos - diagonalPath,\n commonCount = 0;\n\n while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) {\n newPos++;\n oldPos++;\n commonCount++;\n }\n\n if (commonCount) {\n basePath.lastComponent = {\n count: commonCount,\n previousComponent: basePath.lastComponent\n };\n }\n\n basePath.oldPos = oldPos;\n return newPos;\n },\n equals: function equals(left, right) {\n if (this.options.comparator) {\n return this.options.comparator(left, right);\n } else {\n return left === right || this.options.ignoreCase && left.toLowerCase() === right.toLowerCase();\n }\n },\n removeEmpty: function removeEmpty(array) {\n var ret = [];\n\n for (var i = 0; i < array.length; i++) {\n if (array[i]) {\n ret.push(array[i]);\n }\n }\n\n return ret;\n },\n castInput: function castInput(value) {\n return value;\n },\n tokenize: function tokenize(value) {\n return value.split('');\n },\n join: function join(chars) {\n return chars.join('');\n }\n};\n\nfunction buildValues(diff, lastComponent, newString, oldString, useLongestToken) {\n // First we convert our linked list of components in reverse order to an\n // array in the right order:\n var components = [];\n var nextComponent;\n\n while (lastComponent) {\n components.push(lastComponent);\n nextComponent = lastComponent.previousComponent;\n delete lastComponent.previousComponent;\n lastComponent = nextComponent;\n }\n\n components.reverse();\n var componentPos = 0,\n componentLen = components.length,\n newPos = 0,\n oldPos = 0;\n\n for (; componentPos < componentLen; componentPos++) {\n var component = components[componentPos];\n\n if (!component.removed) {\n if (!component.added && useLongestToken) {\n var value = newString.slice(newPos, newPos + component.count);\n value = value.map(function (value, i) {\n var oldValue = oldString[oldPos + i];\n return oldValue.length > value.length ? oldValue : value;\n });\n component.value = diff.join(value);\n } else {\n component.value = diff.join(newString.slice(newPos, newPos + component.count));\n }\n\n newPos += component.count; // Common case\n\n if (!component.added) {\n oldPos += component.count;\n }\n } else {\n component.value = diff.join(oldString.slice(oldPos, oldPos + component.count));\n oldPos += component.count; // Reverse add and remove so removes are output first to match common convention\n // The diffing algorithm is tied to add then remove output and this is the simplest\n // route to get the desired output with minimal overhead.\n\n if (componentPos && components[componentPos - 1].added) {\n var tmp = components[componentPos - 1];\n components[componentPos - 1] = components[componentPos];\n components[componentPos] = tmp;\n }\n }\n } // Special case handle for when one terminal is ignored (i.e. whitespace).\n // For this case we merge the terminal into the prior string and drop the change.\n // This is only available for string mode.\n\n\n var finalComponent = components[componentLen - 1];\n\n if (componentLen > 1 && typeof finalComponent.value === 'string' && (finalComponent.added || finalComponent.removed) && diff.equals('', finalComponent.value)) {\n components[componentLen - 2].value += finalComponent.value;\n components.pop();\n }\n\n return components;\n}\n\nvar characterDiff = new Diff();\nfunction diffChars(oldStr, newStr, options) {\n return characterDiff.diff(oldStr, newStr, options);\n}\n\nfunction generateOptions(options, defaults) {\n if (typeof options === 'function') {\n defaults.callback = options;\n } else if (options) {\n for (var name in options) {\n /* istanbul ignore else */\n if (options.hasOwnProperty(name)) {\n defaults[name] = options[name];\n }\n }\n }\n\n return defaults;\n}\n\n//\n// Ranges and exceptions:\n// Latin-1 Supplement, 0080–00FF\n// - U+00D7 × Multiplication sign\n// - U+00F7 ÷ Division sign\n// Latin Extended-A, 0100–017F\n// Latin Extended-B, 0180–024F\n// IPA Extensions, 0250–02AF\n// Spacing Modifier Letters, 02B0–02FF\n// - U+02C7 ˇ ˇ Caron\n// - U+02D8 ˘ ˘ Breve\n// - U+02D9 ˙ ˙ Dot Above\n// - U+02DA ˚ ˚ Ring Above\n// - U+02DB ˛ ˛ Ogonek\n// - U+02DC ˜ ˜ Small Tilde\n// - U+02DD ˝ ˝ Double Acute Accent\n// Latin Extended Additional, 1E00–1EFF\n\nvar extendedWordChars = /^[A-Za-z\\xC0-\\u02C6\\u02C8-\\u02D7\\u02DE-\\u02FF\\u1E00-\\u1EFF]+$/;\nvar reWhitespace = /\\S/;\nvar wordDiff = new Diff();\n\nwordDiff.equals = function (left, right) {\n if (this.options.ignoreCase) {\n left = left.toLowerCase();\n right = right.toLowerCase();\n }\n\n return left === right || this.options.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right);\n};\n\nwordDiff.tokenize = function (value) {\n // All whitespace symbols except newline group into one token, each newline - in separate token\n var tokens = value.split(/([^\\S\\r\\n]+|[()[\\]{}'\"\\r\\n]|\\b)/); // Join the boundary splits that we do not consider to be boundaries. This is primarily the extended Latin character set.\n\n for (var i = 0; i < tokens.length - 1; i++) {\n // If we have an empty string in the next field and we have only word chars before and after, merge\n if (!tokens[i + 1] && tokens[i + 2] && extendedWordChars.test(tokens[i]) && extendedWordChars.test(tokens[i + 2])) {\n tokens[i] += tokens[i + 2];\n tokens.splice(i + 1, 2);\n i--;\n }\n }\n\n return tokens;\n};\n\nfunction diffWords(oldStr, newStr, options) {\n options = generateOptions(options, {\n ignoreWhitespace: true\n });\n return wordDiff.diff(oldStr, newStr, options);\n}\nfunction diffWordsWithSpace(oldStr, newStr, options) {\n return wordDiff.diff(oldStr, newStr, options);\n}\n\nvar lineDiff = new Diff();\n\nlineDiff.tokenize = function (value) {\n if (this.options.stripTrailingCr) {\n // remove one \\r before \\n to match GNU diff's --strip-trailing-cr behavior\n value = value.replace(/\\r\\n/g, '\\n');\n }\n\n var retLines = [],\n linesAndNewlines = value.split(/(\\n|\\r\\n)/); // Ignore the final empty token that occurs if the string ends with a new line\n\n if (!linesAndNewlines[linesAndNewlines.length - 1]) {\n linesAndNewlines.pop();\n } // Merge the content and line separators into single tokens\n\n\n for (var i = 0; i < linesAndNewlines.length; i++) {\n var line = linesAndNewlines[i];\n\n if (i % 2 && !this.options.newlineIsToken) {\n retLines[retLines.length - 1] += line;\n } else {\n if (this.options.ignoreWhitespace) {\n line = line.trim();\n }\n\n retLines.push(line);\n }\n }\n\n return retLines;\n};\n\nfunction diffLines(oldStr, newStr, callback) {\n return lineDiff.diff(oldStr, newStr, callback);\n}\nfunction diffTrimmedLines(oldStr, newStr, callback) {\n var options = generateOptions(callback, {\n ignoreWhitespace: true\n });\n return lineDiff.diff(oldStr, newStr, options);\n}\n\nvar sentenceDiff = new Diff();\n\nsentenceDiff.tokenize = function (value) {\n return value.split(/(\\S.+?[.!?])(?=\\s+|$)/);\n};\n\nfunction diffSentences(oldStr, newStr, callback) {\n return sentenceDiff.diff(oldStr, newStr, callback);\n}\n\nvar cssDiff = new Diff();\n\ncssDiff.tokenize = function (value) {\n return value.split(/([{}:;,]|\\s+)/);\n};\n\nfunction diffCss(oldStr, newStr, callback) {\n return cssDiff.diff(oldStr, newStr, callback);\n}\n\nfunction _typeof(obj) {\n \"@babel/helpers - typeof\";\n\n if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n _typeof = function (obj) {\n return typeof obj;\n };\n } else {\n _typeof = function (obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n };\n }\n\n return _typeof(obj);\n}\n\nfunction _defineProperty(obj, key, value) {\n if (key in obj) {\n Object.defineProperty(obj, key, {\n value: value,\n enumerable: true,\n configurable: true,\n writable: true\n });\n } else {\n obj[key] = value;\n }\n\n return obj;\n}\n\nfunction ownKeys(object, enumerableOnly) {\n var keys = Object.keys(object);\n\n if (Object.getOwnPropertySymbols) {\n var symbols = Object.getOwnPropertySymbols(object);\n if (enumerableOnly) symbols = symbols.filter(function (sym) {\n return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n });\n keys.push.apply(keys, symbols);\n }\n\n return keys;\n}\n\nfunction _objectSpread2(target) {\n for (var i = 1; i < arguments.length; i++) {\n var source = arguments[i] != null ? arguments[i] : {};\n\n if (i % 2) {\n ownKeys(Object(source), true).forEach(function (key) {\n _defineProperty(target, key, source[key]);\n });\n } else if (Object.getOwnPropertyDescriptors) {\n Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n } else {\n ownKeys(Object(source)).forEach(function (key) {\n Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n });\n }\n }\n\n return target;\n}\n\nfunction _toConsumableArray(arr) {\n return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();\n}\n\nfunction _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) return _arrayLikeToArray(arr);\n}\n\nfunction _iterableToArray(iter) {\n if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nfunction _unsupportedIterableToArray(o, minLen) {\n if (!o) return;\n if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n var n = Object.prototype.toString.call(o).slice(8, -1);\n if (n === \"Object\" && o.constructor) n = o.constructor.name;\n if (n === \"Map\" || n === \"Set\") return Array.from(o);\n if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\n\nfunction _arrayLikeToArray(arr, len) {\n if (len == null || len > arr.length) len = arr.length;\n\n for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n\n return arr2;\n}\n\nfunction _nonIterableSpread() {\n throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nvar objectPrototypeToString = Object.prototype.toString;\nvar jsonDiff = new Diff(); // Discriminate between two lines of pretty-printed, serialized JSON where one of them has a\n// dangling comma and the other doesn't. Turns out including the dangling comma yields the nicest output:\n\njsonDiff.useLongestToken = true;\njsonDiff.tokenize = lineDiff.tokenize;\n\njsonDiff.castInput = function (value) {\n var _this$options = this.options,\n undefinedReplacement = _this$options.undefinedReplacement,\n _this$options$stringi = _this$options.stringifyReplacer,\n stringifyReplacer = _this$options$stringi === void 0 ? function (k, v) {\n return typeof v === 'undefined' ? undefinedReplacement : v;\n } : _this$options$stringi;\n return typeof value === 'string' ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, ' ');\n};\n\njsonDiff.equals = function (left, right) {\n return Diff.prototype.equals.call(jsonDiff, left.replace(/,([\\r\\n])/g, '$1'), right.replace(/,([\\r\\n])/g, '$1'));\n};\n\nfunction diffJson(oldObj, newObj, options) {\n return jsonDiff.diff(oldObj, newObj, options);\n} // This function handles the presence of circular references by bailing out when encountering an\n// object that is already on the \"stack\" of items being processed. Accepts an optional replacer\n\nfunction canonicalize(obj, stack, replacementStack, replacer, key) {\n stack = stack || [];\n replacementStack = replacementStack || [];\n\n if (replacer) {\n obj = replacer(key, obj);\n }\n\n var i;\n\n for (i = 0; i < stack.length; i += 1) {\n if (stack[i] === obj) {\n return replacementStack[i];\n }\n }\n\n var canonicalizedObj;\n\n if ('[object Array]' === objectPrototypeToString.call(obj)) {\n stack.push(obj);\n canonicalizedObj = new Array(obj.length);\n replacementStack.push(canonicalizedObj);\n\n for (i = 0; i < obj.length; i += 1) {\n canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, key);\n }\n\n stack.pop();\n replacementStack.pop();\n return canonicalizedObj;\n }\n\n if (obj && obj.toJSON) {\n obj = obj.toJSON();\n }\n\n if (_typeof(obj) === 'object' && obj !== null) {\n stack.push(obj);\n canonicalizedObj = {};\n replacementStack.push(canonicalizedObj);\n\n var sortedKeys = [],\n _key;\n\n for (_key in obj) {\n /* istanbul ignore else */\n if (obj.hasOwnProperty(_key)) {\n sortedKeys.push(_key);\n }\n }\n\n sortedKeys.sort();\n\n for (i = 0; i < sortedKeys.length; i += 1) {\n _key = sortedKeys[i];\n canonicalizedObj[_key] = canonicalize(obj[_key], stack, replacementStack, replacer, _key);\n }\n\n stack.pop();\n replacementStack.pop();\n } else {\n canonicalizedObj = obj;\n }\n\n return canonicalizedObj;\n}\n\nvar arrayDiff = new Diff();\n\narrayDiff.tokenize = function (value) {\n return value.slice();\n};\n\narrayDiff.join = arrayDiff.removeEmpty = function (value) {\n return value;\n};\n\nfunction diffArrays(oldArr, newArr, callback) {\n return arrayDiff.diff(oldArr, newArr, callback);\n}\n\nfunction parsePatch(uniDiff) {\n var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n var diffstr = uniDiff.split(/\\r\\n|[\\n\\v\\f\\r\\x85]/),\n delimiters = uniDiff.match(/\\r\\n|[\\n\\v\\f\\r\\x85]/g) || [],\n list = [],\n i = 0;\n\n function parseIndex() {\n var index = {};\n list.push(index); // Parse diff metadata\n\n while (i < diffstr.length) {\n var line = diffstr[i]; // File header found, end parsing diff metadata\n\n if (/^(\\-\\-\\-|\\+\\+\\+|@@)\\s/.test(line)) {\n break;\n } // Diff index\n\n\n var header = /^(?:Index:|diff(?: -r \\w+)+)\\s+(.+?)\\s*$/.exec(line);\n\n if (header) {\n index.index = header[1];\n }\n\n i++;\n } // Parse file headers if they are defined. Unified diff requires them, but\n // there's no technical issues to have an isolated hunk without file header\n\n\n parseFileHeader(index);\n parseFileHeader(index); // Parse hunks\n\n index.hunks = [];\n\n while (i < diffstr.length) {\n var _line = diffstr[i];\n\n if (/^(Index:|diff|\\-\\-\\-|\\+\\+\\+)\\s/.test(_line)) {\n break;\n } else if (/^@@/.test(_line)) {\n index.hunks.push(parseHunk());\n } else if (_line && options.strict) {\n // Ignore unexpected content unless in strict mode\n throw new Error('Unknown line ' + (i + 1) + ' ' + JSON.stringify(_line));\n } else {\n i++;\n }\n }\n } // Parses the --- and +++ headers, if none are found, no lines\n // are consumed.\n\n\n function parseFileHeader(index) {\n var fileHeader = /^(---|\\+\\+\\+)\\s+(.*)$/.exec(diffstr[i]);\n\n if (fileHeader) {\n var keyPrefix = fileHeader[1] === '---' ? 'old' : 'new';\n var data = fileHeader[2].split('\\t', 2);\n var fileName = data[0].replace(/\\\\\\\\/g, '\\\\');\n\n if (/^\".*\"$/.test(fileName)) {\n fileName = fileName.substr(1, fileName.length - 2);\n }\n\n index[keyPrefix + 'FileName'] = fileName;\n index[keyPrefix + 'Header'] = (data[1] || '').trim();\n i++;\n }\n } // Parses a hunk\n // This assumes that we are at the start of a hunk.\n\n\n function parseHunk() {\n var chunkHeaderIndex = i,\n chunkHeaderLine = diffstr[i++],\n chunkHeader = chunkHeaderLine.split(/@@ -(\\d+)(?:,(\\d+))? \\+(\\d+)(?:,(\\d+))? @@/);\n var hunk = {\n oldStart: +chunkHeader[1],\n oldLines: typeof chunkHeader[2] === 'undefined' ? 1 : +chunkHeader[2],\n newStart: +chunkHeader[3],\n newLines: typeof chunkHeader[4] === 'undefined' ? 1 : +chunkHeader[4],\n lines: [],\n linedelimiters: []\n }; // Unified Diff Format quirk: If the chunk size is 0,\n // the first number is one lower than one would expect.\n // https://www.artima.com/weblogs/viewpost.jsp?thread=164293\n\n if (hunk.oldLines === 0) {\n hunk.oldStart += 1;\n }\n\n if (hunk.newLines === 0) {\n hunk.newStart += 1;\n }\n\n var addCount = 0,\n removeCount = 0;\n\n for (; i < diffstr.length; i++) {\n // Lines starting with '---' could be mistaken for the \"remove line\" operation\n // But they could be the header for the next file. Therefore prune such cases out.\n if (diffstr[i].indexOf('--- ') === 0 && i + 2 < diffstr.length && diffstr[i + 1].indexOf('+++ ') === 0 && diffstr[i + 2].indexOf('@@') === 0) {\n break;\n }\n\n var operation = diffstr[i].length == 0 && i != diffstr.length - 1 ? ' ' : diffstr[i][0];\n\n if (operation === '+' || operation === '-' || operation === ' ' || operation === '\\\\') {\n hunk.lines.push(diffstr[i]);\n hunk.linedelimiters.push(delimiters[i] || '\\n');\n\n if (operation === '+') {\n addCount++;\n } else if (operation === '-') {\n removeCount++;\n } else if (operation === ' ') {\n addCount++;\n removeCount++;\n }\n } else {\n break;\n }\n } // Handle the empty block count case\n\n\n if (!addCount && hunk.newLines === 1) {\n hunk.newLines = 0;\n }\n\n if (!removeCount && hunk.oldLines === 1) {\n hunk.oldLines = 0;\n } // Perform optional sanity checking\n\n\n if (options.strict) {\n if (addCount !== hunk.newLines) {\n throw new Error('Added line count did not match for hunk at line ' + (chunkHeaderIndex + 1));\n }\n\n if (removeCount !== hunk.oldLines) {\n throw new Error('Removed line count did not match for hunk at line ' + (chunkHeaderIndex + 1));\n }\n }\n\n return hunk;\n }\n\n while (i < diffstr.length) {\n parseIndex();\n }\n\n return list;\n}\n\n// Iterator that traverses in the range of [min, max], stepping\n// by distance from a given start position. I.e. for [0, 4], with\n// start of 2, this will iterate 2, 3, 1, 4, 0.\nfunction distanceIterator (start, minLine, maxLine) {\n var wantForward = true,\n backwardExhausted = false,\n forwardExhausted = false,\n localOffset = 1;\n return function iterator() {\n if (wantForward && !forwardExhausted) {\n if (backwardExhausted) {\n localOffset++;\n } else {\n wantForward = false;\n } // Check if trying to fit beyond text length, and if not, check it fits\n // after offset location (or desired location on first iteration)\n\n\n if (start + localOffset <= maxLine) {\n return localOffset;\n }\n\n forwardExhausted = true;\n }\n\n if (!backwardExhausted) {\n if (!forwardExhausted) {\n wantForward = true;\n } // Check if trying to fit before text beginning, and if not, check it fits\n // before offset location\n\n\n if (minLine <= start - localOffset) {\n return -localOffset++;\n }\n\n backwardExhausted = true;\n return iterator();\n } // We tried to fit hunk before text beginning and beyond text length, then\n // hunk can't fit on the text. Return undefined\n\n };\n}\n\nfunction applyPatch(source, uniDiff) {\n var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n if (typeof uniDiff === 'string') {\n uniDiff = parsePatch(uniDiff);\n }\n\n if (Array.isArray(uniDiff)) {\n if (uniDiff.length > 1) {\n throw new Error('applyPatch only works with a single input.');\n }\n\n uniDiff = uniDiff[0];\n } // Apply the diff to the input\n\n\n var lines = source.split(/\\r\\n|[\\n\\v\\f\\r\\x85]/),\n delimiters = source.match(/\\r\\n|[\\n\\v\\f\\r\\x85]/g) || [],\n hunks = uniDiff.hunks,\n compareLine = options.compareLine || function (lineNumber, line, operation, patchContent) {\n return line === patchContent;\n },\n errorCount = 0,\n fuzzFactor = options.fuzzFactor || 0,\n minLine = 0,\n offset = 0,\n removeEOFNL,\n addEOFNL;\n /**\n * Checks if the hunk exactly fits on the provided location\n */\n\n\n function hunkFits(hunk, toPos) {\n for (var j = 0; j < hunk.lines.length; j++) {\n var line = hunk.lines[j],\n operation = line.length > 0 ? line[0] : ' ',\n content = line.length > 0 ? line.substr(1) : line;\n\n if (operation === ' ' || operation === '-') {\n // Context sanity check\n if (!compareLine(toPos + 1, lines[toPos], operation, content)) {\n errorCount++;\n\n if (errorCount > fuzzFactor) {\n return false;\n }\n }\n\n toPos++;\n }\n }\n\n return true;\n } // Search best fit offsets for each hunk based on the previous ones\n\n\n for (var i = 0; i < hunks.length; i++) {\n var hunk = hunks[i],\n maxLine = lines.length - hunk.oldLines,\n localOffset = 0,\n toPos = offset + hunk.oldStart - 1;\n var iterator = distanceIterator(toPos, minLine, maxLine);\n\n for (; localOffset !== undefined; localOffset = iterator()) {\n if (hunkFits(hunk, toPos + localOffset)) {\n hunk.offset = offset += localOffset;\n break;\n }\n }\n\n if (localOffset === undefined) {\n return false;\n } // Set lower text limit to end of the current hunk, so next ones don't try\n // to fit over already patched text\n\n\n minLine = hunk.offset + hunk.oldStart + hunk.oldLines;\n } // Apply patch hunks\n\n\n var diffOffset = 0;\n\n for (var _i = 0; _i < hunks.length; _i++) {\n var _hunk = hunks[_i],\n _toPos = _hunk.oldStart + _hunk.offset + diffOffset - 1;\n\n diffOffset += _hunk.newLines - _hunk.oldLines;\n\n for (var j = 0; j < _hunk.lines.length; j++) {\n var line = _hunk.lines[j],\n operation = line.length > 0 ? line[0] : ' ',\n content = line.length > 0 ? line.substr(1) : line,\n delimiter = _hunk.linedelimiters && _hunk.linedelimiters[j] || '\\n';\n\n if (operation === ' ') {\n _toPos++;\n } else if (operation === '-') {\n lines.splice(_toPos, 1);\n delimiters.splice(_toPos, 1);\n /* istanbul ignore else */\n } else if (operation === '+') {\n lines.splice(_toPos, 0, content);\n delimiters.splice(_toPos, 0, delimiter);\n _toPos++;\n } else if (operation === '\\\\') {\n var previousOperation = _hunk.lines[j - 1] ? _hunk.lines[j - 1][0] : null;\n\n if (previousOperation === '+') {\n removeEOFNL = true;\n } else if (previousOperation === '-') {\n addEOFNL = true;\n }\n }\n }\n } // Handle EOFNL insertion/removal\n\n\n if (removeEOFNL) {\n while (!lines[lines.length - 1]) {\n lines.pop();\n delimiters.pop();\n }\n } else if (addEOFNL) {\n lines.push('');\n delimiters.push('\\n');\n }\n\n for (var _k = 0; _k < lines.length - 1; _k++) {\n lines[_k] = lines[_k] + delimiters[_k];\n }\n\n return lines.join('');\n} // Wrapper that supports multiple file patches via callbacks.\n\nfunction applyPatches(uniDiff, options) {\n if (typeof uniDiff === 'string') {\n uniDiff = parsePatch(uniDiff);\n }\n\n var currentIndex = 0;\n\n function processIndex() {\n var index = uniDiff[currentIndex++];\n\n if (!index) {\n return options.complete();\n }\n\n options.loadFile(index, function (err, data) {\n if (err) {\n return options.complete(err);\n }\n\n var updatedContent = applyPatch(data, index, options);\n options.patched(index, updatedContent, function (err) {\n if (err) {\n return options.complete(err);\n }\n\n processIndex();\n });\n });\n }\n\n processIndex();\n}\n\nfunction structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {\n if (!options) {\n options = {};\n }\n\n if (typeof options.context === 'undefined') {\n options.context = 4;\n }\n\n var diff = diffLines(oldStr, newStr, options);\n\n if (!diff) {\n return;\n }\n\n diff.push({\n value: '',\n lines: []\n }); // Append an empty value to make cleanup easier\n\n function contextLines(lines) {\n return lines.map(function (entry) {\n return ' ' + entry;\n });\n }\n\n var hunks = [];\n var oldRangeStart = 0,\n newRangeStart = 0,\n curRange = [],\n oldLine = 1,\n newLine = 1;\n\n var _loop = function _loop(i) {\n var current = diff[i],\n lines = current.lines || current.value.replace(/\\n$/, '').split('\\n');\n current.lines = lines;\n\n if (current.added || current.removed) {\n var _curRange;\n\n // If we have previous context, start with that\n if (!oldRangeStart) {\n var prev = diff[i - 1];\n oldRangeStart = oldLine;\n newRangeStart = newLine;\n\n if (prev) {\n curRange = options.context > 0 ? contextLines(prev.lines.slice(-options.context)) : [];\n oldRangeStart -= curRange.length;\n newRangeStart -= curRange.length;\n }\n } // Output our changes\n\n\n (_curRange = curRange).push.apply(_curRange, _toConsumableArray(lines.map(function (entry) {\n return (current.added ? '+' : '-') + entry;\n }))); // Track the updated file position\n\n\n if (current.added) {\n newLine += lines.length;\n } else {\n oldLine += lines.length;\n }\n } else {\n // Identical context lines. Track line changes\n if (oldRangeStart) {\n // Close out any changes that have been output (or join overlapping)\n if (lines.length <= options.context * 2 && i < diff.length - 2) {\n var _curRange2;\n\n // Overlapping\n (_curRange2 = curRange).push.apply(_curRange2, _toConsumableArray(contextLines(lines)));\n } else {\n var _curRange3;\n\n // end the range and output\n var contextSize = Math.min(lines.length, options.context);\n\n (_curRange3 = curRange).push.apply(_curRange3, _toConsumableArray(contextLines(lines.slice(0, contextSize))));\n\n var hunk = {\n oldStart: oldRangeStart,\n oldLines: oldLine - oldRangeStart + contextSize,\n newStart: newRangeStart,\n newLines: newLine - newRangeStart + contextSize,\n lines: curRange\n };\n\n if (i >= diff.length - 2 && lines.length <= options.context) {\n // EOF is inside this hunk\n var oldEOFNewline = /\\n$/.test(oldStr);\n var newEOFNewline = /\\n$/.test(newStr);\n var noNlBeforeAdds = lines.length == 0 && curRange.length > hunk.oldLines;\n\n if (!oldEOFNewline && noNlBeforeAdds && oldStr.length > 0) {\n // special case: old has no eol and no trailing context; no-nl can end up before adds\n // however, if the old file is empty, do not output the no-nl line\n curRange.splice(hunk.oldLines, 0, '\\\\ No newline at end of file');\n }\n\n if (!oldEOFNewline && !noNlBeforeAdds || !newEOFNewline) {\n curRange.push('\\\\ No newline at end of file');\n }\n }\n\n hunks.push(hunk);\n oldRangeStart = 0;\n newRangeStart = 0;\n curRange = [];\n }\n }\n\n oldLine += lines.length;\n newLine += lines.length;\n }\n };\n\n for (var i = 0; i < diff.length; i++) {\n _loop(i);\n }\n\n return {\n oldFileName: oldFileName,\n newFileName: newFileName,\n oldHeader: oldHeader,\n newHeader: newHeader,\n hunks: hunks\n };\n}\nfunction formatPatch(diff) {\n if (Array.isArray(diff)) {\n return diff.map(formatPatch).join('\\n');\n }\n\n var ret = [];\n\n if (diff.oldFileName == diff.newFileName) {\n ret.push('Index: ' + diff.oldFileName);\n }\n\n ret.push('===================================================================');\n ret.push('--- ' + diff.oldFileName + (typeof diff.oldHeader === 'undefined' ? '' : '\\t' + diff.oldHeader));\n ret.push('+++ ' + diff.newFileName + (typeof diff.newHeader === 'undefined' ? '' : '\\t' + diff.newHeader));\n\n for (var i = 0; i < diff.hunks.length; i++) {\n var hunk = diff.hunks[i]; // Unified Diff Format quirk: If the chunk size is 0,\n // the first number is one lower than one would expect.\n // https://www.artima.com/weblogs/viewpost.jsp?thread=164293\n\n if (hunk.oldLines === 0) {\n hunk.oldStart -= 1;\n }\n\n if (hunk.newLines === 0) {\n hunk.newStart -= 1;\n }\n\n ret.push('@@ -' + hunk.oldStart + ',' + hunk.oldLines + ' +' + hunk.newStart + ',' + hunk.newLines + ' @@');\n ret.push.apply(ret, hunk.lines);\n }\n\n return ret.join('\\n') + '\\n';\n}\nfunction createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {\n return formatPatch(structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options));\n}\nfunction createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {\n return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options);\n}\n\nfunction arrayEqual(a, b) {\n if (a.length !== b.length) {\n return false;\n }\n\n return arrayStartsWith(a, b);\n}\nfunction arrayStartsWith(array, start) {\n if (start.length > array.length) {\n return false;\n }\n\n for (var i = 0; i < start.length; i++) {\n if (start[i] !== array[i]) {\n return false;\n }\n }\n\n return true;\n}\n\nfunction calcLineCount(hunk) {\n var _calcOldNewLineCount = calcOldNewLineCount(hunk.lines),\n oldLines = _calcOldNewLineCount.oldLines,\n newLines = _calcOldNewLineCount.newLines;\n\n if (oldLines !== undefined) {\n hunk.oldLines = oldLines;\n } else {\n delete hunk.oldLines;\n }\n\n if (newLines !== undefined) {\n hunk.newLines = newLines;\n } else {\n delete hunk.newLines;\n }\n}\nfunction merge(mine, theirs, base) {\n mine = loadPatch(mine, base);\n theirs = loadPatch(theirs, base);\n var ret = {}; // For index we just let it pass through as it doesn't have any necessary meaning.\n // Leaving sanity checks on this to the API consumer that may know more about the\n // meaning in their own context.\n\n if (mine.index || theirs.index) {\n ret.index = mine.index || theirs.index;\n }\n\n if (mine.newFileName || theirs.newFileName) {\n if (!fileNameChanged(mine)) {\n // No header or no change in ours, use theirs (and ours if theirs does not exist)\n ret.oldFileName = theirs.oldFileName || mine.oldFileName;\n ret.newFileName = theirs.newFileName || mine.newFileName;\n ret.oldHeader = theirs.oldHeader || mine.oldHeader;\n ret.newHeader = theirs.newHeader || mine.newHeader;\n } else if (!fileNameChanged(theirs)) {\n // No header or no change in theirs, use ours\n ret.oldFileName = mine.oldFileName;\n ret.newFileName = mine.newFileName;\n ret.oldHeader = mine.oldHeader;\n ret.newHeader = mine.newHeader;\n } else {\n // Both changed... figure it out\n ret.oldFileName = selectField(ret, mine.oldFileName, theirs.oldFileName);\n ret.newFileName = selectField(ret, mine.newFileName, theirs.newFileName);\n ret.oldHeader = selectField(ret, mine.oldHeader, theirs.oldHeader);\n ret.newHeader = selectField(ret, mine.newHeader, theirs.newHeader);\n }\n }\n\n ret.hunks = [];\n var mineIndex = 0,\n theirsIndex = 0,\n mineOffset = 0,\n theirsOffset = 0;\n\n while (mineIndex < mine.hunks.length || theirsIndex < theirs.hunks.length) {\n var mineCurrent = mine.hunks[mineIndex] || {\n oldStart: Infinity\n },\n theirsCurrent = theirs.hunks[theirsIndex] || {\n oldStart: Infinity\n };\n\n if (hunkBefore(mineCurrent, theirsCurrent)) {\n // This patch does not overlap with any of the others, yay.\n ret.hunks.push(cloneHunk(mineCurrent, mineOffset));\n mineIndex++;\n theirsOffset += mineCurrent.newLines - mineCurrent.oldLines;\n } else if (hunkBefore(theirsCurrent, mineCurrent)) {\n // This patch does not overlap with any of the others, yay.\n ret.hunks.push(cloneHunk(theirsCurrent, theirsOffset));\n theirsIndex++;\n mineOffset += theirsCurrent.newLines - theirsCurrent.oldLines;\n } else {\n // Overlap, merge as best we can\n var mergedHunk = {\n oldStart: Math.min(mineCurrent.oldStart, theirsCurrent.oldStart),\n oldLines: 0,\n newStart: Math.min(mineCurrent.newStart + mineOffset, theirsCurrent.oldStart + theirsOffset),\n newLines: 0,\n lines: []\n };\n mergeLines(mergedHunk, mineCurrent.oldStart, mineCurrent.lines, theirsCurrent.oldStart, theirsCurrent.lines);\n theirsIndex++;\n mineIndex++;\n ret.hunks.push(mergedHunk);\n }\n }\n\n return ret;\n}\n\nfunction loadPatch(param, base) {\n if (typeof param === 'string') {\n if (/^@@/m.test(param) || /^Index:/m.test(param)) {\n return parsePatch(param)[0];\n }\n\n if (!base) {\n throw new Error('Must provide a base reference or pass in a patch');\n }\n\n return structuredPatch(undefined, undefined, base, param);\n }\n\n return param;\n}\n\nfunction fileNameChanged(patch) {\n return patch.newFileName && patch.newFileName !== patch.oldFileName;\n}\n\nfunction selectField(index, mine, theirs) {\n if (mine === theirs) {\n return mine;\n } else {\n index.conflict = true;\n return {\n mine: mine,\n theirs: theirs\n };\n }\n}\n\nfunction hunkBefore(test, check) {\n return test.oldStart < check.oldStart && test.oldStart + test.oldLines < check.oldStart;\n}\n\nfunction cloneHunk(hunk, offset) {\n return {\n oldStart: hunk.oldStart,\n oldLines: hunk.oldLines,\n newStart: hunk.newStart + offset,\n newLines: hunk.newLines,\n lines: hunk.lines\n };\n}\n\nfunction mergeLines(hunk, mineOffset, mineLines, theirOffset, theirLines) {\n // This will generally result in a conflicted hunk, but there are cases where the context\n // is the only overlap where we can successfully merge the content here.\n var mine = {\n offset: mineOffset,\n lines: mineLines,\n index: 0\n },\n their = {\n offset: theirOffset,\n lines: theirLines,\n index: 0\n }; // Handle any leading content\n\n insertLeading(hunk, mine, their);\n insertLeading(hunk, their, mine); // Now in the overlap content. Scan through and select the best changes from each.\n\n while (mine.index < mine.lines.length && their.index < their.lines.length) {\n var mineCurrent = mine.lines[mine.index],\n theirCurrent = their.lines[their.index];\n\n if ((mineCurrent[0] === '-' || mineCurrent[0] === '+') && (theirCurrent[0] === '-' || theirCurrent[0] === '+')) {\n // Both modified ...\n mutualChange(hunk, mine, their);\n } else if (mineCurrent[0] === '+' && theirCurrent[0] === ' ') {\n var _hunk$lines;\n\n // Mine inserted\n (_hunk$lines = hunk.lines).push.apply(_hunk$lines, _toConsumableArray(collectChange(mine)));\n } else if (theirCurrent[0] === '+' && mineCurrent[0] === ' ') {\n var _hunk$lines2;\n\n // Theirs inserted\n (_hunk$lines2 = hunk.lines).push.apply(_hunk$lines2, _toConsumableArray(collectChange(their)));\n } else if (mineCurrent[0] === '-' && theirCurrent[0] === ' ') {\n // Mine removed or edited\n removal(hunk, mine, their);\n } else if (theirCurrent[0] === '-' && mineCurrent[0] === ' ') {\n // Their removed or edited\n removal(hunk, their, mine, true);\n } else if (mineCurrent === theirCurrent) {\n // Context identity\n hunk.lines.push(mineCurrent);\n mine.index++;\n their.index++;\n } else {\n // Context mismatch\n conflict(hunk, collectChange(mine), collectChange(their));\n }\n } // Now push anything that may be remaining\n\n\n insertTrailing(hunk, mine);\n insertTrailing(hunk, their);\n calcLineCount(hunk);\n}\n\nfunction mutualChange(hunk, mine, their) {\n var myChanges = collectChange(mine),\n theirChanges = collectChange(their);\n\n if (allRemoves(myChanges) && allRemoves(theirChanges)) {\n // Special case for remove changes that are supersets of one another\n if (arrayStartsWith(myChanges, theirChanges) && skipRemoveSuperset(their, myChanges, myChanges.length - theirChanges.length)) {\n var _hunk$lines3;\n\n (_hunk$lines3 = hunk.lines).push.apply(_hunk$lines3, _toConsumableArray(myChanges));\n\n return;\n } else if (arrayStartsWith(theirChanges, myChanges) && skipRemoveSuperset(mine, theirChanges, theirChanges.length - myChanges.length)) {\n var _hunk$lines4;\n\n (_hunk$lines4 = hunk.lines).push.apply(_hunk$lines4, _toConsumableArray(theirChanges));\n\n return;\n }\n } else if (arrayEqual(myChanges, theirChanges)) {\n var _hunk$lines5;\n\n (_hunk$lines5 = hunk.lines).push.apply(_hunk$lines5, _toConsumableArray(myChanges));\n\n return;\n }\n\n conflict(hunk, myChanges, theirChanges);\n}\n\nfunction removal(hunk, mine, their, swap) {\n var myChanges = collectChange(mine),\n theirChanges = collectContext(their, myChanges);\n\n if (theirChanges.merged) {\n var _hunk$lines6;\n\n (_hunk$lines6 = hunk.lines).push.apply(_hunk$lines6, _toConsumableArray(theirChanges.merged));\n } else {\n conflict(hunk, swap ? theirChanges : myChanges, swap ? myChanges : theirChanges);\n }\n}\n\nfunction conflict(hunk, mine, their) {\n hunk.conflict = true;\n hunk.lines.push({\n conflict: true,\n mine: mine,\n theirs: their\n });\n}\n\nfunction insertLeading(hunk, insert, their) {\n while (insert.offset < their.offset && insert.index < insert.lines.length) {\n var line = insert.lines[insert.index++];\n hunk.lines.push(line);\n insert.offset++;\n }\n}\n\nfunction insertTrailing(hunk, insert) {\n while (insert.index < insert.lines.length) {\n var line = insert.lines[insert.index++];\n hunk.lines.push(line);\n }\n}\n\nfunction collectChange(state) {\n var ret = [],\n operation = state.lines[state.index][0];\n\n while (state.index < state.lines.length) {\n var line = state.lines[state.index]; // Group additions that are immediately after subtractions and treat them as one \"atomic\" modify change.\n\n if (operation === '-' && line[0] === '+') {\n operation = '+';\n }\n\n if (operation === line[0]) {\n ret.push(line);\n state.index++;\n } else {\n break;\n }\n }\n\n return ret;\n}\n\nfunction collectContext(state, matchChanges) {\n var changes = [],\n merged = [],\n matchIndex = 0,\n contextChanges = false,\n conflicted = false;\n\n while (matchIndex < matchChanges.length && state.index < state.lines.length) {\n var change = state.lines[state.index],\n match = matchChanges[matchIndex]; // Once we've hit our add, then we are done\n\n if (match[0] === '+') {\n break;\n }\n\n contextChanges = contextChanges || change[0] !== ' ';\n merged.push(match);\n matchIndex++; // Consume any additions in the other block as a conflict to attempt\n // to pull in the remaining context after this\n\n if (change[0] === '+') {\n conflicted = true;\n\n while (change[0] === '+') {\n changes.push(change);\n change = state.lines[++state.index];\n }\n }\n\n if (match.substr(1) === change.substr(1)) {\n changes.push(change);\n state.index++;\n } else {\n conflicted = true;\n }\n }\n\n if ((matchChanges[matchIndex] || '')[0] === '+' && contextChanges) {\n conflicted = true;\n }\n\n if (conflicted) {\n return changes;\n }\n\n while (matchIndex < matchChanges.length) {\n merged.push(matchChanges[matchIndex++]);\n }\n\n return {\n merged: merged,\n changes: changes\n };\n}\n\nfunction allRemoves(changes) {\n return changes.reduce(function (prev, change) {\n return prev && change[0] === '-';\n }, true);\n}\n\nfunction skipRemoveSuperset(state, removeChanges, delta) {\n for (var i = 0; i < delta; i++) {\n var changeContent = removeChanges[removeChanges.length - delta + i].substr(1);\n\n if (state.lines[state.index + i] !== ' ' + changeContent) {\n return false;\n }\n }\n\n state.index += delta;\n return true;\n}\n\nfunction calcOldNewLineCount(lines) {\n var oldLines = 0;\n var newLines = 0;\n lines.forEach(function (line) {\n if (typeof line !== 'string') {\n var myCount = calcOldNewLineCount(line.mine);\n var theirCount = calcOldNewLineCount(line.theirs);\n\n if (oldLines !== undefined) {\n if (myCount.oldLines === theirCount.oldLines) {\n oldLines += myCount.oldLines;\n } else {\n oldLines = undefined;\n }\n }\n\n if (newLines !== undefined) {\n if (myCount.newLines === theirCount.newLines) {\n newLines += myCount.newLines;\n } else {\n newLines = undefined;\n }\n }\n } else {\n if (newLines !== undefined && (line[0] === '+' || line[0] === ' ')) {\n newLines++;\n }\n\n if (oldLines !== undefined && (line[0] === '-' || line[0] === ' ')) {\n oldLines++;\n }\n }\n });\n return {\n oldLines: oldLines,\n newLines: newLines\n };\n}\n\nfunction reversePatch(structuredPatch) {\n if (Array.isArray(structuredPatch)) {\n return structuredPatch.map(reversePatch).reverse();\n }\n\n return _objectSpread2(_objectSpread2({}, structuredPatch), {}, {\n oldFileName: structuredPatch.newFileName,\n oldHeader: structuredPatch.newHeader,\n newFileName: structuredPatch.oldFileName,\n newHeader: structuredPatch.oldHeader,\n hunks: structuredPatch.hunks.map(function (hunk) {\n return {\n oldLines: hunk.newLines,\n oldStart: hunk.newStart,\n newLines: hunk.oldLines,\n newStart: hunk.oldStart,\n linedelimiters: hunk.linedelimiters,\n lines: hunk.lines.map(function (l) {\n if (l.startsWith('-')) {\n return \"+\".concat(l.slice(1));\n }\n\n if (l.startsWith('+')) {\n return \"-\".concat(l.slice(1));\n }\n\n return l;\n })\n };\n })\n });\n}\n\n// See: http://code.google.com/p/google-diff-match-patch/wiki/API\nfunction convertChangesToDMP(changes) {\n var ret = [],\n change,\n operation;\n\n for (var i = 0; i < changes.length; i++) {\n change = changes[i];\n\n if (change.added) {\n operation = 1;\n } else if (change.removed) {\n operation = -1;\n } else {\n operation = 0;\n }\n\n ret.push([operation, change.value]);\n }\n\n return ret;\n}\n\nfunction convertChangesToXML(changes) {\n var ret = [];\n\n for (var i = 0; i < changes.length; i++) {\n var change = changes[i];\n\n if (change.added) {\n ret.push('<ins>');\n } else if (change.removed) {\n ret.push('<del>');\n }\n\n ret.push(escapeHTML(change.value));\n\n if (change.added) {\n ret.push('</ins>');\n } else if (change.removed) {\n ret.push('</del>');\n }\n }\n\n return ret.join('');\n}\n\nfunction escapeHTML(s) {\n var n = s;\n n = n.replace(/&/g, '&');\n n = n.replace(/</g, '<');\n n = n.replace(/>/g, '>');\n n = n.replace(/\"/g, '"');\n return n;\n}\n\nexport { Diff, applyPatch, applyPatches, canonicalize, convertChangesToDMP, convertChangesToXML, createPatch, createTwoFilesPatch, diffArrays, diffChars, diffCss, diffJson, diffLines, diffSentences, diffTrimmedLines, diffWords, diffWordsWithSpace, formatPatch, merge, parsePatch, reversePatch, structuredPatch };\n"],"names":["Diff","oldString","newString","_options$timeout","options","callback","self","done","value","newLen","oldLen","editLength","maxEditLength","maxExecutionTime","abortAfterTimestamp","bestPath","newPos","minDiagonalToConsider","maxDiagonalToConsider","execEditLength","diagonalPath","basePath","removePath","addPath","canAdd","addPathNewPos","canRemove","buildValues","exec","ret","path","added","removed","oldPosInc","last","oldPos","commonCount","left","right","array","i","chars","diff","lastComponent","useLongestToken","components","nextComponent","componentPos","componentLen","component","tmp","oldValue","finalComponent","extendedWordChars","reWhitespace","wordDiff","tokens","lineDiff","retLines","linesAndNewlines","line","diffLines","oldStr","newStr","sentenceDiff","cssDiff","_typeof","obj","_toConsumableArray","arr","_arrayWithoutHoles","_iterableToArray","_unsupportedIterableToArray","_nonIterableSpread","_arrayLikeToArray","iter","o","minLen","n","len","arr2","objectPrototypeToString","jsonDiff","_this$options","undefinedReplacement","_this$options$stringi","stringifyReplacer","k","v","canonicalize","stack","replacementStack","replacer","key","canonicalizedObj","sortedKeys","_key","arrayDiff","structuredPatch","oldFileName","newFileName","oldHeader","newHeader","contextLines","lines","entry","hunks","oldRangeStart","newRangeStart","curRange","oldLine","newLine","_loop","current","_curRange","prev","_curRange2","_curRange3","contextSize","hunk","oldEOFNewline","newEOFNewline","noNlBeforeAdds","formatPatch","createTwoFilesPatch","createPatch","fileName"],"mappings":"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","x_google_ignoreList":[0]}