From d0bcb76bd635eefcb1fae39e831e227a1852ef68 Mon Sep 17 00:00:00 2001 From: Gar Date: Thu, 22 Feb 2024 07:18:25 -0800 Subject: [PATCH] deps: diff@5.2.0 --- node_modules/diff/CONTRIBUTING.md | 17 +- node_modules/diff/LICENSE | 44 ++-- node_modules/diff/dist/diff.js | 297 +++++++++++++++++-------- node_modules/diff/dist/diff.min.js | 39 +--- node_modules/diff/lib/diff/base.js | 171 +++++++++----- node_modules/diff/lib/diff/line.js | 7 +- node_modules/diff/lib/index.es6.js | 260 +++++++++++++++++----- node_modules/diff/lib/index.js | 20 +- node_modules/diff/lib/index.mjs | 260 +++++++++++++++++----- node_modules/diff/lib/patch/apply.js | 4 +- node_modules/diff/lib/patch/create.js | 6 +- node_modules/diff/lib/patch/reverse.js | 63 ++++++ node_modules/diff/package.json | 14 +- node_modules/diff/release-notes.md | 14 +- package-lock.json | 8 +- package.json | 2 +- 16 files changed, 857 insertions(+), 369 deletions(-) create mode 100644 node_modules/diff/lib/patch/reverse.js diff --git a/node_modules/diff/CONTRIBUTING.md b/node_modules/diff/CONTRIBUTING.md index c8c4fe6cc225c..c974cf678e2c5 100644 --- a/node_modules/diff/CONTRIBUTING.md +++ b/node_modules/diff/CONTRIBUTING.md @@ -15,25 +15,22 @@ Generally we like to see pull requests that ## Building ``` -npm install -npm test +yarn +yarn test ``` -The `npm test -- dev` implements watching for tests within Node and `karma start` may be used for manual testing in browsers. +Running `yarn test -- dev` will watch for tests within Node and `karma start` may be used for manual testing in browsers. If you notice any problems, please report them to the GitHub issue tracker at [http://github.com/kpdecker/jsdiff/issues](http://github.com/kpdecker/jsdiff/issues). ## Releasing -JsDiff utilizes the [release yeoman generator][generator-release] to perform most release tasks. - A full release may be completed with the following: ``` -yo release -npm publish +yarn clean +yarn grunt +yarn grunt uglify +yarn publish ``` - -[generator-release]: https://github.com/walmartlabs/generator-release -[pull-request]: https://github.com/kpdecker/jsdiff/pull/new/master diff --git a/node_modules/diff/LICENSE b/node_modules/diff/LICENSE index 4e7146ed78a2f..2d48b19fcc2e6 100644 --- a/node_modules/diff/LICENSE +++ b/node_modules/diff/LICENSE @@ -1,31 +1,29 @@ -Software License Agreement (BSD License) +BSD 3-Clause License Copyright (c) 2009-2015, Kevin Decker - All rights reserved. -Redistribution and use of this software in source and binary forms, with or without modification, -are permitted provided that the following conditions are met: +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. -* Neither the name of Kevin Decker nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission. +3. Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR -IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR -CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER -IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT -OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \ No newline at end of file +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/node_modules/diff/dist/diff.js b/node_modules/diff/dist/diff.js index 7fa3a556c4200..76232b293d549 100644 --- a/node_modules/diff/dist/diff.js +++ b/node_modules/diff/dist/diff.js @@ -1,40 +1,3 @@ -/*! - - diff v5.1.0 - -Software License Agreement (BSD License) - -Copyright (c) 2009-2015, Kevin Decker - -All rights reserved. - -Redistribution and use of this software in source and binary forms, with or without modification, -are permitted provided that the following conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of Kevin Decker nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR -IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR -CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER -IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT -OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -@license -*/ (function (global, factory) { typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'], factory) : @@ -44,6 +7,8 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. function Diff() {} Diff.prototype = { diff: function diff(oldString, newString) { + var _options$timeout; + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; var callback = options.callback; @@ -80,64 +45,96 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 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 = [{ - newPos: -1, - components: [] + oldPos: -1, + lastComponent: undefined }]; // Seed editLength = 0, i.e. the content starts with the same values - var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0); + var newPos = this.extractCommon(bestPath[0], newString, oldString, 0); - if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) { + if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) { // Identity per the equality and tokenizer return done([{ value: this.join(newString), count: newString.length }]); - } // Main worker method. checks all permutations of a given edit length for acceptance. - + } // Once we hit the right edge of the edit graph on some diagonal k, we can + // definitely reach the end of the edit graph in no more than k edits, so + // there's no point in considering any moves to diagonal k+1 any more (from + // which we're guaranteed to need at least k+1 more edits). + // Similarly, once we've reached the bottom of the edit graph, there's no + // point considering moves to lower diagonals. + // We record this fact by setting minDiagonalToConsider and + // maxDiagonalToConsider to some finite value once we've hit the edge of + // the edit graph. + // This optimization is not faithful to the original algorithm presented in + // Myers's paper, which instead pointlessly extends D-paths off the end of + // the edit graph - see page 7 of Myers's paper which notes this point + // explicitly and illustrates it with a diagram. This has major performance + // implications for some common scenarios. For instance, to compute a diff + // where the new text simply appends d characters on the end of the + // original text of length n, the true Myers algorithm will take O(n+d^2) + // time while this optimization needs only O(n+d) time. + + + var minDiagonalToConsider = -Infinity, + maxDiagonalToConsider = Infinity; // Main worker method. checks all permutations of a given edit length for acceptance. function execEditLength() { - for (var diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) { + 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]; - var addPath = bestPath[diagonalPath - 1], - removePath = bestPath[diagonalPath + 1], - _oldPos = (removePath ? removePath.newPos : 0) - diagonalPath; - - if (addPath) { + if (removePath) { // No one else is going to attempt to use this value, clear it bestPath[diagonalPath - 1] = undefined; } - var canAdd = addPath && addPath.newPos + 1 < newLen, - canRemove = removePath && 0 <= _oldPos && _oldPos < oldLen; + var canAdd = false; + + if (addPath) { + // what newPos will be after we do an insertion: + var addPathNewPos = addPath.oldPos - diagonalPath; + canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen; + } + + var canRemove = removePath && removePath.oldPos + 1 < oldLen; if (!canAdd && !canRemove) { // If this path is a terminal then prune bestPath[diagonalPath] = undefined; continue; } // Select the diagonal that we want to branch from. We select the prior - // path whose position in the new string is the farthest from the origin + // path whose position in the old string is the farthest from the origin // and does not pass the bounds of the diff graph + // TODO: Remove the `+ 1` here to make behavior match Myers algorithm + // and prefer to order removals before insertions. - if (!canAdd || canRemove && addPath.newPos < removePath.newPos) { - basePath = clonePath(removePath); - self.pushComponent(basePath.components, undefined, true); + if (!canRemove || canAdd && removePath.oldPos + 1 < addPath.oldPos) { + basePath = self.addToPath(addPath, true, undefined, 0); } else { - basePath = addPath; // No need to clone, we've pulled it from the list - - basePath.newPos++; - self.pushComponent(basePath.components, true, undefined); + basePath = self.addToPath(removePath, undefined, true, 1); } - _oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath); // If we have hit the end of both strings, then we are done + newPos = self.extractCommon(basePath, newString, oldString, diagonalPath); - if (basePath.newPos + 1 >= newLen && _oldPos + 1 >= oldLen) { - return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken)); + if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) { + // If we have hit the end of both strings, then we are done + return done(buildValues(self, basePath.lastComponent, newString, oldString, self.useLongestToken)); } else { - // Otherwise track this path as a potential candidate and continue. bestPath[diagonalPath] = basePath; + + if (basePath.oldPos + 1 >= oldLen) { + maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1); + } + + if (newPos + 1 >= newLen) { + minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1); + } } } @@ -151,7 +148,7 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. if (callback) { (function exec() { setTimeout(function () { - if (editLength > maxEditLength) { + if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) { return callback(); } @@ -161,7 +158,7 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. }, 0); })(); } else { - while (editLength <= maxEditLength) { + while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) { var ret = execEditLength(); if (ret) { @@ -170,30 +167,36 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. } } }, - pushComponent: function pushComponent(components, added, removed) { - var last = components[components.length - 1]; + addToPath: function addToPath(path, added, removed, oldPosInc) { + var last = path.lastComponent; if (last && last.added === added && last.removed === removed) { - // We need to clone here as the component clone operation is just - // as shallow array clone - components[components.length - 1] = { - count: last.count + 1, - added: added, - removed: removed + return { + oldPos: path.oldPos + oldPosInc, + lastComponent: { + count: last.count + 1, + added: added, + removed: removed, + previousComponent: last.previousComponent + } }; } else { - components.push({ - count: 1, - added: added, - removed: removed - }); + return { + oldPos: path.oldPos + oldPosInc, + lastComponent: { + count: 1, + added: added, + removed: removed, + previousComponent: last + } + }; } }, extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) { var newLen = newString.length, oldLen = oldString.length, - newPos = basePath.newPos, - oldPos = newPos - diagonalPath, + oldPos = basePath.oldPos, + newPos = oldPos - diagonalPath, commonCount = 0; while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) { @@ -203,13 +206,14 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. } if (commonCount) { - basePath.components.push({ - count: commonCount - }); + basePath.lastComponent = { + count: commonCount, + previousComponent: basePath.lastComponent + }; } - basePath.newPos = newPos; - return oldPos; + basePath.oldPos = oldPos; + return newPos; }, equals: function equals(left, right) { if (this.options.comparator) { @@ -240,7 +244,20 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. } }; - function buildValues(diff, components, newString, oldString, useLongestToken) { + function buildValues(diff, lastComponent, newString, oldString, useLongestToken) { + // First we convert our linked list of components in reverse order to an + // array in the right order: + 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, @@ -283,23 +300,16 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // This is only available for string mode. - var lastComponent = components[componentLen - 1]; + var finalComponent = components[componentLen - 1]; - if (componentLen > 1 && typeof lastComponent.value === 'string' && (lastComponent.added || lastComponent.removed) && diff.equals('', lastComponent.value)) { - components[componentLen - 2].value += lastComponent.value; + if (componentLen > 1 && typeof finalComponent.value === 'string' && (finalComponent.added || finalComponent.removed) && diff.equals('', finalComponent.value)) { + components[componentLen - 2].value += finalComponent.value; components.pop(); } return components; } - function clonePath(path) { - return { - newPos: path.newPos, - components: path.components.slice(0) - }; - } - var characterDiff = new Diff(); function diffChars(oldStr, newStr, options) { return characterDiff.diff(oldStr, newStr, options); @@ -380,6 +390,11 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. var lineDiff = new Diff(); lineDiff.tokenize = function (value) { + if (this.options.stripTrailingCr) { + // remove one \r before \n to match GNU diff's --strip-trailing-cr behavior + value = value.replace(/\r\n/g, '\n'); + } + var retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/); // Ignore the final empty token that occurs if the string ends with a new line @@ -451,6 +466,55 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. return _typeof(obj); } + function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; + } + + function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; + } + + function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; + } + function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); } @@ -883,7 +947,7 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. var line = _hunk.lines[j], operation = line.length > 0 ? line[0] : ' ', content = line.length > 0 ? line.substr(1) : line, - delimiter = _hunk.linedelimiters[j]; + delimiter = _hunk.linedelimiters && _hunk.linedelimiters[j] || '\n'; if (operation === ' ') { _toPos++; @@ -1090,6 +1154,10 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. }; } function formatPatch(diff) { + if (Array.isArray(diff)) { + return diff.map(formatPatch).join('\n'); + } + var ret = []; if (diff.oldFileName == diff.newFileName) { @@ -1545,6 +1613,39 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. }; } + function reversePatch(structuredPatch) { + if (Array.isArray(structuredPatch)) { + return structuredPatch.map(reversePatch).reverse(); + } + + return _objectSpread2(_objectSpread2({}, structuredPatch), {}, { + oldFileName: structuredPatch.newFileName, + oldHeader: structuredPatch.newHeader, + newFileName: structuredPatch.oldFileName, + newHeader: structuredPatch.oldHeader, + hunks: structuredPatch.hunks.map(function (hunk) { + return { + oldLines: hunk.newLines, + oldStart: hunk.newStart, + newLines: hunk.oldLines, + newStart: hunk.oldStart, + linedelimiters: hunk.linedelimiters, + lines: hunk.lines.map(function (l) { + if (l.startsWith('-')) { + return "+".concat(l.slice(1)); + } + + if (l.startsWith('+')) { + return "-".concat(l.slice(1)); + } + + return l; + }) + }; + }) + }); + } + // See: http://code.google.com/p/google-diff-match-patch/wiki/API function convertChangesToDMP(changes) { var ret = [], @@ -1618,8 +1719,10 @@ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. exports.diffTrimmedLines = diffTrimmedLines; exports.diffWords = diffWords; exports.diffWordsWithSpace = diffWordsWithSpace; + exports.formatPatch = formatPatch; exports.merge = merge; exports.parsePatch = parsePatch; + exports.reversePatch = reversePatch; exports.structuredPatch = structuredPatch; Object.defineProperty(exports, '__esModule', { value: true }); diff --git a/node_modules/diff/dist/diff.min.js b/node_modules/diff/dist/diff.min.js index 80c20de5b757d..078bcc5c2e6a7 100644 --- a/node_modules/diff/dist/diff.min.js +++ b/node_modules/diff/dist/diff.min.js @@ -1,38 +1 @@ -/*! - - diff v5.1.0 - -Software License Agreement (BSD License) - -Copyright (c) 2009-2015, Kevin Decker - -All rights reserved. - -Redistribution and use of this software in source and binary forms, with or without modification, -are permitted provided that the following conditions are met: - -* Redistributions of source code must retain the above - copyright notice, this list of conditions and the - following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the - following disclaimer in the documentation and/or other - materials provided with the distribution. - -* Neither the name of Kevin Decker nor the names of its - contributors may be used to endorse or promote products - derived from this software without specific prior - written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR -IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR -CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER -IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT -OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -@license -*/ -!function(e,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n((e=e||self).Diff={})}(this,function(e){"use strict";function t(){}t.prototype={diff:function(u,a,e){var n=2=c&&h<=i+1)return d([{value:this.join(a),count:a.length}]);function o(){for(var e,n=-1*p;n<=p;n+=2){var t=void 0,r=v[n-1],i=v[n+1],o=(i?i.newPos:0)-n;r&&(v[n-1]=void 0);var l=r&&r.newPos+1=c&&h<=o+1)return d(function(e,n,t,r,i){for(var o=0,l=n.length,s=0,u=0;oe.length?t:e}),d.value=e.join(f)):d.value=e.join(t.slice(s,s+d.count)),s+=d.count,d.added||(u+=d.count))}var c=n[l-1];1e.length)&&(n=e.length);for(var t=0,r=new Array(n);t=c.length-2&&u.length<=d.context&&(i=/\n$/.test(a),o=/\n$/.test(f),l=0==u.length&&g.length>r.oldLines,!i&&l&&0e.length)return!1;for(var t=0;t"):i.removed&&t.push(""),t.push((n=i.value,n.replace(/&/g,"&").replace(//g,">").replace(/"/g,"""))),i.added?t.push(""):i.removed&&t.push("")}return t.join("")},e.createPatch=function(e,n,t,r,i,o){return y(e,e,n,t,r,i,o)},e.createTwoFilesPatch=y,e.diffArrays=function(e,n,t){return g.diff(e,n,t)},e.diffChars=function(e,n,t){return r.diff(e,n,t)},e.diffCss=function(e,n,t){return f.diff(e,n,t)},e.diffJson=function(e,n,t){return p.diff(e,n,t)},e.diffLines=L,e.diffSentences=function(e,n,t){return a.diff(e,n,t)},e.diffTrimmedLines=function(e,n,t){var r=i(t,{ignoreWhitespace:!0});return u.diff(e,n,r)},e.diffWords=function(e,n,t){return t=i(t,{ignoreWhitespace:!0}),s.diff(e,n,t)},e.diffWordsWithSpace=function(e,n,t){return s.diff(e,n,t)},e.merge=function(e,n,t){e=b(e,t),n=b(n,t);var r={};(e.index||n.index)&&(r.index=e.index||n.index),(e.newFileName||n.newFileName)&&(F(e)?F(n)?(r.oldFileName=N(r,e.oldFileName,n.oldFileName),r.newFileName=N(r,e.newFileName,n.newFileName),r.oldHeader=N(r,e.oldHeader,n.oldHeader),r.newHeader=N(r,e.newHeader,n.newHeader)):(r.oldFileName=e.oldFileName,r.newFileName=e.newFileName,r.oldHeader=e.oldHeader,r.newHeader=e.newHeader):(r.oldFileName=n.oldFileName||e.oldFileName,r.newFileName=n.newFileName||e.newFileName,r.oldHeader=n.oldHeader||e.oldHeader,r.newHeader=n.newHeader||e.newHeader)),r.hunks=[];for(var i=0,o=0,l=0,s=0;i=c&&f<=v+1)return d([{value:this.join(a),count:a.length}]);var m=-1/0,g=1/0;function w(){for(var e=Math.max(m,-p);e<=Math.min(g,p);e+=2){var n=void 0,t=h[e-1],r=h[e+1];t&&(h[e-1]=void 0);var i,o=!1;r&&(i=r.oldPos-e,o=r&&0<=i&&i=c&&f<=v+1)return d(function(e,n,t,r,i){var o,l=[];for(;n;)l.push(n),o=n.previousComponent,delete n.previousComponent,n=o;l.reverse();for(var s=0,a=l.length,u=0,d=0;se.length?t:e}),p.value=e.join(c)):p.value=e.join(t.slice(u,u+p.count)),u+=p.count,p.added||(d+=p.count))}var h=l[a-1];1=c&&(g=Math.min(g,e-1)),f<=v+1&&(m=Math.max(m,e+1))}else h[e]=void 0}p++}if(r)!function e(){setTimeout(function(){return il?r():void(w()||e())},0)}();else for(;p<=i&&Date.now()<=l;){var y=w();if(y)return y}},addToPath:function(e,n,t,r){var i=e.lastComponent;return i&&i.added===n&&i.removed===t?{oldPos:e.oldPos+r,lastComponent:{count:i.count+1,added:n,removed:t,previousComponent:i.previousComponent}}:{oldPos:e.oldPos+r,lastComponent:{count:1,added:n,removed:t,previousComponent:i}}},extractCommon:function(e,n,t,r){for(var i=n.length,o=t.length,l=e.oldPos,s=l-r,a=0;s+1e.length)&&(n=e.length);for(var t=0,r=new Array(n);t=c.length-2&&a.length<=f.context&&(i=/\n$/.test(u),o=/\n$/.test(d),l=0==a.length&&m.length>r.oldLines,!i&&l&&0e.length)return!1;for(var t=0;t"):i.removed&&t.push(""),t.push((n=i.value,n.replace(/&/g,"&").replace(//g,">").replace(/"/g,"""))),i.added?t.push(""):i.removed&&t.push("")}return t.join("")},e.createPatch=function(e,n,t,r,i,o){return b(e,e,n,t,r,i,o)},e.createTwoFilesPatch=b,e.diffArrays=function(e,n,t){return g.diff(e,n,t)},e.diffChars=function(e,n,t){return r.diff(e,n,t)},e.diffCss=function(e,n,t){return d.diff(e,n,t)},e.diffJson=function(e,n,t){return v.diff(e,n,t)},e.diffLines=L,e.diffSentences=function(e,n,t){return u.diff(e,n,t)},e.diffTrimmedLines=function(e,n,t){var r=i(t,{ignoreWhitespace:!0});return a.diff(e,n,r)},e.diffWords=function(e,n,t){return t=i(t,{ignoreWhitespace:!0}),s.diff(e,n,t)},e.diffWordsWithSpace=function(e,n,t){return s.diff(e,n,t)},e.formatPatch=S,e.merge=function(e,n,t){e=N(e,t),n=N(n,t);var r={};(e.index||n.index)&&(r.index=e.index||n.index),(e.newFileName||n.newFileName)&&(P(e)?P(n)?(r.oldFileName=j(r,e.oldFileName,n.oldFileName),r.newFileName=j(r,e.newFileName,n.newFileName),r.oldHeader=j(r,e.oldHeader,n.oldHeader),r.newHeader=j(r,e.newHeader,n.newHeader)):(r.oldFileName=e.oldFileName,r.newFileName=e.newFileName,r.oldHeader=e.oldHeader,r.newHeader=e.newHeader):(r.oldFileName=n.oldFileName||e.oldFileName,r.newFileName=n.newFileName||e.newFileName,r.oldHeader=n.oldHeader||e.oldHeader,r.newHeader=n.newHeader||e.newHeader)),r.hunks=[];for(var i=0,o=0,l=0,s=0;i 2 && arguments[2] !== undefined ? arguments[2] : {}; @@ -53,68 +55,104 @@ Diff.prototype = { maxEditLength = Math.min(maxEditLength, options.maxEditLength); } + var maxExecutionTime = + /*istanbul ignore start*/ + (_options$timeout = + /*istanbul ignore end*/ + options.timeout) !== null && _options$timeout !== void 0 ? _options$timeout : Infinity; + var abortAfterTimestamp = Date.now() + maxExecutionTime; var bestPath = [{ - newPos: -1, - components: [] + oldPos: -1, + lastComponent: undefined }]; // Seed editLength = 0, i.e. the content starts with the same values - var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0); + var newPos = this.extractCommon(bestPath[0], newString, oldString, 0); - if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) { + if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) { // Identity per the equality and tokenizer return done([{ value: this.join(newString), count: newString.length }]); - } // Main worker method. checks all permutations of a given edit length for acceptance. - + } // Once we hit the right edge of the edit graph on some diagonal k, we can + // definitely reach the end of the edit graph in no more than k edits, so + // there's no point in considering any moves to diagonal k+1 any more (from + // which we're guaranteed to need at least k+1 more edits). + // Similarly, once we've reached the bottom of the edit graph, there's no + // point considering moves to lower diagonals. + // We record this fact by setting minDiagonalToConsider and + // maxDiagonalToConsider to some finite value once we've hit the edge of + // the edit graph. + // This optimization is not faithful to the original algorithm presented in + // Myers's paper, which instead pointlessly extends D-paths off the end of + // the edit graph - see page 7 of Myers's paper which notes this point + // explicitly and illustrates it with a diagram. This has major performance + // implications for some common scenarios. For instance, to compute a diff + // where the new text simply appends d characters on the end of the + // original text of length n, the true Myers algorithm will take O(n+d^2) + // time while this optimization needs only O(n+d) time. + + + var minDiagonalToConsider = -Infinity, + maxDiagonalToConsider = Infinity; // Main worker method. checks all permutations of a given edit length for acceptance. function execEditLength() { - for (var diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) { + for (var diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) { var basePath = /*istanbul ignore start*/ void 0 /*istanbul ignore end*/ ; + var removePath = bestPath[diagonalPath - 1], + addPath = bestPath[diagonalPath + 1]; - var addPath = bestPath[diagonalPath - 1], - removePath = bestPath[diagonalPath + 1], - _oldPos = (removePath ? removePath.newPos : 0) - diagonalPath; - - if (addPath) { + if (removePath) { // No one else is going to attempt to use this value, clear it bestPath[diagonalPath - 1] = undefined; } - var canAdd = addPath && addPath.newPos + 1 < newLen, - canRemove = removePath && 0 <= _oldPos && _oldPos < oldLen; + var canAdd = false; + + if (addPath) { + // what newPos will be after we do an insertion: + var addPathNewPos = addPath.oldPos - diagonalPath; + canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen; + } + + var canRemove = removePath && removePath.oldPos + 1 < oldLen; if (!canAdd && !canRemove) { // If this path is a terminal then prune bestPath[diagonalPath] = undefined; continue; } // Select the diagonal that we want to branch from. We select the prior - // path whose position in the new string is the farthest from the origin + // path whose position in the old string is the farthest from the origin // and does not pass the bounds of the diff graph + // TODO: Remove the `+ 1` here to make behavior match Myers algorithm + // and prefer to order removals before insertions. - if (!canAdd || canRemove && addPath.newPos < removePath.newPos) { - basePath = clonePath(removePath); - self.pushComponent(basePath.components, undefined, true); + if (!canRemove || canAdd && removePath.oldPos + 1 < addPath.oldPos) { + basePath = self.addToPath(addPath, true, undefined, 0); } else { - basePath = addPath; // No need to clone, we've pulled it from the list - - basePath.newPos++; - self.pushComponent(basePath.components, true, undefined); + basePath = self.addToPath(removePath, undefined, true, 1); } - _oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath); // If we have hit the end of both strings, then we are done + newPos = self.extractCommon(basePath, newString, oldString, diagonalPath); - if (basePath.newPos + 1 >= newLen && _oldPos + 1 >= oldLen) { - return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken)); + if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) { + // If we have hit the end of both strings, then we are done + return done(buildValues(self, basePath.lastComponent, newString, oldString, self.useLongestToken)); } else { - // Otherwise track this path as a potential candidate and continue. bestPath[diagonalPath] = basePath; + + if (basePath.oldPos + 1 >= oldLen) { + maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1); + } + + if (newPos + 1 >= newLen) { + minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1); + } } } @@ -128,7 +166,7 @@ Diff.prototype = { if (callback) { (function exec() { setTimeout(function () { - if (editLength > maxEditLength) { + if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) { return callback(); } @@ -138,7 +176,7 @@ Diff.prototype = { }, 0); })(); } else { - while (editLength <= maxEditLength) { + while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) { var ret = execEditLength(); if (ret) { @@ -151,23 +189,29 @@ Diff.prototype = { /*istanbul ignore start*/ /*istanbul ignore end*/ - pushComponent: function pushComponent(components, added, removed) { - var last = components[components.length - 1]; + addToPath: function addToPath(path, added, removed, oldPosInc) { + var last = path.lastComponent; if (last && last.added === added && last.removed === removed) { - // We need to clone here as the component clone operation is just - // as shallow array clone - components[components.length - 1] = { - count: last.count + 1, - added: added, - removed: removed + return { + oldPos: path.oldPos + oldPosInc, + lastComponent: { + count: last.count + 1, + added: added, + removed: removed, + previousComponent: last.previousComponent + } }; } else { - components.push({ - count: 1, - added: added, - removed: removed - }); + return { + oldPos: path.oldPos + oldPosInc, + lastComponent: { + count: 1, + added: added, + removed: removed, + previousComponent: last + } + }; } }, @@ -177,8 +221,8 @@ Diff.prototype = { extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) { var newLen = newString.length, oldLen = oldString.length, - newPos = basePath.newPos, - oldPos = newPos - diagonalPath, + oldPos = basePath.oldPos, + newPos = oldPos - diagonalPath, commonCount = 0; while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) { @@ -188,13 +232,14 @@ Diff.prototype = { } if (commonCount) { - basePath.components.push({ - count: commonCount - }); + basePath.lastComponent = { + count: commonCount, + previousComponent: basePath.lastComponent + }; } - basePath.newPos = newPos; - return oldPos; + basePath.oldPos = oldPos; + return newPos; }, /*istanbul ignore start*/ @@ -245,7 +290,20 @@ Diff.prototype = { } }; -function buildValues(diff, components, newString, oldString, useLongestToken) { +function buildValues(diff, lastComponent, newString, oldString, useLongestToken) { + // First we convert our linked list of components in reverse order to an + // array in the right order: + 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, @@ -288,20 +346,13 @@ function buildValues(diff, components, newString, oldString, useLongestToken) { // This is only available for string mode. - var lastComponent = components[componentLen - 1]; + var finalComponent = components[componentLen - 1]; - if (componentLen > 1 && typeof lastComponent.value === 'string' && (lastComponent.added || lastComponent.removed) && diff.equals('', lastComponent.value)) { - components[componentLen - 2].value += lastComponent.value; + if (componentLen > 1 && typeof finalComponent.value === 'string' && (finalComponent.added || finalComponent.removed) && diff.equals('', finalComponent.value)) { + components[componentLen - 2].value += finalComponent.value; components.pop(); } return components; } - -function clonePath(path) { - return { - newPos: path.newPos, - components: path.components.slice(0) - }; -} -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/diff/base.js"],"names":["Diff","prototype","diff","oldString","newString","options","callback","self","done","value","setTimeout","undefined","castInput","removeEmpty","tokenize","newLen","length","oldLen","editLength","maxEditLength","Math","min","bestPath","newPos","components","oldPos","extractCommon","join","count","execEditLength","diagonalPath","basePath","addPath","removePath","canAdd","canRemove","clonePath","pushComponent","buildValues","useLongestToken","exec","ret","added","removed","last","push","commonCount","equals","left","right","comparator","ignoreCase","toLowerCase","array","i","split","chars","componentPos","componentLen","component","slice","map","oldValue","tmp","lastComponent","pop","path"],"mappings":"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","sourcesContent":["export default function Diff() {}\n\nDiff.prototype = {\n  diff(oldString, newString, options = {}) {\n    let callback = options.callback;\n    if (typeof options === 'function') {\n      callback = options;\n      options = {};\n    }\n    this.options = options;\n\n    let self = this;\n\n    function done(value) {\n      if (callback) {\n        setTimeout(function() { callback(undefined, value); }, 0);\n        return true;\n      } else {\n        return value;\n      }\n    }\n\n    // Allow subclasses to massage the input prior to running\n    oldString = this.castInput(oldString);\n    newString = this.castInput(newString);\n\n    oldString = this.removeEmpty(this.tokenize(oldString));\n    newString = this.removeEmpty(this.tokenize(newString));\n\n    let newLen = newString.length, oldLen = oldString.length;\n    let editLength = 1;\n    let maxEditLength = newLen + oldLen;\n    if(options.maxEditLength) {\n      maxEditLength = Math.min(maxEditLength, options.maxEditLength);\n    }\n\n    let bestPath = [{ newPos: -1, components: [] }];\n\n    // Seed editLength = 0, i.e. the content starts with the same values\n    let oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);\n    if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) {\n      // Identity per the equality and tokenizer\n      return done([{value: this.join(newString), count: newString.length}]);\n    }\n\n    // Main worker method. checks all permutations of a given edit length for acceptance.\n    function execEditLength() {\n      for (let diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) {\n        let basePath;\n        let addPath = bestPath[diagonalPath - 1],\n            removePath = bestPath[diagonalPath + 1],\n            oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;\n        if (addPath) {\n          // No one else is going to attempt to use this value, clear it\n          bestPath[diagonalPath - 1] = undefined;\n        }\n\n        let canAdd = addPath && addPath.newPos + 1 < newLen,\n            canRemove = removePath && 0 <= oldPos && oldPos < oldLen;\n        if (!canAdd && !canRemove) {\n          // If this path is a terminal then prune\n          bestPath[diagonalPath] = undefined;\n          continue;\n        }\n\n        // Select the diagonal that we want to branch from. We select the prior\n        // path whose position in the new string is the farthest from the origin\n        // and does not pass the bounds of the diff graph\n        if (!canAdd || (canRemove && addPath.newPos < removePath.newPos)) {\n          basePath = clonePath(removePath);\n          self.pushComponent(basePath.components, undefined, true);\n        } else {\n          basePath = addPath; // No need to clone, we've pulled it from the list\n          basePath.newPos++;\n          self.pushComponent(basePath.components, true, undefined);\n        }\n\n        oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath);\n\n        // If we have hit the end of both strings, then we are done\n        if (basePath.newPos + 1 >= newLen && oldPos + 1 >= oldLen) {\n          return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken));\n        } else {\n          // Otherwise track this path as a potential candidate and continue.\n          bestPath[diagonalPath] = basePath;\n        }\n      }\n\n      editLength++;\n    }\n\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    if (callback) {\n      (function exec() {\n        setTimeout(function() {\n          if (editLength > maxEditLength) {\n            return callback();\n          }\n\n          if (!execEditLength()) {\n            exec();\n          }\n        }, 0);\n      }());\n    } else {\n      while (editLength <= maxEditLength) {\n        let ret = execEditLength();\n        if (ret) {\n          return ret;\n        }\n      }\n    }\n  },\n\n  pushComponent(components, added, removed) {\n    let last = components[components.length - 1];\n    if (last && last.added === added && last.removed === removed) {\n      // We need to clone here as the component clone operation is just\n      // as shallow array clone\n      components[components.length - 1] = {count: last.count + 1, added: added, removed: removed };\n    } else {\n      components.push({count: 1, added: added, removed: removed });\n    }\n  },\n  extractCommon(basePath, newString, oldString, diagonalPath) {\n    let newLen = newString.length,\n        oldLen = oldString.length,\n        newPos = basePath.newPos,\n        oldPos = newPos - diagonalPath,\n\n        commonCount = 0;\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.components.push({count: commonCount});\n    }\n\n    basePath.newPos = newPos;\n    return oldPos;\n  },\n\n  equals(left, right) {\n    if (this.options.comparator) {\n      return this.options.comparator(left, right);\n    } else {\n      return left === right\n        || (this.options.ignoreCase && left.toLowerCase() === right.toLowerCase());\n    }\n  },\n  removeEmpty(array) {\n    let ret = [];\n    for (let i = 0; i < array.length; i++) {\n      if (array[i]) {\n        ret.push(array[i]);\n      }\n    }\n    return ret;\n  },\n  castInput(value) {\n    return value;\n  },\n  tokenize(value) {\n    return value.split('');\n  },\n  join(chars) {\n    return chars.join('');\n  }\n};\n\nfunction buildValues(diff, components, newString, oldString, useLongestToken) {\n  let componentPos = 0,\n      componentLen = components.length,\n      newPos = 0,\n      oldPos = 0;\n\n  for (; componentPos < componentLen; componentPos++) {\n    let component = components[componentPos];\n    if (!component.removed) {\n      if (!component.added && useLongestToken) {\n        let value = newString.slice(newPos, newPos + component.count);\n        value = value.map(function(value, i) {\n          let oldValue = oldString[oldPos + i];\n          return oldValue.length > value.length ? oldValue : value;\n        });\n\n        component.value = diff.join(value);\n      } else {\n        component.value = diff.join(newString.slice(newPos, newPos + component.count));\n      }\n      newPos += component.count;\n\n      // Common case\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;\n\n      // 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      if (componentPos && components[componentPos - 1].added) {\n        let tmp = components[componentPos - 1];\n        components[componentPos - 1] = components[componentPos];\n        components[componentPos] = tmp;\n      }\n    }\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  let lastComponent = components[componentLen - 1];\n  if (componentLen > 1\n      && typeof lastComponent.value === 'string'\n      && (lastComponent.added || lastComponent.removed)\n      && diff.equals('', lastComponent.value)) {\n    components[componentLen - 2].value += lastComponent.value;\n    components.pop();\n  }\n\n  return components;\n}\n\nfunction clonePath(path) {\n  return { newPos: path.newPos, components: path.components.slice(0) };\n}\n"]} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/diff/base.js"],"names":["Diff","prototype","diff","oldString","newString","options","callback","self","done","value","setTimeout","undefined","castInput","removeEmpty","tokenize","newLen","length","oldLen","editLength","maxEditLength","Math","min","maxExecutionTime","timeout","Infinity","abortAfterTimestamp","Date","now","bestPath","oldPos","lastComponent","newPos","extractCommon","join","count","minDiagonalToConsider","maxDiagonalToConsider","execEditLength","diagonalPath","max","basePath","removePath","addPath","canAdd","addPathNewPos","canRemove","addToPath","buildValues","useLongestToken","exec","ret","path","added","removed","oldPosInc","last","previousComponent","commonCount","equals","left","right","comparator","ignoreCase","toLowerCase","array","i","push","split","chars","components","nextComponent","reverse","componentPos","componentLen","component","slice","map","oldValue","tmp","finalComponent","pop"],"mappings":"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","sourcesContent":["export default function Diff() {}\n\nDiff.prototype = {\n  diff(oldString, newString, options = {}) {\n    let callback = options.callback;\n    if (typeof options === 'function') {\n      callback = options;\n      options = {};\n    }\n    this.options = options;\n\n    let self = this;\n\n    function done(value) {\n      if (callback) {\n        setTimeout(function() { callback(undefined, value); }, 0);\n        return true;\n      } else {\n        return value;\n      }\n    }\n\n    // Allow subclasses to massage the input prior to running\n    oldString = this.castInput(oldString);\n    newString = this.castInput(newString);\n\n    oldString = this.removeEmpty(this.tokenize(oldString));\n    newString = this.removeEmpty(this.tokenize(newString));\n\n    let newLen = newString.length, oldLen = oldString.length;\n    let editLength = 1;\n    let maxEditLength = newLen + oldLen;\n    if(options.maxEditLength) {\n      maxEditLength = Math.min(maxEditLength, options.maxEditLength);\n    }\n    const maxExecutionTime = options.timeout ?? Infinity;\n    const abortAfterTimestamp = Date.now() + maxExecutionTime;\n\n    let bestPath = [{ oldPos: -1, lastComponent: undefined }];\n\n    // Seed editLength = 0, i.e. the content starts with the same values\n    let newPos = this.extractCommon(bestPath[0], newString, oldString, 0);\n    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {\n      // Identity per the equality and tokenizer\n      return done([{value: this.join(newString), count: newString.length}]);\n    }\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    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;\n\n    // Main worker method. checks all permutations of a given edit length for acceptance.\n    function execEditLength() {\n      for (\n        let diagonalPath = Math.max(minDiagonalToConsider, -editLength);\n        diagonalPath <= Math.min(maxDiagonalToConsider, editLength);\n        diagonalPath += 2\n      ) {\n        let basePath;\n        let removePath = bestPath[diagonalPath - 1],\n            addPath = bestPath[diagonalPath + 1];\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        let canAdd = false;\n        if (addPath) {\n          // what newPos will be after we do an insertion:\n          const addPathNewPos = addPath.oldPos - diagonalPath;\n          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;\n        }\n\n        let canRemove = removePath && removePath.oldPos + 1 < oldLen;\n        if (!canAdd && !canRemove) {\n          // If this path is a terminal then prune\n          bestPath[diagonalPath] = undefined;\n          continue;\n        }\n\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        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          if (basePath.oldPos + 1 >= oldLen) {\n            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);\n          }\n          if (newPos + 1 >= newLen) {\n            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);\n          }\n        }\n      }\n\n      editLength++;\n    }\n\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    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        let ret = execEditLength();\n        if (ret) {\n          return ret;\n        }\n      }\n    }\n  },\n\n  addToPath(path, added, removed, oldPosInc) {\n    let last = path.lastComponent;\n    if (last && last.added === added && last.removed === removed) {\n      return {\n        oldPos: path.oldPos + oldPosInc,\n        lastComponent: {count: last.count + 1, added: added, removed: removed, previousComponent: last.previousComponent }\n      };\n    } else {\n      return {\n        oldPos: path.oldPos + oldPosInc,\n        lastComponent: {count: 1, added: added, removed: removed, previousComponent: last }\n      };\n    }\n  },\n  extractCommon(basePath, newString, oldString, diagonalPath) {\n    let newLen = newString.length,\n        oldLen = oldString.length,\n        oldPos = basePath.oldPos,\n        newPos = oldPos - diagonalPath,\n\n        commonCount = 0;\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 = {count: commonCount, previousComponent: basePath.lastComponent};\n    }\n\n    basePath.oldPos = oldPos;\n    return newPos;\n  },\n\n  equals(left, right) {\n    if (this.options.comparator) {\n      return this.options.comparator(left, right);\n    } else {\n      return left === right\n        || (this.options.ignoreCase && left.toLowerCase() === right.toLowerCase());\n    }\n  },\n  removeEmpty(array) {\n    let ret = [];\n    for (let i = 0; i < array.length; i++) {\n      if (array[i]) {\n        ret.push(array[i]);\n      }\n    }\n    return ret;\n  },\n  castInput(value) {\n    return value;\n  },\n  tokenize(value) {\n    return value.split('');\n  },\n  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  const components = [];\n  let nextComponent;\n  while (lastComponent) {\n    components.push(lastComponent);\n    nextComponent = lastComponent.previousComponent;\n    delete lastComponent.previousComponent;\n    lastComponent = nextComponent;\n  }\n  components.reverse();\n\n  let componentPos = 0,\n      componentLen = components.length,\n      newPos = 0,\n      oldPos = 0;\n\n  for (; componentPos < componentLen; componentPos++) {\n    let component = components[componentPos];\n    if (!component.removed) {\n      if (!component.added && useLongestToken) {\n        let value = newString.slice(newPos, newPos + component.count);\n        value = value.map(function(value, i) {\n          let oldValue = oldString[oldPos + i];\n          return oldValue.length > value.length ? oldValue : value;\n        });\n\n        component.value = diff.join(value);\n      } else {\n        component.value = diff.join(newString.slice(newPos, newPos + component.count));\n      }\n      newPos += component.count;\n\n      // Common case\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;\n\n      // 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      if (componentPos && components[componentPos - 1].added) {\n        let tmp = components[componentPos - 1];\n        components[componentPos - 1] = components[componentPos];\n        components[componentPos] = tmp;\n      }\n    }\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  let finalComponent = components[componentLen - 1];\n  if (componentLen > 1\n      && typeof finalComponent.value === 'string'\n      && (finalComponent.added || finalComponent.removed)\n      && diff.equals('', finalComponent.value)) {\n    components[componentLen - 2].value += finalComponent.value;\n    components.pop();\n  }\n\n  return components;\n}\n"]} diff --git a/node_modules/diff/lib/diff/line.js b/node_modules/diff/lib/diff/line.js index 855fe30b9cc2c..30bc74d2383d2 100644 --- a/node_modules/diff/lib/diff/line.js +++ b/node_modules/diff/lib/diff/line.js @@ -39,6 +39,11 @@ exports.lineDiff = lineDiff; /*istanbul ignore end*/ lineDiff.tokenize = function (value) { + if (this.options.stripTrailingCr) { + // remove one \r before \n to match GNU diff's --strip-trailing-cr behavior + value = value.replace(/\r\n/g, '\n'); + } + var retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/); // Ignore the final empty token that occurs if the string ends with a new line @@ -86,4 +91,4 @@ function diffTrimmedLines(oldStr, newStr, callback) { }); return lineDiff.diff(oldStr, newStr, options); } -//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 diff --git a/node_modules/diff/lib/index.es6.js b/node_modules/diff/lib/index.es6.js index c2a00135a4e24..a0ace0182ab14 100644 --- a/node_modules/diff/lib/index.es6.js +++ b/node_modules/diff/lib/index.es6.js @@ -1,6 +1,8 @@ function Diff() {} Diff.prototype = { diff: function diff(oldString, newString) { + var _options$timeout; + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; var callback = options.callback; @@ -37,64 +39,96 @@ Diff.prototype = { 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 = [{ - newPos: -1, - components: [] + oldPos: -1, + lastComponent: undefined }]; // Seed editLength = 0, i.e. the content starts with the same values - var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0); + var newPos = this.extractCommon(bestPath[0], newString, oldString, 0); - if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) { + if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) { // Identity per the equality and tokenizer return done([{ value: this.join(newString), count: newString.length }]); - } // Main worker method. checks all permutations of a given edit length for acceptance. - + } // Once we hit the right edge of the edit graph on some diagonal k, we can + // definitely reach the end of the edit graph in no more than k edits, so + // there's no point in considering any moves to diagonal k+1 any more (from + // which we're guaranteed to need at least k+1 more edits). + // Similarly, once we've reached the bottom of the edit graph, there's no + // point considering moves to lower diagonals. + // We record this fact by setting minDiagonalToConsider and + // maxDiagonalToConsider to some finite value once we've hit the edge of + // the edit graph. + // This optimization is not faithful to the original algorithm presented in + // Myers's paper, which instead pointlessly extends D-paths off the end of + // the edit graph - see page 7 of Myers's paper which notes this point + // explicitly and illustrates it with a diagram. This has major performance + // implications for some common scenarios. For instance, to compute a diff + // where the new text simply appends d characters on the end of the + // original text of length n, the true Myers algorithm will take O(n+d^2) + // time while this optimization needs only O(n+d) time. + + + var minDiagonalToConsider = -Infinity, + maxDiagonalToConsider = Infinity; // Main worker method. checks all permutations of a given edit length for acceptance. function execEditLength() { - for (var diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) { + 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]; - var addPath = bestPath[diagonalPath - 1], - removePath = bestPath[diagonalPath + 1], - _oldPos = (removePath ? removePath.newPos : 0) - diagonalPath; - - if (addPath) { + if (removePath) { // No one else is going to attempt to use this value, clear it bestPath[diagonalPath - 1] = undefined; } - var canAdd = addPath && addPath.newPos + 1 < newLen, - canRemove = removePath && 0 <= _oldPos && _oldPos < oldLen; + var canAdd = false; + + if (addPath) { + // what newPos will be after we do an insertion: + var addPathNewPos = addPath.oldPos - diagonalPath; + canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen; + } + + var canRemove = removePath && removePath.oldPos + 1 < oldLen; if (!canAdd && !canRemove) { // If this path is a terminal then prune bestPath[diagonalPath] = undefined; continue; } // Select the diagonal that we want to branch from. We select the prior - // path whose position in the new string is the farthest from the origin + // path whose position in the old string is the farthest from the origin // and does not pass the bounds of the diff graph + // TODO: Remove the `+ 1` here to make behavior match Myers algorithm + // and prefer to order removals before insertions. - if (!canAdd || canRemove && addPath.newPos < removePath.newPos) { - basePath = clonePath(removePath); - self.pushComponent(basePath.components, undefined, true); + if (!canRemove || canAdd && removePath.oldPos + 1 < addPath.oldPos) { + basePath = self.addToPath(addPath, true, undefined, 0); } else { - basePath = addPath; // No need to clone, we've pulled it from the list - - basePath.newPos++; - self.pushComponent(basePath.components, true, undefined); + basePath = self.addToPath(removePath, undefined, true, 1); } - _oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath); // If we have hit the end of both strings, then we are done + newPos = self.extractCommon(basePath, newString, oldString, diagonalPath); - if (basePath.newPos + 1 >= newLen && _oldPos + 1 >= oldLen) { - return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken)); + if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) { + // If we have hit the end of both strings, then we are done + return done(buildValues(self, basePath.lastComponent, newString, oldString, self.useLongestToken)); } else { - // Otherwise track this path as a potential candidate and continue. bestPath[diagonalPath] = basePath; + + if (basePath.oldPos + 1 >= oldLen) { + maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1); + } + + if (newPos + 1 >= newLen) { + minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1); + } } } @@ -108,7 +142,7 @@ Diff.prototype = { if (callback) { (function exec() { setTimeout(function () { - if (editLength > maxEditLength) { + if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) { return callback(); } @@ -118,7 +152,7 @@ Diff.prototype = { }, 0); })(); } else { - while (editLength <= maxEditLength) { + while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) { var ret = execEditLength(); if (ret) { @@ -127,30 +161,36 @@ Diff.prototype = { } } }, - pushComponent: function pushComponent(components, added, removed) { - var last = components[components.length - 1]; + addToPath: function addToPath(path, added, removed, oldPosInc) { + var last = path.lastComponent; if (last && last.added === added && last.removed === removed) { - // We need to clone here as the component clone operation is just - // as shallow array clone - components[components.length - 1] = { - count: last.count + 1, - added: added, - removed: removed + return { + oldPos: path.oldPos + oldPosInc, + lastComponent: { + count: last.count + 1, + added: added, + removed: removed, + previousComponent: last.previousComponent + } }; } else { - components.push({ - count: 1, - added: added, - removed: removed - }); + return { + oldPos: path.oldPos + oldPosInc, + lastComponent: { + count: 1, + added: added, + removed: removed, + previousComponent: last + } + }; } }, extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) { var newLen = newString.length, oldLen = oldString.length, - newPos = basePath.newPos, - oldPos = newPos - diagonalPath, + oldPos = basePath.oldPos, + newPos = oldPos - diagonalPath, commonCount = 0; while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) { @@ -160,13 +200,14 @@ Diff.prototype = { } if (commonCount) { - basePath.components.push({ - count: commonCount - }); + basePath.lastComponent = { + count: commonCount, + previousComponent: basePath.lastComponent + }; } - basePath.newPos = newPos; - return oldPos; + basePath.oldPos = oldPos; + return newPos; }, equals: function equals(left, right) { if (this.options.comparator) { @@ -197,7 +238,20 @@ Diff.prototype = { } }; -function buildValues(diff, components, newString, oldString, useLongestToken) { +function buildValues(diff, lastComponent, newString, oldString, useLongestToken) { + // First we convert our linked list of components in reverse order to an + // array in the right order: + 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, @@ -240,23 +294,16 @@ function buildValues(diff, components, newString, oldString, useLongestToken) { // This is only available for string mode. - var lastComponent = components[componentLen - 1]; + var finalComponent = components[componentLen - 1]; - if (componentLen > 1 && typeof lastComponent.value === 'string' && (lastComponent.added || lastComponent.removed) && diff.equals('', lastComponent.value)) { - components[componentLen - 2].value += lastComponent.value; + if (componentLen > 1 && typeof finalComponent.value === 'string' && (finalComponent.added || finalComponent.removed) && diff.equals('', finalComponent.value)) { + components[componentLen - 2].value += finalComponent.value; components.pop(); } return components; } -function clonePath(path) { - return { - newPos: path.newPos, - components: path.components.slice(0) - }; -} - var characterDiff = new Diff(); function diffChars(oldStr, newStr, options) { return characterDiff.diff(oldStr, newStr, options); @@ -337,6 +384,11 @@ function diffWordsWithSpace(oldStr, newStr, options) { var lineDiff = new Diff(); lineDiff.tokenize = function (value) { + if (this.options.stripTrailingCr) { + // remove one \r before \n to match GNU diff's --strip-trailing-cr behavior + value = value.replace(/\r\n/g, '\n'); + } + var retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/); // Ignore the final empty token that occurs if the string ends with a new line @@ -408,6 +460,55 @@ function _typeof(obj) { return _typeof(obj); } +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +} + +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; +} + +function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; +} + function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); } @@ -840,7 +941,7 @@ function applyPatch(source, uniDiff) { var line = _hunk.lines[j], operation = line.length > 0 ? line[0] : ' ', content = line.length > 0 ? line.substr(1) : line, - delimiter = _hunk.linedelimiters[j]; + delimiter = _hunk.linedelimiters && _hunk.linedelimiters[j] || '\n'; if (operation === ' ') { _toPos++; @@ -1047,6 +1148,10 @@ function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, ne }; } function formatPatch(diff) { + if (Array.isArray(diff)) { + return diff.map(formatPatch).join('\n'); + } + var ret = []; if (diff.oldFileName == diff.newFileName) { @@ -1502,6 +1607,39 @@ function calcOldNewLineCount(lines) { }; } +function reversePatch(structuredPatch) { + if (Array.isArray(structuredPatch)) { + return structuredPatch.map(reversePatch).reverse(); + } + + return _objectSpread2(_objectSpread2({}, structuredPatch), {}, { + oldFileName: structuredPatch.newFileName, + oldHeader: structuredPatch.newHeader, + newFileName: structuredPatch.oldFileName, + newHeader: structuredPatch.oldHeader, + hunks: structuredPatch.hunks.map(function (hunk) { + return { + oldLines: hunk.newLines, + oldStart: hunk.newStart, + newLines: hunk.oldLines, + newStart: hunk.oldStart, + linedelimiters: hunk.linedelimiters, + lines: hunk.lines.map(function (l) { + if (l.startsWith('-')) { + return "+".concat(l.slice(1)); + } + + if (l.startsWith('+')) { + return "-".concat(l.slice(1)); + } + + return l; + }) + }; + }) + }); +} + // See: http://code.google.com/p/google-diff-match-patch/wiki/API function convertChangesToDMP(changes) { var ret = [], @@ -1558,4 +1696,4 @@ function escapeHTML(s) { return n; } -export { Diff, applyPatch, applyPatches, canonicalize, convertChangesToDMP, convertChangesToXML, createPatch, createTwoFilesPatch, diffArrays, diffChars, diffCss, diffJson, diffLines, diffSentences, diffTrimmedLines, diffWords, diffWordsWithSpace, merge, parsePatch, structuredPatch }; +export { Diff, applyPatch, applyPatches, canonicalize, convertChangesToDMP, convertChangesToXML, createPatch, createTwoFilesPatch, diffArrays, diffChars, diffCss, diffJson, diffLines, diffSentences, diffTrimmedLines, diffWords, diffWordsWithSpace, formatPatch, merge, parsePatch, reversePatch, structuredPatch }; diff --git a/node_modules/diff/lib/index.js b/node_modules/diff/lib/index.js index 920f0feeb0caf..09d885e118292 100644 --- a/node_modules/diff/lib/index.js +++ b/node_modules/diff/lib/index.js @@ -94,6 +94,12 @@ Object.defineProperty(exports, "merge", { return _merge.merge; } }); +Object.defineProperty(exports, "reversePatch", { + enumerable: true, + get: function get() { + return _reverse.reversePatch; + } +}); Object.defineProperty(exports, "structuredPatch", { enumerable: true, get: function get() { @@ -112,6 +118,12 @@ Object.defineProperty(exports, "createPatch", { return _create.createPatch; } }); +Object.defineProperty(exports, "formatPatch", { + enumerable: true, + get: function get() { + return _create.formatPatch; + } +}); Object.defineProperty(exports, "convertChangesToDMP", { enumerable: true, get: function get() { @@ -192,6 +204,12 @@ _merge = require("./patch/merge") /*istanbul ignore end*/ ; +var +/*istanbul ignore start*/ +_reverse = require("./patch/reverse") +/*istanbul ignore end*/ +; + var /*istanbul ignore start*/ _create = require("./patch/create") @@ -213,4 +231,4 @@ _xml = require("./convert/xml") /*istanbul ignore start*/ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; } /*istanbul ignore end*/ -//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 diff --git a/node_modules/diff/lib/index.mjs b/node_modules/diff/lib/index.mjs index c2a00135a4e24..a0ace0182ab14 100644 --- a/node_modules/diff/lib/index.mjs +++ b/node_modules/diff/lib/index.mjs @@ -1,6 +1,8 @@ function Diff() {} Diff.prototype = { diff: function diff(oldString, newString) { + var _options$timeout; + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; var callback = options.callback; @@ -37,64 +39,96 @@ Diff.prototype = { 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 = [{ - newPos: -1, - components: [] + oldPos: -1, + lastComponent: undefined }]; // Seed editLength = 0, i.e. the content starts with the same values - var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0); + var newPos = this.extractCommon(bestPath[0], newString, oldString, 0); - if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) { + if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) { // Identity per the equality and tokenizer return done([{ value: this.join(newString), count: newString.length }]); - } // Main worker method. checks all permutations of a given edit length for acceptance. - + } // Once we hit the right edge of the edit graph on some diagonal k, we can + // definitely reach the end of the edit graph in no more than k edits, so + // there's no point in considering any moves to diagonal k+1 any more (from + // which we're guaranteed to need at least k+1 more edits). + // Similarly, once we've reached the bottom of the edit graph, there's no + // point considering moves to lower diagonals. + // We record this fact by setting minDiagonalToConsider and + // maxDiagonalToConsider to some finite value once we've hit the edge of + // the edit graph. + // This optimization is not faithful to the original algorithm presented in + // Myers's paper, which instead pointlessly extends D-paths off the end of + // the edit graph - see page 7 of Myers's paper which notes this point + // explicitly and illustrates it with a diagram. This has major performance + // implications for some common scenarios. For instance, to compute a diff + // where the new text simply appends d characters on the end of the + // original text of length n, the true Myers algorithm will take O(n+d^2) + // time while this optimization needs only O(n+d) time. + + + var minDiagonalToConsider = -Infinity, + maxDiagonalToConsider = Infinity; // Main worker method. checks all permutations of a given edit length for acceptance. function execEditLength() { - for (var diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) { + 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]; - var addPath = bestPath[diagonalPath - 1], - removePath = bestPath[diagonalPath + 1], - _oldPos = (removePath ? removePath.newPos : 0) - diagonalPath; - - if (addPath) { + if (removePath) { // No one else is going to attempt to use this value, clear it bestPath[diagonalPath - 1] = undefined; } - var canAdd = addPath && addPath.newPos + 1 < newLen, - canRemove = removePath && 0 <= _oldPos && _oldPos < oldLen; + var canAdd = false; + + if (addPath) { + // what newPos will be after we do an insertion: + var addPathNewPos = addPath.oldPos - diagonalPath; + canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen; + } + + var canRemove = removePath && removePath.oldPos + 1 < oldLen; if (!canAdd && !canRemove) { // If this path is a terminal then prune bestPath[diagonalPath] = undefined; continue; } // Select the diagonal that we want to branch from. We select the prior - // path whose position in the new string is the farthest from the origin + // path whose position in the old string is the farthest from the origin // and does not pass the bounds of the diff graph + // TODO: Remove the `+ 1` here to make behavior match Myers algorithm + // and prefer to order removals before insertions. - if (!canAdd || canRemove && addPath.newPos < removePath.newPos) { - basePath = clonePath(removePath); - self.pushComponent(basePath.components, undefined, true); + if (!canRemove || canAdd && removePath.oldPos + 1 < addPath.oldPos) { + basePath = self.addToPath(addPath, true, undefined, 0); } else { - basePath = addPath; // No need to clone, we've pulled it from the list - - basePath.newPos++; - self.pushComponent(basePath.components, true, undefined); + basePath = self.addToPath(removePath, undefined, true, 1); } - _oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath); // If we have hit the end of both strings, then we are done + newPos = self.extractCommon(basePath, newString, oldString, diagonalPath); - if (basePath.newPos + 1 >= newLen && _oldPos + 1 >= oldLen) { - return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken)); + if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) { + // If we have hit the end of both strings, then we are done + return done(buildValues(self, basePath.lastComponent, newString, oldString, self.useLongestToken)); } else { - // Otherwise track this path as a potential candidate and continue. bestPath[diagonalPath] = basePath; + + if (basePath.oldPos + 1 >= oldLen) { + maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1); + } + + if (newPos + 1 >= newLen) { + minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1); + } } } @@ -108,7 +142,7 @@ Diff.prototype = { if (callback) { (function exec() { setTimeout(function () { - if (editLength > maxEditLength) { + if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) { return callback(); } @@ -118,7 +152,7 @@ Diff.prototype = { }, 0); })(); } else { - while (editLength <= maxEditLength) { + while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) { var ret = execEditLength(); if (ret) { @@ -127,30 +161,36 @@ Diff.prototype = { } } }, - pushComponent: function pushComponent(components, added, removed) { - var last = components[components.length - 1]; + addToPath: function addToPath(path, added, removed, oldPosInc) { + var last = path.lastComponent; if (last && last.added === added && last.removed === removed) { - // We need to clone here as the component clone operation is just - // as shallow array clone - components[components.length - 1] = { - count: last.count + 1, - added: added, - removed: removed + return { + oldPos: path.oldPos + oldPosInc, + lastComponent: { + count: last.count + 1, + added: added, + removed: removed, + previousComponent: last.previousComponent + } }; } else { - components.push({ - count: 1, - added: added, - removed: removed - }); + return { + oldPos: path.oldPos + oldPosInc, + lastComponent: { + count: 1, + added: added, + removed: removed, + previousComponent: last + } + }; } }, extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) { var newLen = newString.length, oldLen = oldString.length, - newPos = basePath.newPos, - oldPos = newPos - diagonalPath, + oldPos = basePath.oldPos, + newPos = oldPos - diagonalPath, commonCount = 0; while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) { @@ -160,13 +200,14 @@ Diff.prototype = { } if (commonCount) { - basePath.components.push({ - count: commonCount - }); + basePath.lastComponent = { + count: commonCount, + previousComponent: basePath.lastComponent + }; } - basePath.newPos = newPos; - return oldPos; + basePath.oldPos = oldPos; + return newPos; }, equals: function equals(left, right) { if (this.options.comparator) { @@ -197,7 +238,20 @@ Diff.prototype = { } }; -function buildValues(diff, components, newString, oldString, useLongestToken) { +function buildValues(diff, lastComponent, newString, oldString, useLongestToken) { + // First we convert our linked list of components in reverse order to an + // array in the right order: + 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, @@ -240,23 +294,16 @@ function buildValues(diff, components, newString, oldString, useLongestToken) { // This is only available for string mode. - var lastComponent = components[componentLen - 1]; + var finalComponent = components[componentLen - 1]; - if (componentLen > 1 && typeof lastComponent.value === 'string' && (lastComponent.added || lastComponent.removed) && diff.equals('', lastComponent.value)) { - components[componentLen - 2].value += lastComponent.value; + if (componentLen > 1 && typeof finalComponent.value === 'string' && (finalComponent.added || finalComponent.removed) && diff.equals('', finalComponent.value)) { + components[componentLen - 2].value += finalComponent.value; components.pop(); } return components; } -function clonePath(path) { - return { - newPos: path.newPos, - components: path.components.slice(0) - }; -} - var characterDiff = new Diff(); function diffChars(oldStr, newStr, options) { return characterDiff.diff(oldStr, newStr, options); @@ -337,6 +384,11 @@ function diffWordsWithSpace(oldStr, newStr, options) { var lineDiff = new Diff(); lineDiff.tokenize = function (value) { + if (this.options.stripTrailingCr) { + // remove one \r before \n to match GNU diff's --strip-trailing-cr behavior + value = value.replace(/\r\n/g, '\n'); + } + var retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/); // Ignore the final empty token that occurs if the string ends with a new line @@ -408,6 +460,55 @@ function _typeof(obj) { return _typeof(obj); } +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +} + +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; +} + +function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; +} + function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); } @@ -840,7 +941,7 @@ function applyPatch(source, uniDiff) { var line = _hunk.lines[j], operation = line.length > 0 ? line[0] : ' ', content = line.length > 0 ? line.substr(1) : line, - delimiter = _hunk.linedelimiters[j]; + delimiter = _hunk.linedelimiters && _hunk.linedelimiters[j] || '\n'; if (operation === ' ') { _toPos++; @@ -1047,6 +1148,10 @@ function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, ne }; } function formatPatch(diff) { + if (Array.isArray(diff)) { + return diff.map(formatPatch).join('\n'); + } + var ret = []; if (diff.oldFileName == diff.newFileName) { @@ -1502,6 +1607,39 @@ function calcOldNewLineCount(lines) { }; } +function reversePatch(structuredPatch) { + if (Array.isArray(structuredPatch)) { + return structuredPatch.map(reversePatch).reverse(); + } + + return _objectSpread2(_objectSpread2({}, structuredPatch), {}, { + oldFileName: structuredPatch.newFileName, + oldHeader: structuredPatch.newHeader, + newFileName: structuredPatch.oldFileName, + newHeader: structuredPatch.oldHeader, + hunks: structuredPatch.hunks.map(function (hunk) { + return { + oldLines: hunk.newLines, + oldStart: hunk.newStart, + newLines: hunk.oldLines, + newStart: hunk.oldStart, + linedelimiters: hunk.linedelimiters, + lines: hunk.lines.map(function (l) { + if (l.startsWith('-')) { + return "+".concat(l.slice(1)); + } + + if (l.startsWith('+')) { + return "-".concat(l.slice(1)); + } + + return l; + }) + }; + }) + }); +} + // See: http://code.google.com/p/google-diff-match-patch/wiki/API function convertChangesToDMP(changes) { var ret = [], @@ -1558,4 +1696,4 @@ function escapeHTML(s) { return n; } -export { Diff, applyPatch, applyPatches, canonicalize, convertChangesToDMP, convertChangesToXML, createPatch, createTwoFilesPatch, diffArrays, diffChars, diffCss, diffJson, diffLines, diffSentences, diffTrimmedLines, diffWords, diffWordsWithSpace, merge, parsePatch, structuredPatch }; +export { Diff, applyPatch, applyPatches, canonicalize, convertChangesToDMP, convertChangesToXML, createPatch, createTwoFilesPatch, diffArrays, diffChars, diffCss, diffJson, diffLines, diffSentences, diffTrimmedLines, diffWords, diffWordsWithSpace, formatPatch, merge, parsePatch, reversePatch, structuredPatch }; diff --git a/node_modules/diff/lib/patch/apply.js b/node_modules/diff/lib/patch/apply.js index 21c76ddb76ba7..cefea04dae73b 100644 --- a/node_modules/diff/lib/patch/apply.js +++ b/node_modules/diff/lib/patch/apply.js @@ -148,7 +148,7 @@ function applyPatch(source, uniDiff) { var line = _hunk.lines[j], operation = line.length > 0 ? line[0] : ' ', content = line.length > 0 ? line.substr(1) : line, - delimiter = _hunk.linedelimiters[j]; + delimiter = _hunk.linedelimiters && _hunk.linedelimiters[j] || '\n'; if (operation === ' ') { _toPos++; @@ -235,4 +235,4 @@ function applyPatches(uniDiff, options) { processIndex(); } -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/patch/apply.js"],"names":["applyPatch","source","uniDiff","options","parsePatch","Array","isArray","length","Error","lines","split","delimiters","match","hunks","compareLine","lineNumber","line","operation","patchContent","errorCount","fuzzFactor","minLine","offset","removeEOFNL","addEOFNL","hunkFits","hunk","toPos","j","content","substr","i","maxLine","oldLines","localOffset","oldStart","iterator","distanceIterator","undefined","diffOffset","newLines","delimiter","linedelimiters","splice","previousOperation","pop","push","_k","join","applyPatches","currentIndex","processIndex","index","complete","loadFile","err","data","updatedContent","patched"],"mappings":"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","sourcesContent":["import {parsePatch} from './parse';\nimport distanceIterator from '../util/distance-iterator';\n\nexport function applyPatch(source, uniDiff, options = {}) {\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  }\n\n  // Apply the diff to the input\n  let 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\n      compareLine = options.compareLine || ((lineNumber, line, operation, patchContent) => line === patchContent),\n      errorCount = 0,\n      fuzzFactor = options.fuzzFactor || 0,\n      minLine = 0,\n      offset = 0,\n\n      removeEOFNL,\n      addEOFNL;\n\n  /**\n   * Checks if the hunk exactly fits on the provided location\n   */\n  function hunkFits(hunk, toPos) {\n    for (let j = 0; j < hunk.lines.length; j++) {\n      let 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        toPos++;\n      }\n    }\n\n    return true;\n  }\n\n  // Search best fit offsets for each hunk based on the previous ones\n  for (let i = 0; i < hunks.length; i++) {\n    let hunk = hunks[i],\n        maxLine = lines.length - hunk.oldLines,\n        localOffset = 0,\n        toPos = offset + hunk.oldStart - 1;\n\n    let 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    }\n\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    minLine = hunk.offset + hunk.oldStart + hunk.oldLines;\n  }\n\n  // Apply patch hunks\n  let diffOffset = 0;\n  for (let i = 0; i < hunks.length; i++) {\n    let hunk = hunks[i],\n        toPos = hunk.oldStart + hunk.offset + diffOffset - 1;\n    diffOffset += hunk.newLines - hunk.oldLines;\n\n    for (let j = 0; j < hunk.lines.length; j++) {\n      let line = hunk.lines[j],\n          operation = (line.length > 0 ? line[0] : ' '),\n          content = (line.length > 0 ? line.substr(1) : line),\n          delimiter = hunk.linedelimiters[j];\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        let previousOperation = hunk.lines[j - 1] ? hunk.lines[j - 1][0] : null;\n        if (previousOperation === '+') {\n          removeEOFNL = true;\n        } else if (previousOperation === '-') {\n          addEOFNL = true;\n        }\n      }\n    }\n  }\n\n  // Handle EOFNL insertion/removal\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  for (let _k = 0; _k < lines.length - 1; _k++) {\n    lines[_k] = lines[_k] + delimiters[_k];\n  }\n  return lines.join('');\n}\n\n// Wrapper that supports multiple file patches via callbacks.\nexport function applyPatches(uniDiff, options) {\n  if (typeof uniDiff === 'string') {\n    uniDiff = parsePatch(uniDiff);\n  }\n\n  let currentIndex = 0;\n  function processIndex() {\n    let index = uniDiff[currentIndex++];\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      let 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  processIndex();\n}\n"]} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/patch/apply.js"],"names":["applyPatch","source","uniDiff","options","parsePatch","Array","isArray","length","Error","lines","split","delimiters","match","hunks","compareLine","lineNumber","line","operation","patchContent","errorCount","fuzzFactor","minLine","offset","removeEOFNL","addEOFNL","hunkFits","hunk","toPos","j","content","substr","i","maxLine","oldLines","localOffset","oldStart","iterator","distanceIterator","undefined","diffOffset","newLines","delimiter","linedelimiters","splice","previousOperation","pop","push","_k","join","applyPatches","currentIndex","processIndex","index","complete","loadFile","err","data","updatedContent","patched"],"mappings":";;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;AACA;AAAA;AAAA;AAAA;AAAA;;;;;AAEO,SAASA,UAAT,CAAoBC,MAApB,EAA4BC,OAA5B,EAAmD;AAAA;AAAA;AAAA;AAAdC,EAAAA,OAAc,uEAAJ,EAAI;;AACxD,MAAI,OAAOD,OAAP,KAAmB,QAAvB,EAAiC;AAC/BA,IAAAA,OAAO;AAAG;AAAA;AAAA;;AAAAE;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAA;AAAA,KAAWF,OAAX,CAAV;AACD;;AAED,MAAIG,KAAK,CAACC,OAAN,CAAcJ,OAAd,CAAJ,EAA4B;AAC1B,QAAIA,OAAO,CAACK,MAAR,GAAiB,CAArB,EAAwB;AACtB,YAAM,IAAIC,KAAJ,CAAU,4CAAV,CAAN;AACD;;AAEDN,IAAAA,OAAO,GAAGA,OAAO,CAAC,CAAD,CAAjB;AACD,GAXuD,CAaxD;;;AACA,MAAIO,KAAK,GAAGR,MAAM,CAACS,KAAP,CAAa,qBAAb,CAAZ;AAAA,MACIC,UAAU,GAAGV,MAAM,CAACW,KAAP,CAAa,sBAAb,KAAwC,EADzD;AAAA,MAEIC,KAAK,GAAGX,OAAO,CAACW,KAFpB;AAAA,MAIIC,WAAW,GAAGX,OAAO,CAACW,WAAR,IAAwB,UAACC,UAAD,EAAaC,IAAb,EAAmBC,SAAnB,EAA8BC,YAA9B;AAAA;AAAA;AAAA;AAAA;AAA+CF,MAAAA,IAAI,KAAKE;AAAxD;AAAA,GAJ1C;AAAA,MAKIC,UAAU,GAAG,CALjB;AAAA,MAMIC,UAAU,GAAGjB,OAAO,CAACiB,UAAR,IAAsB,CANvC;AAAA,MAOIC,OAAO,GAAG,CAPd;AAAA,MAQIC,MAAM,GAAG,CARb;AAAA,MAUIC,WAVJ;AAAA,MAWIC,QAXJ;AAaA;;;;;AAGA,WAASC,QAAT,CAAkBC,IAAlB,EAAwBC,KAAxB,EAA+B;AAC7B,SAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGF,IAAI,CAACjB,KAAL,CAAWF,MAA/B,EAAuCqB,CAAC,EAAxC,EAA4C;AAC1C,UAAIZ,IAAI,GAAGU,IAAI,CAACjB,KAAL,CAAWmB,CAAX,CAAX;AAAA,UACIX,SAAS,GAAID,IAAI,CAACT,MAAL,GAAc,CAAd,GAAkBS,IAAI,CAAC,CAAD,CAAtB,GAA4B,GAD7C;AAAA,UAEIa,OAAO,GAAIb,IAAI,CAACT,MAAL,GAAc,CAAd,GAAkBS,IAAI,CAACc,MAAL,CAAY,CAAZ,CAAlB,GAAmCd,IAFlD;;AAIA,UAAIC,SAAS,KAAK,GAAd,IAAqBA,SAAS,KAAK,GAAvC,EAA4C;AAC1C;AACA,YAAI,CAACH,WAAW,CAACa,KAAK,GAAG,CAAT,EAAYlB,KAAK,CAACkB,KAAD,CAAjB,EAA0BV,SAA1B,EAAqCY,OAArC,CAAhB,EAA+D;AAC7DV,UAAAA,UAAU;;AAEV,cAAIA,UAAU,GAAGC,UAAjB,EAA6B;AAC3B,mBAAO,KAAP;AACD;AACF;;AACDO,QAAAA,KAAK;AACN;AACF;;AAED,WAAO,IAAP;AACD,GAlDuD,CAoDxD;;;AACA,OAAK,IAAII,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGlB,KAAK,CAACN,MAA1B,EAAkCwB,CAAC,EAAnC,EAAuC;AACrC,QAAIL,IAAI,GAAGb,KAAK,CAACkB,CAAD,CAAhB;AAAA,QACIC,OAAO,GAAGvB,KAAK,CAACF,MAAN,GAAemB,IAAI,CAACO,QADlC;AAAA,QAEIC,WAAW,GAAG,CAFlB;AAAA,QAGIP,KAAK,GAAGL,MAAM,GAAGI,IAAI,CAACS,QAAd,GAAyB,CAHrC;AAKA,QAAIC,QAAQ;AAAG;AAAA;AAAA;;AAAAC;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA,OAAiBV,KAAjB,EAAwBN,OAAxB,EAAiCW,OAAjC,CAAf;;AAEA,WAAOE,WAAW,KAAKI,SAAvB,EAAkCJ,WAAW,GAAGE,QAAQ,EAAxD,EAA4D;AAC1D,UAAIX,QAAQ,CAACC,IAAD,EAAOC,KAAK,GAAGO,WAAf,CAAZ,EAAyC;AACvCR,QAAAA,IAAI,CAACJ,MAAL,GAAcA,MAAM,IAAIY,WAAxB;AACA;AACD;AACF;;AAED,QAAIA,WAAW,KAAKI,SAApB,EAA+B;AAC7B,aAAO,KAAP;AACD,KAjBoC,CAmBrC;AACA;;;AACAjB,IAAAA,OAAO,GAAGK,IAAI,CAACJ,MAAL,GAAcI,IAAI,CAACS,QAAnB,GAA8BT,IAAI,CAACO,QAA7C;AACD,GA3EuD,CA6ExD;;;AACA,MAAIM,UAAU,GAAG,CAAjB;;AACA,OAAK,IAAIR,EAAC,GAAG,CAAb,EAAgBA,EAAC,GAAGlB,KAAK,CAACN,MAA1B,EAAkCwB,EAAC,EAAnC,EAAuC;AACrC,QAAIL,KAAI,GAAGb,KAAK,CAACkB,EAAD,CAAhB;AAAA,QACIJ,MAAK,GAAGD,KAAI,CAACS,QAAL,GAAgBT,KAAI,CAACJ,MAArB,GAA8BiB,UAA9B,GAA2C,CADvD;;AAEAA,IAAAA,UAAU,IAAIb,KAAI,CAACc,QAAL,GAAgBd,KAAI,CAACO,QAAnC;;AAEA,SAAK,IAAIL,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGF,KAAI,CAACjB,KAAL,CAAWF,MAA/B,EAAuCqB,CAAC,EAAxC,EAA4C;AAC1C,UAAIZ,IAAI,GAAGU,KAAI,CAACjB,KAAL,CAAWmB,CAAX,CAAX;AAAA,UACIX,SAAS,GAAID,IAAI,CAACT,MAAL,GAAc,CAAd,GAAkBS,IAAI,CAAC,CAAD,CAAtB,GAA4B,GAD7C;AAAA,UAEIa,OAAO,GAAIb,IAAI,CAACT,MAAL,GAAc,CAAd,GAAkBS,IAAI,CAACc,MAAL,CAAY,CAAZ,CAAlB,GAAmCd,IAFlD;AAAA,UAGIyB,SAAS,GAAGf,KAAI,CAACgB,cAAL,IAAuBhB,KAAI,CAACgB,cAAL,CAAoBd,CAApB,CAAvB,IAAiD,IAHjE;;AAKA,UAAIX,SAAS,KAAK,GAAlB,EAAuB;AACrBU,QAAAA,MAAK;AACN,OAFD,MAEO,IAAIV,SAAS,KAAK,GAAlB,EAAuB;AAC5BR,QAAAA,KAAK,CAACkC,MAAN,CAAahB,MAAb,EAAoB,CAApB;AACAhB,QAAAA,UAAU,CAACgC,MAAX,CAAkBhB,MAAlB,EAAyB,CAAzB;AACF;AACC,OAJM,MAIA,IAAIV,SAAS,KAAK,GAAlB,EAAuB;AAC5BR,QAAAA,KAAK,CAACkC,MAAN,CAAahB,MAAb,EAAoB,CAApB,EAAuBE,OAAvB;AACAlB,QAAAA,UAAU,CAACgC,MAAX,CAAkBhB,MAAlB,EAAyB,CAAzB,EAA4Bc,SAA5B;AACAd,QAAAA,MAAK;AACN,OAJM,MAIA,IAAIV,SAAS,KAAK,IAAlB,EAAwB;AAC7B,YAAI2B,iBAAiB,GAAGlB,KAAI,CAACjB,KAAL,CAAWmB,CAAC,GAAG,CAAf,IAAoBF,KAAI,CAACjB,KAAL,CAAWmB,CAAC,GAAG,CAAf,EAAkB,CAAlB,CAApB,GAA2C,IAAnE;;AACA,YAAIgB,iBAAiB,KAAK,GAA1B,EAA+B;AAC7BrB,UAAAA,WAAW,GAAG,IAAd;AACD,SAFD,MAEO,IAAIqB,iBAAiB,KAAK,GAA1B,EAA+B;AACpCpB,UAAAA,QAAQ,GAAG,IAAX;AACD;AACF;AACF;AACF,GA7GuD,CA+GxD;;;AACA,MAAID,WAAJ,EAAiB;AACf,WAAO,CAACd,KAAK,CAACA,KAAK,CAACF,MAAN,GAAe,CAAhB,CAAb,EAAiC;AAC/BE,MAAAA,KAAK,CAACoC,GAAN;AACAlC,MAAAA,UAAU,CAACkC,GAAX;AACD;AACF,GALD,MAKO,IAAIrB,QAAJ,EAAc;AACnBf,IAAAA,KAAK,CAACqC,IAAN,CAAW,EAAX;AACAnC,IAAAA,UAAU,CAACmC,IAAX,CAAgB,IAAhB;AACD;;AACD,OAAK,IAAIC,EAAE,GAAG,CAAd,EAAiBA,EAAE,GAAGtC,KAAK,CAACF,MAAN,GAAe,CAArC,EAAwCwC,EAAE,EAA1C,EAA8C;AAC5CtC,IAAAA,KAAK,CAACsC,EAAD,CAAL,GAAYtC,KAAK,CAACsC,EAAD,CAAL,GAAYpC,UAAU,CAACoC,EAAD,CAAlC;AACD;;AACD,SAAOtC,KAAK,CAACuC,IAAN,CAAW,EAAX,CAAP;AACD,C,CAED;;;AACO,SAASC,YAAT,CAAsB/C,OAAtB,EAA+BC,OAA/B,EAAwC;AAC7C,MAAI,OAAOD,OAAP,KAAmB,QAAvB,EAAiC;AAC/BA,IAAAA,OAAO;AAAG;AAAA;AAAA;;AAAAE;AAAAA;AAAAA;AAAAA;AAAAA;AAAAA;AAAA;AAAA,KAAWF,OAAX,CAAV;AACD;;AAED,MAAIgD,YAAY,GAAG,CAAnB;;AACA,WAASC,YAAT,GAAwB;AACtB,QAAIC,KAAK,GAAGlD,OAAO,CAACgD,YAAY,EAAb,CAAnB;;AACA,QAAI,CAACE,KAAL,EAAY;AACV,aAAOjD,OAAO,CAACkD,QAAR,EAAP;AACD;;AAEDlD,IAAAA,OAAO,CAACmD,QAAR,CAAiBF,KAAjB,EAAwB,UAASG,GAAT,EAAcC,IAAd,EAAoB;AAC1C,UAAID,GAAJ,EAAS;AACP,eAAOpD,OAAO,CAACkD,QAAR,CAAiBE,GAAjB,CAAP;AACD;;AAED,UAAIE,cAAc,GAAGzD,UAAU,CAACwD,IAAD,EAAOJ,KAAP,EAAcjD,OAAd,CAA/B;AACAA,MAAAA,OAAO,CAACuD,OAAR,CAAgBN,KAAhB,EAAuBK,cAAvB,EAAuC,UAASF,GAAT,EAAc;AACnD,YAAIA,GAAJ,EAAS;AACP,iBAAOpD,OAAO,CAACkD,QAAR,CAAiBE,GAAjB,CAAP;AACD;;AAEDJ,QAAAA,YAAY;AACb,OAND;AAOD,KAbD;AAcD;;AACDA,EAAAA,YAAY;AACb","sourcesContent":["import {parsePatch} from './parse';\nimport distanceIterator from '../util/distance-iterator';\n\nexport function applyPatch(source, uniDiff, options = {}) {\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  }\n\n  // Apply the diff to the input\n  let 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\n      compareLine = options.compareLine || ((lineNumber, line, operation, patchContent) => line === patchContent),\n      errorCount = 0,\n      fuzzFactor = options.fuzzFactor || 0,\n      minLine = 0,\n      offset = 0,\n\n      removeEOFNL,\n      addEOFNL;\n\n  /**\n   * Checks if the hunk exactly fits on the provided location\n   */\n  function hunkFits(hunk, toPos) {\n    for (let j = 0; j < hunk.lines.length; j++) {\n      let 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        toPos++;\n      }\n    }\n\n    return true;\n  }\n\n  // Search best fit offsets for each hunk based on the previous ones\n  for (let i = 0; i < hunks.length; i++) {\n    let hunk = hunks[i],\n        maxLine = lines.length - hunk.oldLines,\n        localOffset = 0,\n        toPos = offset + hunk.oldStart - 1;\n\n    let 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    }\n\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    minLine = hunk.offset + hunk.oldStart + hunk.oldLines;\n  }\n\n  // Apply patch hunks\n  let diffOffset = 0;\n  for (let i = 0; i < hunks.length; i++) {\n    let hunk = hunks[i],\n        toPos = hunk.oldStart + hunk.offset + diffOffset - 1;\n    diffOffset += hunk.newLines - hunk.oldLines;\n\n    for (let j = 0; j < hunk.lines.length; j++) {\n      let 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        let previousOperation = hunk.lines[j - 1] ? hunk.lines[j - 1][0] : null;\n        if (previousOperation === '+') {\n          removeEOFNL = true;\n        } else if (previousOperation === '-') {\n          addEOFNL = true;\n        }\n      }\n    }\n  }\n\n  // Handle EOFNL insertion/removal\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  for (let _k = 0; _k < lines.length - 1; _k++) {\n    lines[_k] = lines[_k] + delimiters[_k];\n  }\n  return lines.join('');\n}\n\n// Wrapper that supports multiple file patches via callbacks.\nexport function applyPatches(uniDiff, options) {\n  if (typeof uniDiff === 'string') {\n    uniDiff = parsePatch(uniDiff);\n  }\n\n  let currentIndex = 0;\n  function processIndex() {\n    let index = uniDiff[currentIndex++];\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      let 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  processIndex();\n}\n"]} diff --git a/node_modules/diff/lib/patch/create.js b/node_modules/diff/lib/patch/create.js index 1d3b4c303ce4b..45be1512a5a08 100644 --- a/node_modules/diff/lib/patch/create.js +++ b/node_modules/diff/lib/patch/create.js @@ -232,6 +232,10 @@ function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, ne } function formatPatch(diff) { + if (Array.isArray(diff)) { + return diff.map(formatPatch).join('\n'); + } + var ret = []; if (diff.oldFileName == diff.newFileName) { @@ -269,4 +273,4 @@ function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) { return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options); } -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/patch/create.js"],"names":["structuredPatch","oldFileName","newFileName","oldStr","newStr","oldHeader","newHeader","options","context","diff","diffLines","push","value","lines","contextLines","map","entry","hunks","oldRangeStart","newRangeStart","curRange","oldLine","newLine","i","current","replace","split","added","removed","prev","slice","length","contextSize","Math","min","hunk","oldStart","oldLines","newStart","newLines","oldEOFNewline","test","newEOFNewline","noNlBeforeAdds","splice","formatPatch","ret","apply","join","createTwoFilesPatch","createPatch","fileName"],"mappings":"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","sourcesContent":["import {diffLines} from '../diff/line';\n\nexport function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {\n  if (!options) {\n    options = {};\n  }\n  if (typeof options.context === 'undefined') {\n    options.context = 4;\n  }\n\n  const diff = diffLines(oldStr, newStr, options);\n  if(!diff) {\n    return;\n  }\n\n  diff.push({value: '', lines: []}); // Append an empty value to make cleanup easier\n\n  function contextLines(lines) {\n    return lines.map(function(entry) { return ' ' + entry; });\n  }\n\n  let hunks = [];\n  let oldRangeStart = 0, newRangeStart = 0, curRange = [],\n      oldLine = 1, newLine = 1;\n  for (let i = 0; i < diff.length; i++) {\n    const 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      // If we have previous context, start with that\n      if (!oldRangeStart) {\n        const 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      }\n\n      // Output our changes\n      curRange.push(... lines.map(function(entry) {\n        return (current.added ? '+' : '-') + entry;\n      }));\n\n      // Track the updated file position\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          // Overlapping\n          curRange.push(... contextLines(lines));\n        } else {\n          // end the range and output\n          let contextSize = Math.min(lines.length, options.context);\n          curRange.push(... contextLines(lines.slice(0, contextSize)));\n\n          let hunk = {\n            oldStart: oldRangeStart,\n            oldLines: (oldLine - oldRangeStart + contextSize),\n            newStart: newRangeStart,\n            newLines: (newLine - newRangeStart + contextSize),\n            lines: curRange\n          };\n          if (i >= diff.length - 2 && lines.length <= options.context) {\n            // EOF is inside this hunk\n            let oldEOFNewline = ((/\\n$/).test(oldStr));\n            let newEOFNewline = ((/\\n$/).test(newStr));\n            let noNlBeforeAdds = lines.length == 0 && curRange.length > hunk.oldLines;\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            if ((!oldEOFNewline && !noNlBeforeAdds) || !newEOFNewline) {\n              curRange.push('\\\\ No newline at end of file');\n            }\n          }\n          hunks.push(hunk);\n\n          oldRangeStart = 0;\n          newRangeStart = 0;\n          curRange = [];\n        }\n      }\n      oldLine += lines.length;\n      newLine += lines.length;\n    }\n  }\n\n  return {\n    oldFileName: oldFileName, newFileName: newFileName,\n    oldHeader: oldHeader, newHeader: newHeader,\n    hunks: hunks\n  };\n}\n\nexport function formatPatch(diff) {\n  const ret = [];\n  if (diff.oldFileName == diff.newFileName) {\n    ret.push('Index: ' + diff.oldFileName);\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 (let i = 0; i < diff.hunks.length; i++) {\n    const hunk = diff.hunks[i];\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    if (hunk.oldLines === 0) {\n      hunk.oldStart -= 1;\n    }\n    if (hunk.newLines === 0) {\n      hunk.newStart -= 1;\n    }\n    ret.push(\n      '@@ -' + hunk.oldStart + ',' + hunk.oldLines\n      + ' +' + hunk.newStart + ',' + hunk.newLines\n      + ' @@'\n    );\n    ret.push.apply(ret, hunk.lines);\n  }\n\n  return ret.join('\\n') + '\\n';\n}\n\nexport function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {\n  return formatPatch(structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options));\n}\n\nexport function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {\n  return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options);\n}\n"]} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/patch/create.js"],"names":["structuredPatch","oldFileName","newFileName","oldStr","newStr","oldHeader","newHeader","options","context","diff","diffLines","push","value","lines","contextLines","map","entry","hunks","oldRangeStart","newRangeStart","curRange","oldLine","newLine","i","current","replace","split","added","removed","prev","slice","length","contextSize","Math","min","hunk","oldStart","oldLines","newStart","newLines","oldEOFNewline","test","newEOFNewline","noNlBeforeAdds","splice","formatPatch","Array","isArray","join","ret","apply","createTwoFilesPatch","createPatch","fileName"],"mappings":"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","sourcesContent":["import {diffLines} from '../diff/line';\n\nexport function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {\n  if (!options) {\n    options = {};\n  }\n  if (typeof options.context === 'undefined') {\n    options.context = 4;\n  }\n\n  const diff = diffLines(oldStr, newStr, options);\n  if(!diff) {\n    return;\n  }\n\n  diff.push({value: '', lines: []}); // Append an empty value to make cleanup easier\n\n  function contextLines(lines) {\n    return lines.map(function(entry) { return ' ' + entry; });\n  }\n\n  let hunks = [];\n  let oldRangeStart = 0, newRangeStart = 0, curRange = [],\n      oldLine = 1, newLine = 1;\n  for (let i = 0; i < diff.length; i++) {\n    const 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      // If we have previous context, start with that\n      if (!oldRangeStart) {\n        const 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      }\n\n      // Output our changes\n      curRange.push(... lines.map(function(entry) {\n        return (current.added ? '+' : '-') + entry;\n      }));\n\n      // Track the updated file position\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          // Overlapping\n          curRange.push(... contextLines(lines));\n        } else {\n          // end the range and output\n          let contextSize = Math.min(lines.length, options.context);\n          curRange.push(... contextLines(lines.slice(0, contextSize)));\n\n          let hunk = {\n            oldStart: oldRangeStart,\n            oldLines: (oldLine - oldRangeStart + contextSize),\n            newStart: newRangeStart,\n            newLines: (newLine - newRangeStart + contextSize),\n            lines: curRange\n          };\n          if (i >= diff.length - 2 && lines.length <= options.context) {\n            // EOF is inside this hunk\n            let oldEOFNewline = ((/\\n$/).test(oldStr));\n            let newEOFNewline = ((/\\n$/).test(newStr));\n            let noNlBeforeAdds = lines.length == 0 && curRange.length > hunk.oldLines;\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            if ((!oldEOFNewline && !noNlBeforeAdds) || !newEOFNewline) {\n              curRange.push('\\\\ No newline at end of file');\n            }\n          }\n          hunks.push(hunk);\n\n          oldRangeStart = 0;\n          newRangeStart = 0;\n          curRange = [];\n        }\n      }\n      oldLine += lines.length;\n      newLine += lines.length;\n    }\n  }\n\n  return {\n    oldFileName: oldFileName, newFileName: newFileName,\n    oldHeader: oldHeader, newHeader: newHeader,\n    hunks: hunks\n  };\n}\n\nexport function formatPatch(diff) {\n  if (Array.isArray(diff)) {\n    return diff.map(formatPatch).join('\\n');\n  }\n\n  const ret = [];\n  if (diff.oldFileName == diff.newFileName) {\n    ret.push('Index: ' + diff.oldFileName);\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 (let i = 0; i < diff.hunks.length; i++) {\n    const hunk = diff.hunks[i];\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    if (hunk.oldLines === 0) {\n      hunk.oldStart -= 1;\n    }\n    if (hunk.newLines === 0) {\n      hunk.newStart -= 1;\n    }\n    ret.push(\n      '@@ -' + hunk.oldStart + ',' + hunk.oldLines\n      + ' +' + hunk.newStart + ',' + hunk.newLines\n      + ' @@'\n    );\n    ret.push.apply(ret, hunk.lines);\n  }\n\n  return ret.join('\\n') + '\\n';\n}\n\nexport function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {\n  return formatPatch(structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options));\n}\n\nexport function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {\n  return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options);\n}\n"]} diff --git a/node_modules/diff/lib/patch/reverse.js b/node_modules/diff/lib/patch/reverse.js new file mode 100644 index 0000000000000..6e4be99af8ac3 --- /dev/null +++ b/node_modules/diff/lib/patch/reverse.js @@ -0,0 +1,63 @@ +/*istanbul ignore start*/ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.reversePatch = reversePatch; + +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; } + +function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; } + +function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + +/*istanbul ignore end*/ +function reversePatch(structuredPatch) { + if (Array.isArray(structuredPatch)) { + return structuredPatch.map(reversePatch).reverse(); + } + + return ( + /*istanbul ignore start*/ + _objectSpread(_objectSpread({}, + /*istanbul ignore end*/ + structuredPatch), {}, { + oldFileName: structuredPatch.newFileName, + oldHeader: structuredPatch.newHeader, + newFileName: structuredPatch.oldFileName, + newHeader: structuredPatch.oldHeader, + hunks: structuredPatch.hunks.map(function (hunk) { + return { + oldLines: hunk.newLines, + oldStart: hunk.newStart, + newLines: hunk.oldLines, + newStart: hunk.oldStart, + linedelimiters: hunk.linedelimiters, + lines: hunk.lines.map(function (l) { + if (l.startsWith('-')) { + return ( + /*istanbul ignore start*/ + "+".concat( + /*istanbul ignore end*/ + l.slice(1)) + ); + } + + if (l.startsWith('+')) { + return ( + /*istanbul ignore start*/ + "-".concat( + /*istanbul ignore end*/ + l.slice(1)) + ); + } + + return l; + }) + }; + }) + }) + ); +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 diff --git a/node_modules/diff/package.json b/node_modules/diff/package.json index a2fc30c581218..dcffb9474baef 100644 --- a/node_modules/diff/package.json +++ b/node_modules/diff/package.json @@ -1,7 +1,7 @@ { "name": "diff", - "version": "5.1.0", - "description": "A javascript text diff implementation.", + "version": "5.2.0", + "description": "A JavaScript text diff implementation.", "keywords": [ "diff", "jsdiff", @@ -13,7 +13,8 @@ "javascript" ], "maintainers": [ - "Kevin Decker (http://incaseofstairs.com)" + "Kevin Decker (http://incaseofstairs.com)", + "Mark Amery " ], "bugs": { "email": "kpdecker@gmail.com", @@ -37,7 +38,8 @@ "require": "./lib/index.js" }, "./package.json": "./package.json", - "./": "./" + "./": "./", + "./*": "./*" }, "scripts": { "clean": "rm -rf lib/ dist/", @@ -50,10 +52,10 @@ "@babel/plugin-transform-modules-commonjs": "^7.2.0", "@babel/preset-env": "^7.2.3", "@babel/register": "^7.0.0", + "@colors/colors": "^1.3.3", "babel-eslint": "^10.0.1", "babel-loader": "^8.0.5", "chai": "^4.2.0", - "colors": "^1.3.3", "eslint": "^5.12.0", "grunt": "^1.0.3", "grunt-babel": "^8.0.0", @@ -69,7 +71,7 @@ "grunt-mocha-test": "^0.13.3", "grunt-webpack": "^3.1.3", "istanbul": "github:kpdecker/istanbul", - "karma": "^5.1.1", + "karma": "^6.3.16", "karma-chrome-launcher": "^3.1.0", "karma-mocha": "^2.0.1", "karma-mocha-reporter": "^2.0.0", diff --git a/node_modules/diff/release-notes.md b/node_modules/diff/release-notes.md index b7bc9c803b902..fe98f22d239e7 100644 --- a/node_modules/diff/release-notes.md +++ b/node_modules/diff/release-notes.md @@ -1,14 +1,22 @@ # Release Notes -## Development +## v5.2.0 -[Commits](https://github.com/kpdecker/jsdiff/compare/v5.0.0...master) +[Commits](https://github.com/kpdecker/jsdiff/compare/v5.1.0...master) + +- [#411](https://github.com/kpdecker/jsdiff/pull/411) Big performance improvement. Previously an O(n) array-copying operation inside the innermost loop of jsdiff's base diffing code increased the overall worst-case time complexity of computing a diff from O(n²) to O(n³). This is now fixed, bringing the worst-case time complexity down to what it theoretically should be for a Myers diff implementation. +- [#448](https://github.com/kpdecker/jsdiff/pull/411) Performance improvement. Diagonals whose furthest-reaching D-path would go off the edge of the edit graph are now skipped, rather than being pointlessly considered as called for by the original Myers diff algorithm. This dramatically speeds up computing diffs where the new text just appends or truncates content at the end of the old text. +- [#351](https://github.com/kpdecker/jsdiff/issues/351) Importing from the lib folder - e.g. `require("diff/lib/diff/word.js")` - will work again now. This had been broken for users on the latest version of Node since Node 17.5.0, which changed how Node interprets the `exports` property in jsdiff's `package.json` file. +- [#344](https://github.com/kpdecker/jsdiff/issues/344) `diffLines`, `createTwoFilesPatch`, and other patch-creation methods now take an optional `stripTrailingCr: true` option which causes Windows-style `\r\n` line endings to be replaced with Unix-style `\n` line endings before calculating the diff, just like GNU `diff`'s `--strip-trailing-cr` flag. +- [#451](https://github.com/kpdecker/jsdiff/pull/451) Added `diff.formatPatch`. +- [#450](https://github.com/kpdecker/jsdiff/pull/450) Added `diff.reversePatch`. +- [#478](https://github.com/kpdecker/jsdiff/pull/478) Added `timeout` option. ## v5.1.0 - [#365](https://github.com/kpdecker/jsdiff/issues/365) Allow early termination to limit execution time with degenerate cases -[Commits](https://github.com/kpdecker/jsdiff/compare/v5.0.0...v5.0.1) +[Commits](https://github.com/kpdecker/jsdiff/compare/v5.0.0...v5.1.0) ## v5.0.0 diff --git a/package-lock.json b/package-lock.json index cee7de47abd35..c3dd43bd2f791 100644 --- a/package-lock.json +++ b/package-lock.json @@ -174,7 +174,7 @@ "ajv": "^8.12.0", "ajv-formats": "^2.1.1", "ajv-formats-draft2019": "^1.6.1", - "diff": "^5.1.0", + "diff": "^5.2.0", "licensee": "^10.0.0", "nock": "^13.4.0", "npm-packlist": "^8.0.2", @@ -4209,9 +4209,9 @@ } }, "node_modules/diff": { - "version": "5.1.0", - "resolved": "https://registry.npmjs.org/diff/-/diff-5.1.0.tgz", - "integrity": "sha512-D+mk+qE8VC/PAUrlAU34N+VfXev0ghe5ywmpqrawphmVZc1bEfn56uo9qpyGp1p4xpzOHkSW4ztBd6L7Xx4ACw==", + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/diff/-/diff-5.2.0.tgz", + "integrity": "sha512-uIFDxqpRZGZ6ThOk84hEfqWoHx2devRFvpTZcTHur85vImfaxUbTW9Ryh4CpCuDnToOP1CEtXKIgytHBPVff5A==", "engines": { "node": ">=0.3.1" } diff --git a/package.json b/package.json index a8029469292c1..1d082680a89b0 100644 --- a/package.json +++ b/package.json @@ -205,7 +205,7 @@ "ajv": "^8.12.0", "ajv-formats": "^2.1.1", "ajv-formats-draft2019": "^1.6.1", - "diff": "^5.1.0", + "diff": "^5.2.0", "licensee": "^10.0.0", "nock": "^13.4.0", "npm-packlist": "^8.0.2",