File: /var/www/html/laravel/node_modules/.vite/deps_temp_f3d6b3ef/diff.js
import "./chunk-HKJ2B2AA.js";
// node_modules/diff/lib/index.mjs
function Diff() {
}
Diff.prototype = {
diff: function diff(oldString, newString) {
var _options$timeout;
var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
var callback = options.callback;
if (typeof options === "function") {
callback = options;
options = {};
}
var self = this;
function done(value) {
value = self.postProcess(value, options);
if (callback) {
setTimeout(function() {
callback(value);
}, 0);
return true;
} else {
return value;
}
}
oldString = this.castInput(oldString, options);
newString = this.castInput(newString, options);
oldString = this.removeEmpty(this.tokenize(oldString, options));
newString = this.removeEmpty(this.tokenize(newString, options));
var newLen = newString.length, oldLen = oldString.length;
var editLength = 1;
var maxEditLength = newLen + oldLen;
if (options.maxEditLength != null) {
maxEditLength = Math.min(maxEditLength, options.maxEditLength);
}
var maxExecutionTime = (_options$timeout = options.timeout) !== null && _options$timeout !== void 0 ? _options$timeout : Infinity;
var abortAfterTimestamp = Date.now() + maxExecutionTime;
var bestPath = [{
oldPos: -1,
lastComponent: void 0
}];
var newPos = this.extractCommon(bestPath[0], newString, oldString, 0, options);
if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
return done(buildValues(self, bestPath[0].lastComponent, newString, oldString, self.useLongestToken));
}
var minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
function execEditLength() {
for (var diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
var basePath = void 0;
var removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
if (removePath) {
bestPath[diagonalPath - 1] = void 0;
}
var canAdd = false;
if (addPath) {
var addPathNewPos = addPath.oldPos - diagonalPath;
canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
}
var canRemove = removePath && removePath.oldPos + 1 < oldLen;
if (!canAdd && !canRemove) {
bestPath[diagonalPath] = void 0;
continue;
}
if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
basePath = self.addToPath(addPath, true, false, 0, options);
} else {
basePath = self.addToPath(removePath, false, true, 1, options);
}
newPos = self.extractCommon(basePath, newString, oldString, diagonalPath, options);
if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
return done(buildValues(self, basePath.lastComponent, newString, oldString, self.useLongestToken));
} else {
bestPath[diagonalPath] = basePath;
if (basePath.oldPos + 1 >= oldLen) {
maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
}
if (newPos + 1 >= newLen) {
minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
}
}
}
editLength++;
}
if (callback) {
(function exec() {
setTimeout(function() {
if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
return callback();
}
if (!execEditLength()) {
exec();
}
}, 0);
})();
} else {
while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
var ret = execEditLength();
if (ret) {
return ret;
}
}
}
},
addToPath: function addToPath(path, added, removed, oldPosInc, options) {
var last = path.lastComponent;
if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
return {
oldPos: path.oldPos + oldPosInc,
lastComponent: {
count: last.count + 1,
added,
removed,
previousComponent: last.previousComponent
}
};
} else {
return {
oldPos: path.oldPos + oldPosInc,
lastComponent: {
count: 1,
added,
removed,
previousComponent: last
}
};
}
},
extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath, options) {
var newLen = newString.length, oldLen = oldString.length, oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldString[oldPos + 1], newString[newPos + 1], options)) {
newPos++;
oldPos++;
commonCount++;
if (options.oneChangePerToken) {
basePath.lastComponent = {
count: 1,
previousComponent: basePath.lastComponent,
added: false,
removed: false
};
}
}
if (commonCount && !options.oneChangePerToken) {
basePath.lastComponent = {
count: commonCount,
previousComponent: basePath.lastComponent,
added: false,
removed: false
};
}
basePath.oldPos = oldPos;
return newPos;
},
equals: function equals(left, right, options) {
if (options.comparator) {
return options.comparator(left, right);
} else {
return left === right || options.ignoreCase && left.toLowerCase() === right.toLowerCase();
}
},
removeEmpty: function removeEmpty(array) {
var ret = [];
for (var i = 0; i < array.length; i++) {
if (array[i]) {
ret.push(array[i]);
}
}
return ret;
},
castInput: function castInput(value) {
return value;
},
tokenize: function tokenize(value) {
return Array.from(value);
},
join: function join(chars) {
return chars.join("");
},
postProcess: function postProcess(changeObjects) {
return changeObjects;
}
};
function buildValues(diff2, lastComponent, newString, oldString, useLongestToken) {
var components = [];
var nextComponent;
while (lastComponent) {
components.push(lastComponent);
nextComponent = lastComponent.previousComponent;
delete lastComponent.previousComponent;
lastComponent = nextComponent;
}
components.reverse();
var componentPos = 0, componentLen = components.length, newPos = 0, oldPos = 0;
for (; componentPos < componentLen; componentPos++) {
var component = components[componentPos];
if (!component.removed) {
if (!component.added && useLongestToken) {
var value = newString.slice(newPos, newPos + component.count);
value = value.map(function(value2, i) {
var oldValue = oldString[oldPos + i];
return oldValue.length > value2.length ? oldValue : value2;
});
component.value = diff2.join(value);
} else {
component.value = diff2.join(newString.slice(newPos, newPos + component.count));
}
newPos += component.count;
if (!component.added) {
oldPos += component.count;
}
} else {
component.value = diff2.join(oldString.slice(oldPos, oldPos + component.count));
oldPos += component.count;
}
}
return components;
}
var characterDiff = new Diff();
function diffChars(oldStr, newStr, options) {
return characterDiff.diff(oldStr, newStr, options);
}
function longestCommonPrefix(str1, str2) {
var i;
for (i = 0; i < str1.length && i < str2.length; i++) {
if (str1[i] != str2[i]) {
return str1.slice(0, i);
}
}
return str1.slice(0, i);
}
function longestCommonSuffix(str1, str2) {
var i;
if (!str1 || !str2 || str1[str1.length - 1] != str2[str2.length - 1]) {
return "";
}
for (i = 0; i < str1.length && i < str2.length; i++) {
if (str1[str1.length - (i + 1)] != str2[str2.length - (i + 1)]) {
return str1.slice(-i);
}
}
return str1.slice(-i);
}
function replacePrefix(string, oldPrefix, newPrefix) {
if (string.slice(0, oldPrefix.length) != oldPrefix) {
throw Error("string ".concat(JSON.stringify(string), " doesn't start with prefix ").concat(JSON.stringify(oldPrefix), "; this is a bug"));
}
return newPrefix + string.slice(oldPrefix.length);
}
function replaceSuffix(string, oldSuffix, newSuffix) {
if (!oldSuffix) {
return string + newSuffix;
}
if (string.slice(-oldSuffix.length) != oldSuffix) {
throw Error("string ".concat(JSON.stringify(string), " doesn't end with suffix ").concat(JSON.stringify(oldSuffix), "; this is a bug"));
}
return string.slice(0, -oldSuffix.length) + newSuffix;
}
function removePrefix(string, oldPrefix) {
return replacePrefix(string, oldPrefix, "");
}
function removeSuffix(string, oldSuffix) {
return replaceSuffix(string, oldSuffix, "");
}
function maximumOverlap(string1, string2) {
return string2.slice(0, overlapCount(string1, string2));
}
function overlapCount(a, b) {
var startA = 0;
if (a.length > b.length) {
startA = a.length - b.length;
}
var endB = b.length;
if (a.length < b.length) {
endB = a.length;
}
var map = Array(endB);
var k = 0;
map[0] = 0;
for (var j = 1; j < endB; j++) {
if (b[j] == b[k]) {
map[j] = map[k];
} else {
map[j] = k;
}
while (k > 0 && b[j] != b[k]) {
k = map[k];
}
if (b[j] == b[k]) {
k++;
}
}
k = 0;
for (var i = startA; i < a.length; i++) {
while (k > 0 && a[i] != b[k]) {
k = map[k];
}
if (a[i] == b[k]) {
k++;
}
}
return k;
}
function hasOnlyWinLineEndings(string) {
return string.includes("\r\n") && !string.startsWith("\n") && !string.match(/[^\r]\n/);
}
function hasOnlyUnixLineEndings(string) {
return !string.includes("\r\n") && string.includes("\n");
}
var extendedWordChars = "a-zA-Z\\u{C0}-\\u{FF}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}";
var tokenizeIncludingWhitespace = new RegExp("[".concat(extendedWordChars, "]+|\\s+|[^").concat(extendedWordChars, "]"), "ug");
var wordDiff = new Diff();
wordDiff.equals = function(left, right, options) {
if (options.ignoreCase) {
left = left.toLowerCase();
right = right.toLowerCase();
}
return left.trim() === right.trim();
};
wordDiff.tokenize = function(value) {
var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
var parts;
if (options.intlSegmenter) {
if (options.intlSegmenter.resolvedOptions().granularity != "word") {
throw new Error('The segmenter passed must have a granularity of "word"');
}
parts = Array.from(options.intlSegmenter.segment(value), function(segment) {
return segment.segment;
});
} else {
parts = value.match(tokenizeIncludingWhitespace) || [];
}
var tokens = [];
var prevPart = null;
parts.forEach(function(part) {
if (/\s/.test(part)) {
if (prevPart == null) {
tokens.push(part);
} else {
tokens.push(tokens.pop() + part);
}
} else if (/\s/.test(prevPart)) {
if (tokens[tokens.length - 1] == prevPart) {
tokens.push(tokens.pop() + part);
} else {
tokens.push(prevPart + part);
}
} else {
tokens.push(part);
}
prevPart = part;
});
return tokens;
};
wordDiff.join = function(tokens) {
return tokens.map(function(token, i) {
if (i == 0) {
return token;
} else {
return token.replace(/^\s+/, "");
}
}).join("");
};
wordDiff.postProcess = function(changes, options) {
if (!changes || options.oneChangePerToken) {
return changes;
}
var lastKeep = null;
var insertion = null;
var deletion = null;
changes.forEach(function(change) {
if (change.added) {
insertion = change;
} else if (change.removed) {
deletion = change;
} else {
if (insertion || deletion) {
dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change);
}
lastKeep = change;
insertion = null;
deletion = null;
}
});
if (insertion || deletion) {
dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null);
}
return changes;
};
function diffWords(oldStr, newStr, options) {
if ((options === null || options === void 0 ? void 0 : options.ignoreWhitespace) != null && !options.ignoreWhitespace) {
return diffWordsWithSpace(oldStr, newStr, options);
}
return wordDiff.diff(oldStr, newStr, options);
}
function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep) {
if (deletion && insertion) {
var oldWsPrefix = deletion.value.match(/^\s*/)[0];
var oldWsSuffix = deletion.value.match(/\s*$/)[0];
var newWsPrefix = insertion.value.match(/^\s*/)[0];
var newWsSuffix = insertion.value.match(/\s*$/)[0];
if (startKeep) {
var commonWsPrefix = longestCommonPrefix(oldWsPrefix, newWsPrefix);
startKeep.value = replaceSuffix(startKeep.value, newWsPrefix, commonWsPrefix);
deletion.value = removePrefix(deletion.value, commonWsPrefix);
insertion.value = removePrefix(insertion.value, commonWsPrefix);
}
if (endKeep) {
var commonWsSuffix = longestCommonSuffix(oldWsSuffix, newWsSuffix);
endKeep.value = replacePrefix(endKeep.value, newWsSuffix, commonWsSuffix);
deletion.value = removeSuffix(deletion.value, commonWsSuffix);
insertion.value = removeSuffix(insertion.value, commonWsSuffix);
}
} else if (insertion) {
if (startKeep) {
insertion.value = insertion.value.replace(/^\s*/, "");
}
if (endKeep) {
endKeep.value = endKeep.value.replace(/^\s*/, "");
}
} else if (startKeep && endKeep) {
var newWsFull = endKeep.value.match(/^\s*/)[0], delWsStart = deletion.value.match(/^\s*/)[0], delWsEnd = deletion.value.match(/\s*$/)[0];
var newWsStart = longestCommonPrefix(newWsFull, delWsStart);
deletion.value = removePrefix(deletion.value, newWsStart);
var newWsEnd = longestCommonSuffix(removePrefix(newWsFull, newWsStart), delWsEnd);
deletion.value = removeSuffix(deletion.value, newWsEnd);
endKeep.value = replacePrefix(endKeep.value, newWsFull, newWsEnd);
startKeep.value = replaceSuffix(startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));
} else if (endKeep) {
var endKeepWsPrefix = endKeep.value.match(/^\s*/)[0];
var deletionWsSuffix = deletion.value.match(/\s*$/)[0];
var overlap = maximumOverlap(deletionWsSuffix, endKeepWsPrefix);
deletion.value = removeSuffix(deletion.value, overlap);
} else if (startKeep) {
var startKeepWsSuffix = startKeep.value.match(/\s*$/)[0];
var deletionWsPrefix = deletion.value.match(/^\s*/)[0];
var _overlap = maximumOverlap(startKeepWsSuffix, deletionWsPrefix);
deletion.value = removePrefix(deletion.value, _overlap);
}
}
var wordWithSpaceDiff = new Diff();
wordWithSpaceDiff.tokenize = function(value) {
var regex = new RegExp("(\\r?\\n)|[".concat(extendedWordChars, "]+|[^\\S\\n\\r]+|[^").concat(extendedWordChars, "]"), "ug");
return value.match(regex) || [];
};
function diffWordsWithSpace(oldStr, newStr, options) {
return wordWithSpaceDiff.diff(oldStr, newStr, options);
}
function generateOptions(options, defaults) {
if (typeof options === "function") {
defaults.callback = options;
} else if (options) {
for (var name in options) {
if (options.hasOwnProperty(name)) {
defaults[name] = options[name];
}
}
}
return defaults;
}
var lineDiff = new Diff();
lineDiff.tokenize = function(value, options) {
if (options.stripTrailingCr) {
value = value.replace(/\r\n/g, "\n");
}
var retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
if (!linesAndNewlines[linesAndNewlines.length - 1]) {
linesAndNewlines.pop();
}
for (var i = 0; i < linesAndNewlines.length; i++) {
var line = linesAndNewlines[i];
if (i % 2 && !options.newlineIsToken) {
retLines[retLines.length - 1] += line;
} else {
retLines.push(line);
}
}
return retLines;
};
lineDiff.equals = function(left, right, options) {
if (options.ignoreWhitespace) {
if (!options.newlineIsToken || !left.includes("\n")) {
left = left.trim();
}
if (!options.newlineIsToken || !right.includes("\n")) {
right = right.trim();
}
} else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
if (left.endsWith("\n")) {
left = left.slice(0, -1);
}
if (right.endsWith("\n")) {
right = right.slice(0, -1);
}
}
return Diff.prototype.equals.call(this, left, right, options);
};
function diffLines(oldStr, newStr, callback) {
return lineDiff.diff(oldStr, newStr, callback);
}
function diffTrimmedLines(oldStr, newStr, callback) {
var options = generateOptions(callback, {
ignoreWhitespace: true
});
return lineDiff.diff(oldStr, newStr, options);
}
var sentenceDiff = new Diff();
sentenceDiff.tokenize = function(value) {
return value.split(/(\S.+?[.!?])(?=\s+|$)/);
};
function diffSentences(oldStr, newStr, callback) {
return sentenceDiff.diff(oldStr, newStr, callback);
}
var cssDiff = new Diff();
cssDiff.tokenize = function(value) {
return value.split(/([{}:;,]|\s+)/);
};
function diffCss(oldStr, newStr, callback) {
return cssDiff.diff(oldStr, newStr, callback);
}
function ownKeys(e, r) {
var t = Object.keys(e);
if (Object.getOwnPropertySymbols) {
var o = Object.getOwnPropertySymbols(e);
r && (o = o.filter(function(r2) {
return Object.getOwnPropertyDescriptor(e, r2).enumerable;
})), t.push.apply(t, o);
}
return t;
}
function _objectSpread2(e) {
for (var r = 1; r < arguments.length; r++) {
var t = null != arguments[r] ? arguments[r] : {};
r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
_defineProperty(e, r2, t[r2]);
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
});
}
return e;
}
function _toPrimitive(t, r) {
if ("object" != typeof t || !t) return t;
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r || "default");
if ("object" != typeof i) return i;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === r ? String : Number)(t);
}
function _toPropertyKey(t) {
var i = _toPrimitive(t, "string");
return "symbol" == typeof i ? i : i + "";
}
function _typeof(o) {
"@babel/helpers - typeof";
return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
return typeof o2;
} : function(o2) {
return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
}, _typeof(o);
}
function _defineProperty(obj, key, value) {
key = _toPropertyKey(key);
if (key in obj) {
Object.defineProperty(obj, key, {
value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
function _toConsumableArray(arr) {
return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
}
function _arrayWithoutHoles(arr) {
if (Array.isArray(arr)) return _arrayLikeToArray(arr);
}
function _iterableToArray(iter) {
if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
}
function _unsupportedIterableToArray(o, minLen) {
if (!o) return;
if (typeof o === "string") return _arrayLikeToArray(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
if (n === "Object" && o.constructor) n = o.constructor.name;
if (n === "Map" || n === "Set") return Array.from(o);
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
}
function _arrayLikeToArray(arr, len) {
if (len == null || len > arr.length) len = arr.length;
for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
return arr2;
}
function _nonIterableSpread() {
throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
var jsonDiff = new Diff();
jsonDiff.useLongestToken = true;
jsonDiff.tokenize = lineDiff.tokenize;
jsonDiff.castInput = function(value, options) {
var undefinedReplacement = options.undefinedReplacement, _options$stringifyRep = options.stringifyReplacer, stringifyReplacer = _options$stringifyRep === void 0 ? function(k, v) {
return typeof v === "undefined" ? undefinedReplacement : v;
} : _options$stringifyRep;
return typeof value === "string" ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, " ");
};
jsonDiff.equals = function(left, right, options) {
return Diff.prototype.equals.call(jsonDiff, left.replace(/,([\r\n])/g, "$1"), right.replace(/,([\r\n])/g, "$1"), options);
};
function diffJson(oldObj, newObj, options) {
return jsonDiff.diff(oldObj, newObj, options);
}
function canonicalize(obj, stack, replacementStack, replacer, key) {
stack = stack || [];
replacementStack = replacementStack || [];
if (replacer) {
obj = replacer(key, obj);
}
var i;
for (i = 0; i < stack.length; i += 1) {
if (stack[i] === obj) {
return replacementStack[i];
}
}
var canonicalizedObj;
if ("[object Array]" === Object.prototype.toString.call(obj)) {
stack.push(obj);
canonicalizedObj = new Array(obj.length);
replacementStack.push(canonicalizedObj);
for (i = 0; i < obj.length; i += 1) {
canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, key);
}
stack.pop();
replacementStack.pop();
return canonicalizedObj;
}
if (obj && obj.toJSON) {
obj = obj.toJSON();
}
if (_typeof(obj) === "object" && obj !== null) {
stack.push(obj);
canonicalizedObj = {};
replacementStack.push(canonicalizedObj);
var sortedKeys = [], _key;
for (_key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, _key)) {
sortedKeys.push(_key);
}
}
sortedKeys.sort();
for (i = 0; i < sortedKeys.length; i += 1) {
_key = sortedKeys[i];
canonicalizedObj[_key] = canonicalize(obj[_key], stack, replacementStack, replacer, _key);
}
stack.pop();
replacementStack.pop();
} else {
canonicalizedObj = obj;
}
return canonicalizedObj;
}
var arrayDiff = new Diff();
arrayDiff.tokenize = function(value) {
return value.slice();
};
arrayDiff.join = arrayDiff.removeEmpty = function(value) {
return value;
};
function diffArrays(oldArr, newArr, callback) {
return arrayDiff.diff(oldArr, newArr, callback);
}
function unixToWin(patch) {
if (Array.isArray(patch)) {
return patch.map(unixToWin);
}
return _objectSpread2(_objectSpread2({}, patch), {}, {
hunks: patch.hunks.map(function(hunk) {
return _objectSpread2(_objectSpread2({}, hunk), {}, {
lines: hunk.lines.map(function(line, i) {
var _hunk$lines;
return line.startsWith("\\") || line.endsWith("\r") || (_hunk$lines = hunk.lines[i + 1]) !== null && _hunk$lines !== void 0 && _hunk$lines.startsWith("\\") ? line : line + "\r";
})
});
})
});
}
function winToUnix(patch) {
if (Array.isArray(patch)) {
return patch.map(winToUnix);
}
return _objectSpread2(_objectSpread2({}, patch), {}, {
hunks: patch.hunks.map(function(hunk) {
return _objectSpread2(_objectSpread2({}, hunk), {}, {
lines: hunk.lines.map(function(line) {
return line.endsWith("\r") ? line.substring(0, line.length - 1) : line;
})
});
})
});
}
function isUnix(patch) {
if (!Array.isArray(patch)) {
patch = [patch];
}
return !patch.some(function(index) {
return index.hunks.some(function(hunk) {
return hunk.lines.some(function(line) {
return !line.startsWith("\\") && line.endsWith("\r");
});
});
});
}
function isWin(patch) {
if (!Array.isArray(patch)) {
patch = [patch];
}
return patch.some(function(index) {
return index.hunks.some(function(hunk) {
return hunk.lines.some(function(line) {
return line.endsWith("\r");
});
});
}) && patch.every(function(index) {
return index.hunks.every(function(hunk) {
return hunk.lines.every(function(line, i) {
var _hunk$lines2;
return line.startsWith("\\") || line.endsWith("\r") || ((_hunk$lines2 = hunk.lines[i + 1]) === null || _hunk$lines2 === void 0 ? void 0 : _hunk$lines2.startsWith("\\"));
});
});
});
}
function parsePatch(uniDiff) {
var diffstr = uniDiff.split(/\n/), list = [], i = 0;
function parseIndex() {
var index = {};
list.push(index);
while (i < diffstr.length) {
var line = diffstr[i];
if (/^(\-\-\-|\+\+\+|@@)\s/.test(line)) {
break;
}
var header = /^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(line);
if (header) {
index.index = header[1];
}
i++;
}
parseFileHeader(index);
parseFileHeader(index);
index.hunks = [];
while (i < diffstr.length) {
var _line = diffstr[i];
if (/^(Index:\s|diff\s|\-\-\-\s|\+\+\+\s|===================================================================)/.test(_line)) {
break;
} else if (/^@@/.test(_line)) {
index.hunks.push(parseHunk());
} else if (_line) {
throw new Error("Unknown line " + (i + 1) + " " + JSON.stringify(_line));
} else {
i++;
}
}
}
function parseFileHeader(index) {
var fileHeader = /^(---|\+\+\+)\s+(.*)\r?$/.exec(diffstr[i]);
if (fileHeader) {
var keyPrefix = fileHeader[1] === "---" ? "old" : "new";
var data = fileHeader[2].split(" ", 2);
var fileName = data[0].replace(/\\\\/g, "\\");
if (/^".*"$/.test(fileName)) {
fileName = fileName.substr(1, fileName.length - 2);
}
index[keyPrefix + "FileName"] = fileName;
index[keyPrefix + "Header"] = (data[1] || "").trim();
i++;
}
}
function parseHunk() {
var chunkHeaderIndex = i, chunkHeaderLine = diffstr[i++], chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
var hunk = {
oldStart: +chunkHeader[1],
oldLines: typeof chunkHeader[2] === "undefined" ? 1 : +chunkHeader[2],
newStart: +chunkHeader[3],
newLines: typeof chunkHeader[4] === "undefined" ? 1 : +chunkHeader[4],
lines: []
};
if (hunk.oldLines === 0) {
hunk.oldStart += 1;
}
if (hunk.newLines === 0) {
hunk.newStart += 1;
}
var addCount = 0, removeCount = 0;
for (; i < diffstr.length && (removeCount < hunk.oldLines || addCount < hunk.newLines || (_diffstr$i = diffstr[i]) !== null && _diffstr$i !== void 0 && _diffstr$i.startsWith("\\")); i++) {
var _diffstr$i;
var operation = diffstr[i].length == 0 && i != diffstr.length - 1 ? " " : diffstr[i][0];
if (operation === "+" || operation === "-" || operation === " " || operation === "\\") {
hunk.lines.push(diffstr[i]);
if (operation === "+") {
addCount++;
} else if (operation === "-") {
removeCount++;
} else if (operation === " ") {
addCount++;
removeCount++;
}
} else {
throw new Error("Hunk at line ".concat(chunkHeaderIndex + 1, " contained invalid line ").concat(diffstr[i]));
}
}
if (!addCount && hunk.newLines === 1) {
hunk.newLines = 0;
}
if (!removeCount && hunk.oldLines === 1) {
hunk.oldLines = 0;
}
if (addCount !== hunk.newLines) {
throw new Error("Added line count did not match for hunk at line " + (chunkHeaderIndex + 1));
}
if (removeCount !== hunk.oldLines) {
throw new Error("Removed line count did not match for hunk at line " + (chunkHeaderIndex + 1));
}
return hunk;
}
while (i < diffstr.length) {
parseIndex();
}
return list;
}
function distanceIterator(start, minLine, maxLine) {
var wantForward = true, backwardExhausted = false, forwardExhausted = false, localOffset = 1;
return function iterator() {
if (wantForward && !forwardExhausted) {
if (backwardExhausted) {
localOffset++;
} else {
wantForward = false;
}
if (start + localOffset <= maxLine) {
return start + localOffset;
}
forwardExhausted = true;
}
if (!backwardExhausted) {
if (!forwardExhausted) {
wantForward = true;
}
if (minLine <= start - localOffset) {
return start - localOffset++;
}
backwardExhausted = true;
return iterator();
}
};
}
function applyPatch(source, uniDiff) {
var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
if (typeof uniDiff === "string") {
uniDiff = parsePatch(uniDiff);
}
if (Array.isArray(uniDiff)) {
if (uniDiff.length > 1) {
throw new Error("applyPatch only works with a single input.");
}
uniDiff = uniDiff[0];
}
if (options.autoConvertLineEndings || options.autoConvertLineEndings == null) {
if (hasOnlyWinLineEndings(source) && isUnix(uniDiff)) {
uniDiff = unixToWin(uniDiff);
} else if (hasOnlyUnixLineEndings(source) && isWin(uniDiff)) {
uniDiff = winToUnix(uniDiff);
}
}
var lines = source.split("\n"), hunks = uniDiff.hunks, compareLine = options.compareLine || function(lineNumber, line2, operation, patchContent) {
return line2 === patchContent;
}, fuzzFactor = options.fuzzFactor || 0, minLine = 0;
if (fuzzFactor < 0 || !Number.isInteger(fuzzFactor)) {
throw new Error("fuzzFactor must be a non-negative integer");
}
if (!hunks.length) {
return source;
}
var prevLine = "", removeEOFNL = false, addEOFNL = false;
for (var i = 0; i < hunks[hunks.length - 1].lines.length; i++) {
var line = hunks[hunks.length - 1].lines[i];
if (line[0] == "\\") {
if (prevLine[0] == "+") {
removeEOFNL = true;
} else if (prevLine[0] == "-") {
addEOFNL = true;
}
}
prevLine = line;
}
if (removeEOFNL) {
if (addEOFNL) {
if (!fuzzFactor && lines[lines.length - 1] == "") {
return false;
}
} else if (lines[lines.length - 1] == "") {
lines.pop();
} else if (!fuzzFactor) {
return false;
}
} else if (addEOFNL) {
if (lines[lines.length - 1] != "") {
lines.push("");
} else if (!fuzzFactor) {
return false;
}
}
function applyHunk(hunkLines, toPos2, maxErrors2) {
var hunkLinesI = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0;
var lastContextLineMatched = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : true;
var patchedLines = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : [];
var patchedLinesLength = arguments.length > 6 && arguments[6] !== void 0 ? arguments[6] : 0;
var nConsecutiveOldContextLines = 0;
var nextContextLineMustMatch = false;
for (; hunkLinesI < hunkLines.length; hunkLinesI++) {
var hunkLine = hunkLines[hunkLinesI], operation = hunkLine.length > 0 ? hunkLine[0] : " ", content = hunkLine.length > 0 ? hunkLine.substr(1) : hunkLine;
if (operation === "-") {
if (compareLine(toPos2 + 1, lines[toPos2], operation, content)) {
toPos2++;
nConsecutiveOldContextLines = 0;
} else {
if (!maxErrors2 || lines[toPos2] == null) {
return null;
}
patchedLines[patchedLinesLength] = lines[toPos2];
return applyHunk(hunkLines, toPos2 + 1, maxErrors2 - 1, hunkLinesI, false, patchedLines, patchedLinesLength + 1);
}
}
if (operation === "+") {
if (!lastContextLineMatched) {
return null;
}
patchedLines[patchedLinesLength] = content;
patchedLinesLength++;
nConsecutiveOldContextLines = 0;
nextContextLineMustMatch = true;
}
if (operation === " ") {
nConsecutiveOldContextLines++;
patchedLines[patchedLinesLength] = lines[toPos2];
if (compareLine(toPos2 + 1, lines[toPos2], operation, content)) {
patchedLinesLength++;
lastContextLineMatched = true;
nextContextLineMustMatch = false;
toPos2++;
} else {
if (nextContextLineMustMatch || !maxErrors2) {
return null;
}
return lines[toPos2] && (applyHunk(hunkLines, toPos2 + 1, maxErrors2 - 1, hunkLinesI + 1, false, patchedLines, patchedLinesLength + 1) || applyHunk(hunkLines, toPos2 + 1, maxErrors2 - 1, hunkLinesI, false, patchedLines, patchedLinesLength + 1)) || applyHunk(hunkLines, toPos2, maxErrors2 - 1, hunkLinesI + 1, false, patchedLines, patchedLinesLength);
}
}
}
patchedLinesLength -= nConsecutiveOldContextLines;
toPos2 -= nConsecutiveOldContextLines;
patchedLines.length = patchedLinesLength;
return {
patchedLines,
oldLineLastI: toPos2 - 1
};
}
var resultLines = [];
var prevHunkOffset = 0;
for (var _i = 0; _i < hunks.length; _i++) {
var hunk = hunks[_i];
var hunkResult = void 0;
var maxLine = lines.length - hunk.oldLines + fuzzFactor;
var toPos = void 0;
for (var maxErrors = 0; maxErrors <= fuzzFactor; maxErrors++) {
toPos = hunk.oldStart + prevHunkOffset - 1;
var iterator = distanceIterator(toPos, minLine, maxLine);
for (; toPos !== void 0; toPos = iterator()) {
hunkResult = applyHunk(hunk.lines, toPos, maxErrors);
if (hunkResult) {
break;
}
}
if (hunkResult) {
break;
}
}
if (!hunkResult) {
return false;
}
for (var _i2 = minLine; _i2 < toPos; _i2++) {
resultLines.push(lines[_i2]);
}
for (var _i3 = 0; _i3 < hunkResult.patchedLines.length; _i3++) {
var _line = hunkResult.patchedLines[_i3];
resultLines.push(_line);
}
minLine = hunkResult.oldLineLastI + 1;
prevHunkOffset = toPos + 1 - hunk.oldStart;
}
for (var _i4 = minLine; _i4 < lines.length; _i4++) {
resultLines.push(lines[_i4]);
}
return resultLines.join("\n");
}
function applyPatches(uniDiff, options) {
if (typeof uniDiff === "string") {
uniDiff = parsePatch(uniDiff);
}
var currentIndex = 0;
function processIndex() {
var index = uniDiff[currentIndex++];
if (!index) {
return options.complete();
}
options.loadFile(index, function(err, data) {
if (err) {
return options.complete(err);
}
var updatedContent = applyPatch(data, index, options);
options.patched(index, updatedContent, function(err2) {
if (err2) {
return options.complete(err2);
}
processIndex();
});
});
}
processIndex();
}
function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
if (!options) {
options = {};
}
if (typeof options === "function") {
options = {
callback: options
};
}
if (typeof options.context === "undefined") {
options.context = 4;
}
if (options.newlineIsToken) {
throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
}
if (!options.callback) {
return diffLinesResultToPatch(diffLines(oldStr, newStr, options));
} else {
var _options = options, _callback = _options.callback;
diffLines(oldStr, newStr, _objectSpread2(_objectSpread2({}, options), {}, {
callback: function callback(diff2) {
var patch = diffLinesResultToPatch(diff2);
_callback(patch);
}
}));
}
function diffLinesResultToPatch(diff2) {
if (!diff2) {
return;
}
diff2.push({
value: "",
lines: []
});
function contextLines(lines) {
return lines.map(function(entry) {
return " " + entry;
});
}
var hunks = [];
var oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
var _loop = function _loop2() {
var current = diff2[i], lines = current.lines || splitLines(current.value);
current.lines = lines;
if (current.added || current.removed) {
var _curRange;
if (!oldRangeStart) {
var prev = diff2[i - 1];
oldRangeStart = oldLine;
newRangeStart = newLine;
if (prev) {
curRange = options.context > 0 ? contextLines(prev.lines.slice(-options.context)) : [];
oldRangeStart -= curRange.length;
newRangeStart -= curRange.length;
}
}
(_curRange = curRange).push.apply(_curRange, _toConsumableArray(lines.map(function(entry) {
return (current.added ? "+" : "-") + entry;
})));
if (current.added) {
newLine += lines.length;
} else {
oldLine += lines.length;
}
} else {
if (oldRangeStart) {
if (lines.length <= options.context * 2 && i < diff2.length - 2) {
var _curRange2;
(_curRange2 = curRange).push.apply(_curRange2, _toConsumableArray(contextLines(lines)));
} else {
var _curRange3;
var contextSize = Math.min(lines.length, options.context);
(_curRange3 = curRange).push.apply(_curRange3, _toConsumableArray(contextLines(lines.slice(0, contextSize))));
var _hunk = {
oldStart: oldRangeStart,
oldLines: oldLine - oldRangeStart + contextSize,
newStart: newRangeStart,
newLines: newLine - newRangeStart + contextSize,
lines: curRange
};
hunks.push(_hunk);
oldRangeStart = 0;
newRangeStart = 0;
curRange = [];
}
}
oldLine += lines.length;
newLine += lines.length;
}
};
for (var i = 0; i < diff2.length; i++) {
_loop();
}
for (var _i = 0, _hunks = hunks; _i < _hunks.length; _i++) {
var hunk = _hunks[_i];
for (var _i2 = 0; _i2 < hunk.lines.length; _i2++) {
if (hunk.lines[_i2].endsWith("\n")) {
hunk.lines[_i2] = hunk.lines[_i2].slice(0, -1);
} else {
hunk.lines.splice(_i2 + 1, 0, "\\ No newline at end of file");
_i2++;
}
}
}
return {
oldFileName,
newFileName,
oldHeader,
newHeader,
hunks
};
}
}
function formatPatch(diff2) {
if (Array.isArray(diff2)) {
return diff2.map(formatPatch).join("\n");
}
var ret = [];
if (diff2.oldFileName == diff2.newFileName) {
ret.push("Index: " + diff2.oldFileName);
}
ret.push("===================================================================");
ret.push("--- " + diff2.oldFileName + (typeof diff2.oldHeader === "undefined" ? "" : " " + diff2.oldHeader));
ret.push("+++ " + diff2.newFileName + (typeof diff2.newHeader === "undefined" ? "" : " " + diff2.newHeader));
for (var i = 0; i < diff2.hunks.length; i++) {
var hunk = diff2.hunks[i];
if (hunk.oldLines === 0) {
hunk.oldStart -= 1;
}
if (hunk.newLines === 0) {
hunk.newStart -= 1;
}
ret.push("@@ -" + hunk.oldStart + "," + hunk.oldLines + " +" + hunk.newStart + "," + hunk.newLines + " @@");
ret.push.apply(ret, hunk.lines);
}
return ret.join("\n") + "\n";
}
function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
var _options2;
if (typeof options === "function") {
options = {
callback: options
};
}
if (!((_options2 = options) !== null && _options2 !== void 0 && _options2.callback)) {
var patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
if (!patchObj) {
return;
}
return formatPatch(patchObj);
} else {
var _options3 = options, _callback2 = _options3.callback;
structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, _objectSpread2(_objectSpread2({}, options), {}, {
callback: function callback(patchObj2) {
if (!patchObj2) {
_callback2();
} else {
_callback2(formatPatch(patchObj2));
}
}
}));
}
}
function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {
return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options);
}
function splitLines(text) {
var hasTrailingNl = text.endsWith("\n");
var result = text.split("\n").map(function(line) {
return line + "\n";
});
if (hasTrailingNl) {
result.pop();
} else {
result.push(result.pop().slice(0, -1));
}
return result;
}
function arrayEqual(a, b) {
if (a.length !== b.length) {
return false;
}
return arrayStartsWith(a, b);
}
function arrayStartsWith(array, start) {
if (start.length > array.length) {
return false;
}
for (var i = 0; i < start.length; i++) {
if (start[i] !== array[i]) {
return false;
}
}
return true;
}
function calcLineCount(hunk) {
var _calcOldNewLineCount = calcOldNewLineCount(hunk.lines), oldLines = _calcOldNewLineCount.oldLines, newLines = _calcOldNewLineCount.newLines;
if (oldLines !== void 0) {
hunk.oldLines = oldLines;
} else {
delete hunk.oldLines;
}
if (newLines !== void 0) {
hunk.newLines = newLines;
} else {
delete hunk.newLines;
}
}
function merge(mine, theirs, base) {
mine = loadPatch(mine, base);
theirs = loadPatch(theirs, base);
var ret = {};
if (mine.index || theirs.index) {
ret.index = mine.index || theirs.index;
}
if (mine.newFileName || theirs.newFileName) {
if (!fileNameChanged(mine)) {
ret.oldFileName = theirs.oldFileName || mine.oldFileName;
ret.newFileName = theirs.newFileName || mine.newFileName;
ret.oldHeader = theirs.oldHeader || mine.oldHeader;
ret.newHeader = theirs.newHeader || mine.newHeader;
} else if (!fileNameChanged(theirs)) {
ret.oldFileName = mine.oldFileName;
ret.newFileName = mine.newFileName;
ret.oldHeader = mine.oldHeader;
ret.newHeader = mine.newHeader;
} else {
ret.oldFileName = selectField(ret, mine.oldFileName, theirs.oldFileName);
ret.newFileName = selectField(ret, mine.newFileName, theirs.newFileName);
ret.oldHeader = selectField(ret, mine.oldHeader, theirs.oldHeader);
ret.newHeader = selectField(ret, mine.newHeader, theirs.newHeader);
}
}
ret.hunks = [];
var mineIndex = 0, theirsIndex = 0, mineOffset = 0, theirsOffset = 0;
while (mineIndex < mine.hunks.length || theirsIndex < theirs.hunks.length) {
var mineCurrent = mine.hunks[mineIndex] || {
oldStart: Infinity
}, theirsCurrent = theirs.hunks[theirsIndex] || {
oldStart: Infinity
};
if (hunkBefore(mineCurrent, theirsCurrent)) {
ret.hunks.push(cloneHunk(mineCurrent, mineOffset));
mineIndex++;
theirsOffset += mineCurrent.newLines - mineCurrent.oldLines;
} else if (hunkBefore(theirsCurrent, mineCurrent)) {
ret.hunks.push(cloneHunk(theirsCurrent, theirsOffset));
theirsIndex++;
mineOffset += theirsCurrent.newLines - theirsCurrent.oldLines;
} else {
var mergedHunk = {
oldStart: Math.min(mineCurrent.oldStart, theirsCurrent.oldStart),
oldLines: 0,
newStart: Math.min(mineCurrent.newStart + mineOffset, theirsCurrent.oldStart + theirsOffset),
newLines: 0,
lines: []
};
mergeLines(mergedHunk, mineCurrent.oldStart, mineCurrent.lines, theirsCurrent.oldStart, theirsCurrent.lines);
theirsIndex++;
mineIndex++;
ret.hunks.push(mergedHunk);
}
}
return ret;
}
function loadPatch(param, base) {
if (typeof param === "string") {
if (/^@@/m.test(param) || /^Index:/m.test(param)) {
return parsePatch(param)[0];
}
if (!base) {
throw new Error("Must provide a base reference or pass in a patch");
}
return structuredPatch(void 0, void 0, base, param);
}
return param;
}
function fileNameChanged(patch) {
return patch.newFileName && patch.newFileName !== patch.oldFileName;
}
function selectField(index, mine, theirs) {
if (mine === theirs) {
return mine;
} else {
index.conflict = true;
return {
mine,
theirs
};
}
}
function hunkBefore(test, check) {
return test.oldStart < check.oldStart && test.oldStart + test.oldLines < check.oldStart;
}
function cloneHunk(hunk, offset) {
return {
oldStart: hunk.oldStart,
oldLines: hunk.oldLines,
newStart: hunk.newStart + offset,
newLines: hunk.newLines,
lines: hunk.lines
};
}
function mergeLines(hunk, mineOffset, mineLines, theirOffset, theirLines) {
var mine = {
offset: mineOffset,
lines: mineLines,
index: 0
}, their = {
offset: theirOffset,
lines: theirLines,
index: 0
};
insertLeading(hunk, mine, their);
insertLeading(hunk, their, mine);
while (mine.index < mine.lines.length && their.index < their.lines.length) {
var mineCurrent = mine.lines[mine.index], theirCurrent = their.lines[their.index];
if ((mineCurrent[0] === "-" || mineCurrent[0] === "+") && (theirCurrent[0] === "-" || theirCurrent[0] === "+")) {
mutualChange(hunk, mine, their);
} else if (mineCurrent[0] === "+" && theirCurrent[0] === " ") {
var _hunk$lines;
(_hunk$lines = hunk.lines).push.apply(_hunk$lines, _toConsumableArray(collectChange(mine)));
} else if (theirCurrent[0] === "+" && mineCurrent[0] === " ") {
var _hunk$lines2;
(_hunk$lines2 = hunk.lines).push.apply(_hunk$lines2, _toConsumableArray(collectChange(their)));
} else if (mineCurrent[0] === "-" && theirCurrent[0] === " ") {
removal(hunk, mine, their);
} else if (theirCurrent[0] === "-" && mineCurrent[0] === " ") {
removal(hunk, their, mine, true);
} else if (mineCurrent === theirCurrent) {
hunk.lines.push(mineCurrent);
mine.index++;
their.index++;
} else {
conflict(hunk, collectChange(mine), collectChange(their));
}
}
insertTrailing(hunk, mine);
insertTrailing(hunk, their);
calcLineCount(hunk);
}
function mutualChange(hunk, mine, their) {
var myChanges = collectChange(mine), theirChanges = collectChange(their);
if (allRemoves(myChanges) && allRemoves(theirChanges)) {
if (arrayStartsWith(myChanges, theirChanges) && skipRemoveSuperset(their, myChanges, myChanges.length - theirChanges.length)) {
var _hunk$lines3;
(_hunk$lines3 = hunk.lines).push.apply(_hunk$lines3, _toConsumableArray(myChanges));
return;
} else if (arrayStartsWith(theirChanges, myChanges) && skipRemoveSuperset(mine, theirChanges, theirChanges.length - myChanges.length)) {
var _hunk$lines4;
(_hunk$lines4 = hunk.lines).push.apply(_hunk$lines4, _toConsumableArray(theirChanges));
return;
}
} else if (arrayEqual(myChanges, theirChanges)) {
var _hunk$lines5;
(_hunk$lines5 = hunk.lines).push.apply(_hunk$lines5, _toConsumableArray(myChanges));
return;
}
conflict(hunk, myChanges, theirChanges);
}
function removal(hunk, mine, their, swap) {
var myChanges = collectChange(mine), theirChanges = collectContext(their, myChanges);
if (theirChanges.merged) {
var _hunk$lines6;
(_hunk$lines6 = hunk.lines).push.apply(_hunk$lines6, _toConsumableArray(theirChanges.merged));
} else {
conflict(hunk, swap ? theirChanges : myChanges, swap ? myChanges : theirChanges);
}
}
function conflict(hunk, mine, their) {
hunk.conflict = true;
hunk.lines.push({
conflict: true,
mine,
theirs: their
});
}
function insertLeading(hunk, insert, their) {
while (insert.offset < their.offset && insert.index < insert.lines.length) {
var line = insert.lines[insert.index++];
hunk.lines.push(line);
insert.offset++;
}
}
function insertTrailing(hunk, insert) {
while (insert.index < insert.lines.length) {
var line = insert.lines[insert.index++];
hunk.lines.push(line);
}
}
function collectChange(state) {
var ret = [], operation = state.lines[state.index][0];
while (state.index < state.lines.length) {
var line = state.lines[state.index];
if (operation === "-" && line[0] === "+") {
operation = "+";
}
if (operation === line[0]) {
ret.push(line);
state.index++;
} else {
break;
}
}
return ret;
}
function collectContext(state, matchChanges) {
var changes = [], merged = [], matchIndex = 0, contextChanges = false, conflicted = false;
while (matchIndex < matchChanges.length && state.index < state.lines.length) {
var change = state.lines[state.index], match = matchChanges[matchIndex];
if (match[0] === "+") {
break;
}
contextChanges = contextChanges || change[0] !== " ";
merged.push(match);
matchIndex++;
if (change[0] === "+") {
conflicted = true;
while (change[0] === "+") {
changes.push(change);
change = state.lines[++state.index];
}
}
if (match.substr(1) === change.substr(1)) {
changes.push(change);
state.index++;
} else {
conflicted = true;
}
}
if ((matchChanges[matchIndex] || "")[0] === "+" && contextChanges) {
conflicted = true;
}
if (conflicted) {
return changes;
}
while (matchIndex < matchChanges.length) {
merged.push(matchChanges[matchIndex++]);
}
return {
merged,
changes
};
}
function allRemoves(changes) {
return changes.reduce(function(prev, change) {
return prev && change[0] === "-";
}, true);
}
function skipRemoveSuperset(state, removeChanges, delta) {
for (var i = 0; i < delta; i++) {
var changeContent = removeChanges[removeChanges.length - delta + i].substr(1);
if (state.lines[state.index + i] !== " " + changeContent) {
return false;
}
}
state.index += delta;
return true;
}
function calcOldNewLineCount(lines) {
var oldLines = 0;
var newLines = 0;
lines.forEach(function(line) {
if (typeof line !== "string") {
var myCount = calcOldNewLineCount(line.mine);
var theirCount = calcOldNewLineCount(line.theirs);
if (oldLines !== void 0) {
if (myCount.oldLines === theirCount.oldLines) {
oldLines += myCount.oldLines;
} else {
oldLines = void 0;
}
}
if (newLines !== void 0) {
if (myCount.newLines === theirCount.newLines) {
newLines += myCount.newLines;
} else {
newLines = void 0;
}
}
} else {
if (newLines !== void 0 && (line[0] === "+" || line[0] === " ")) {
newLines++;
}
if (oldLines !== void 0 && (line[0] === "-" || line[0] === " ")) {
oldLines++;
}
}
});
return {
oldLines,
newLines
};
}
function reversePatch(structuredPatch2) {
if (Array.isArray(structuredPatch2)) {
return structuredPatch2.map(reversePatch).reverse();
}
return _objectSpread2(_objectSpread2({}, structuredPatch2), {}, {
oldFileName: structuredPatch2.newFileName,
oldHeader: structuredPatch2.newHeader,
newFileName: structuredPatch2.oldFileName,
newHeader: structuredPatch2.oldHeader,
hunks: structuredPatch2.hunks.map(function(hunk) {
return {
oldLines: hunk.newLines,
oldStart: hunk.newStart,
newLines: hunk.oldLines,
newStart: hunk.oldStart,
lines: hunk.lines.map(function(l) {
if (l.startsWith("-")) {
return "+".concat(l.slice(1));
}
if (l.startsWith("+")) {
return "-".concat(l.slice(1));
}
return l;
})
};
})
});
}
function convertChangesToDMP(changes) {
var ret = [], change, operation;
for (var i = 0; i < changes.length; i++) {
change = changes[i];
if (change.added) {
operation = 1;
} else if (change.removed) {
operation = -1;
} else {
operation = 0;
}
ret.push([operation, change.value]);
}
return ret;
}
function convertChangesToXML(changes) {
var ret = [];
for (var i = 0; i < changes.length; i++) {
var change = changes[i];
if (change.added) {
ret.push("<ins>");
} else if (change.removed) {
ret.push("<del>");
}
ret.push(escapeHTML(change.value));
if (change.added) {
ret.push("</ins>");
} else if (change.removed) {
ret.push("</del>");
}
}
return ret.join("");
}
function escapeHTML(s) {
var n = s;
n = n.replace(/&/g, "&");
n = n.replace(/</g, "<");
n = n.replace(/>/g, ">");
n = n.replace(/"/g, """);
return n;
}
export {
Diff,
applyPatch,
applyPatches,
canonicalize,
convertChangesToDMP,
convertChangesToXML,
createPatch,
createTwoFilesPatch,
diffArrays,
diffChars,
diffCss,
diffJson,
diffLines,
diffSentences,
diffTrimmedLines,
diffWords,
diffWordsWithSpace,
formatPatch,
merge,
parsePatch,
reversePatch,
structuredPatch
};
//# sourceMappingURL=diff.js.map