5588 lines
No EOL
234 KiB
JavaScript
5588 lines
No EOL
234 KiB
JavaScript
/******/ (function(modules) { // webpackBootstrap
|
||
/******/ // The module cache
|
||
/******/ var installedModules = {};
|
||
|
||
/******/ // The require function
|
||
/******/ function __webpack_require__(moduleId) {
|
||
|
||
/******/ // Check if module is in cache
|
||
/******/ if(installedModules[moduleId])
|
||
/******/ return installedModules[moduleId].exports;
|
||
|
||
/******/ // Create a new module (and put it into the cache)
|
||
/******/ var module = installedModules[moduleId] = {
|
||
/******/ exports: {},
|
||
/******/ id: moduleId,
|
||
/******/ loaded: false
|
||
/******/ };
|
||
|
||
/******/ // Execute the module function
|
||
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
||
|
||
/******/ // Flag the module as loaded
|
||
/******/ module.loaded = true;
|
||
|
||
/******/ // Return the exports of the module
|
||
/******/ return module.exports;
|
||
/******/ }
|
||
|
||
|
||
/******/ // expose the modules object (__webpack_modules__)
|
||
/******/ __webpack_require__.m = modules;
|
||
|
||
/******/ // expose the module cache
|
||
/******/ __webpack_require__.c = installedModules;
|
||
|
||
/******/ // __webpack_public_path__
|
||
/******/ __webpack_require__.p = "";
|
||
|
||
/******/ // Load entry module and return exports
|
||
/******/ return __webpack_require__(0);
|
||
/******/ })
|
||
/************************************************************************/
|
||
/******/ ([
|
||
/* 0 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
/* WEBPACK VAR INJECTION */(function(global) {/*
|
||
*
|
||
* Diff to HTML (diff2html.js)
|
||
* Author: rtfpessoa
|
||
*
|
||
*/
|
||
|
||
(function() {
|
||
|
||
var diffParser = __webpack_require__(1).DiffParser;
|
||
var fileLister = __webpack_require__(3).FileListPrinter;
|
||
var htmlPrinter = __webpack_require__(21).HtmlPrinter;
|
||
|
||
function Diff2Html() {
|
||
}
|
||
|
||
/*
|
||
* Line diff type configuration
|
||
var config = {
|
||
'wordByWord': true, // (default)
|
||
// OR
|
||
'charByChar': true
|
||
};
|
||
*/
|
||
|
||
/*
|
||
* Generates json object from string diff input
|
||
*/
|
||
Diff2Html.prototype.getJsonFromDiff = function(diffInput, config) {
|
||
var configOrEmpty = config || {};
|
||
return diffParser.generateDiffJson(diffInput, configOrEmpty);
|
||
};
|
||
|
||
/*
|
||
* Generates the html diff. The config parameter configures the output/input formats and other options
|
||
*/
|
||
Diff2Html.prototype.getPrettyHtml = function(diffInput, config) {
|
||
var configOrEmpty = config || {};
|
||
|
||
var diffJson = diffInput;
|
||
if (!configOrEmpty.inputFormat || configOrEmpty.inputFormat === 'diff') {
|
||
diffJson = diffParser.generateDiffJson(diffInput, configOrEmpty);
|
||
}
|
||
|
||
var fileList = '';
|
||
if (configOrEmpty.showFiles === true) {
|
||
fileList = fileLister.generateFileList(diffJson, configOrEmpty);
|
||
}
|
||
|
||
var diffOutput = '';
|
||
if (configOrEmpty.outputFormat === 'side-by-side') {
|
||
diffOutput = htmlPrinter.generateSideBySideJsonHtml(diffJson, configOrEmpty);
|
||
} else {
|
||
diffOutput = htmlPrinter.generateLineByLineJsonHtml(diffJson, configOrEmpty);
|
||
}
|
||
|
||
return fileList + diffOutput;
|
||
};
|
||
|
||
|
||
/*
|
||
* Deprecated methods - The following methods exist only to maintain compatibility with previous versions
|
||
*/
|
||
|
||
/*
|
||
* Generates pretty html from string diff input
|
||
*/
|
||
Diff2Html.prototype.getPrettyHtmlFromDiff = function(diffInput, config) {
|
||
var configOrEmpty = config || {};
|
||
configOrEmpty.inputFormat = 'diff';
|
||
configOrEmpty.outputFormat = 'line-by-line';
|
||
return this.getPrettyHtml(diffInput, configOrEmpty);
|
||
};
|
||
|
||
/*
|
||
* Generates pretty html from a json object
|
||
*/
|
||
Diff2Html.prototype.getPrettyHtmlFromJson = function(diffJson, config) {
|
||
var configOrEmpty = config || {};
|
||
configOrEmpty.inputFormat = 'json';
|
||
configOrEmpty.outputFormat = 'line-by-line';
|
||
return this.getPrettyHtml(diffJson, configOrEmpty);
|
||
};
|
||
|
||
/*
|
||
* Generates pretty side by side html from string diff input
|
||
*/
|
||
Diff2Html.prototype.getPrettySideBySideHtmlFromDiff = function(diffInput, config) {
|
||
var configOrEmpty = config || {};
|
||
configOrEmpty.inputFormat = 'diff';
|
||
configOrEmpty.outputFormat = 'side-by-side';
|
||
return this.getPrettyHtml(diffInput, configOrEmpty);
|
||
};
|
||
|
||
/*
|
||
* Generates pretty side by side html from a json object
|
||
*/
|
||
Diff2Html.prototype.getPrettySideBySideHtmlFromJson = function(diffJson, config) {
|
||
var configOrEmpty = config || {};
|
||
configOrEmpty.inputFormat = 'json';
|
||
configOrEmpty.outputFormat = 'side-by-side';
|
||
return this.getPrettyHtml(diffJson, configOrEmpty);
|
||
};
|
||
|
||
var diffObject = new Diff2Html();
|
||
module.exports.Diff2Html = diffObject;
|
||
|
||
// Expose diff2html in the browser
|
||
global.Diff2Html = diffObject;
|
||
|
||
})();
|
||
|
||
/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
|
||
|
||
/***/ },
|
||
/* 1 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
/*
|
||
*
|
||
* Diff Parser (diff-parser.js)
|
||
* Author: rtfpessoa
|
||
*
|
||
*/
|
||
|
||
(function() {
|
||
|
||
var utils = __webpack_require__(2).Utils;
|
||
|
||
var LINE_TYPE = {
|
||
INSERTS: 'd2h-ins',
|
||
DELETES: 'd2h-del',
|
||
INSERT_CHANGES: 'd2h-ins d2h-change',
|
||
DELETE_CHANGES: 'd2h-del d2h-change',
|
||
CONTEXT: 'd2h-cntx',
|
||
INFO: 'd2h-info'
|
||
};
|
||
|
||
function DiffParser() {
|
||
}
|
||
|
||
DiffParser.prototype.LINE_TYPE = LINE_TYPE;
|
||
|
||
DiffParser.prototype.generateDiffJson = function(diffInput, config) {
|
||
var files = [];
|
||
var currentFile = null;
|
||
var currentBlock = null;
|
||
var oldLine = null;
|
||
var newLine = null;
|
||
|
||
var saveBlock = function() {
|
||
|
||
/* Add previous block(if exists) before start a new file */
|
||
if (currentBlock) {
|
||
currentFile.blocks.push(currentBlock);
|
||
currentBlock = null;
|
||
}
|
||
};
|
||
|
||
var saveFile = function() {
|
||
|
||
/*
|
||
* Add previous file(if exists) before start a new one
|
||
* if it has name (to avoid binary files errors)
|
||
*/
|
||
if (currentFile && currentFile.newName) {
|
||
files.push(currentFile);
|
||
currentFile = null;
|
||
}
|
||
};
|
||
|
||
var startFile = function() {
|
||
saveBlock();
|
||
saveFile();
|
||
|
||
/* Create file structure */
|
||
currentFile = {};
|
||
currentFile.blocks = [];
|
||
currentFile.deletedLines = 0;
|
||
currentFile.addedLines = 0;
|
||
};
|
||
|
||
var startBlock = function(line) {
|
||
saveBlock();
|
||
|
||
var values;
|
||
|
||
if (values = /^@@ -(\d+),\d+ \+(\d+),\d+ @@.*/.exec(line)) {
|
||
currentFile.isCombined = false;
|
||
} else if (values = /^@@@ -(\d+),\d+ -\d+,\d+ \+(\d+),\d+ @@@.*/.exec(line)) {
|
||
currentFile.isCombined = true;
|
||
} else {
|
||
values = [0, 0];
|
||
currentFile.isCombined = false;
|
||
}
|
||
|
||
oldLine = values[1];
|
||
newLine = values[2];
|
||
|
||
/* Create block metadata */
|
||
currentBlock = {};
|
||
currentBlock.lines = [];
|
||
currentBlock.oldStartLine = oldLine;
|
||
currentBlock.newStartLine = newLine;
|
||
currentBlock.header = line;
|
||
};
|
||
|
||
var createLine = function(line) {
|
||
var currentLine = {};
|
||
currentLine.content = line;
|
||
|
||
var newLinePrefixes = !currentFile.isCombined ? ['+'] : ['+', ' +'];
|
||
var delLinePrefixes = !currentFile.isCombined ? ['-'] : ['-', ' -'];
|
||
|
||
/* Fill the line data */
|
||
if (utils.startsWith(line, newLinePrefixes)) {
|
||
currentFile.addedLines++;
|
||
|
||
currentLine.type = LINE_TYPE.INSERTS;
|
||
currentLine.oldNumber = null;
|
||
currentLine.newNumber = newLine++;
|
||
|
||
currentBlock.lines.push(currentLine);
|
||
|
||
} else if (utils.startsWith(line, delLinePrefixes)) {
|
||
currentFile.deletedLines++;
|
||
|
||
currentLine.type = LINE_TYPE.DELETES;
|
||
currentLine.oldNumber = oldLine++;
|
||
currentLine.newNumber = null;
|
||
|
||
currentBlock.lines.push(currentLine);
|
||
|
||
} else {
|
||
currentLine.type = LINE_TYPE.CONTEXT;
|
||
currentLine.oldNumber = oldLine++;
|
||
currentLine.newNumber = newLine++;
|
||
|
||
currentBlock.lines.push(currentLine);
|
||
}
|
||
};
|
||
|
||
var diffLines =
|
||
diffInput.replace(/\\ No newline at end of file/g, '')
|
||
.replace(/\r\n?/g, '\n')
|
||
.split('\n');
|
||
|
||
/* Diff */
|
||
var oldMode = /^old mode (\d{6})/;
|
||
var newMode = /^new mode (\d{6})/;
|
||
var deletedFileMode = /^deleted file mode (\d{6})/;
|
||
var newFileMode = /^new file mode (\d{6})/;
|
||
|
||
var copyFrom = /^copy from "?(.+?)"?/;
|
||
var copyTo = /^copy to "?(.+?)"?/;
|
||
|
||
var renameFrom = /^rename from "?(.+?)"?/;
|
||
var renameTo = /^rename to "?(.+?)"?/;
|
||
|
||
var similarityIndex = /^similarity index (\d+)%/;
|
||
var dissimilarityIndex = /^dissimilarity index (\d+)%/;
|
||
var index = /^index ([0-9a-z]+)..([0-9a-z]+) (\d{6})?/;
|
||
|
||
/* Combined Diff */
|
||
var combinedIndex = /^index ([0-9a-z]+),([0-9a-z]+)..([0-9a-z]+)/;
|
||
var combinedMode = /^mode (\d{6}),(\d{6})..(\d{6})/;
|
||
var combinedNewFile = /^new file mode (\d{6})/;
|
||
var combinedDeletedFile = /^deleted file mode (\d{6}),(\d{6})/;
|
||
|
||
diffLines.forEach(function(line) {
|
||
// Unmerged paths, and possibly other non-diffable files
|
||
// https://github.com/scottgonzalez/pretty-diff/issues/11
|
||
// Also, remove some useless lines
|
||
if (!line || utils.startsWith(line, '*')) {
|
||
return;
|
||
}
|
||
|
||
var values = [];
|
||
if (utils.startsWith(line, 'diff')) {
|
||
startFile();
|
||
} else if (currentFile && !currentFile.oldName && (values = getSrcFilename(line, config))) {
|
||
currentFile.oldName = values;
|
||
currentFile.language = getExtension(currentFile.oldName, currentFile.language);
|
||
} else if (currentFile && !currentFile.newName && (values = getDstFilename(line, config))) {
|
||
currentFile.newName = values;
|
||
currentFile.language = getExtension(currentFile.newName, currentFile.language);
|
||
} else if (currentFile && utils.startsWith(line, '@@')) {
|
||
startBlock(line);
|
||
} else if ((values = oldMode.exec(line))) {
|
||
currentFile.oldMode = values[1];
|
||
} else if ((values = newMode.exec(line))) {
|
||
currentFile.newMode = values[1];
|
||
} else if ((values = deletedFileMode.exec(line))) {
|
||
currentFile.deletedFileMode = values[1];
|
||
} else if ((values = newFileMode.exec(line))) {
|
||
currentFile.newFileMode = values[1];
|
||
} else if ((values = copyFrom.exec(line))) {
|
||
currentFile.oldName = values[1];
|
||
currentFile.isCopy = true;
|
||
} else if ((values = copyTo.exec(line))) {
|
||
currentFile.newName = values[1];
|
||
currentFile.isCopy = true;
|
||
} else if ((values = renameFrom.exec(line))) {
|
||
currentFile.oldName = values[1];
|
||
currentFile.isRename = true;
|
||
} else if ((values = renameTo.exec(line))) {
|
||
currentFile.newName = values[1];
|
||
currentFile.isRename = true;
|
||
} else if ((values = similarityIndex.exec(line))) {
|
||
currentFile.unchangedPercentage = values[1];
|
||
} else if ((values = dissimilarityIndex.exec(line))) {
|
||
currentFile.changedPercentage = values[1];
|
||
} else if ((values = index.exec(line))) {
|
||
currentFile.checksumBefore = values[1];
|
||
currentFile.checksumAfter = values[2];
|
||
values[2] && (currentFile.mode = values[3]);
|
||
} else if ((values = combinedIndex.exec(line))) {
|
||
currentFile.checksumBefore = [values[2], values[3]];
|
||
currentFile.checksumAfter = values[1];
|
||
} else if ((values = combinedMode.exec(line))) {
|
||
currentFile.oldMode = [values[2], values[3]];
|
||
currentFile.newMode = values[1];
|
||
} else if ((values = combinedNewFile.exec(line))) {
|
||
currentFile.newFileMode = values[1];
|
||
} else if ((values = combinedDeletedFile.exec(line))) {
|
||
currentFile.deletedFileMode = values[1];
|
||
} else if (currentBlock) {
|
||
createLine(line);
|
||
}
|
||
});
|
||
|
||
saveBlock();
|
||
saveFile();
|
||
|
||
return files;
|
||
};
|
||
|
||
function getExtension(filename, language) {
|
||
var nameSplit = filename.split('.');
|
||
if (nameSplit.length > 1) {
|
||
return nameSplit[nameSplit.length - 1];
|
||
}
|
||
|
||
return language;
|
||
}
|
||
|
||
function getSrcFilename(line, cfg) {
|
||
var prefixes = ["a/", "i/", "w/", "c/", "o/"];
|
||
|
||
if (cfg.srcPrefix) prefixes.push(cfg.srcPrefix);
|
||
|
||
return _getFilename('---', line, prefixes);
|
||
}
|
||
|
||
function getDstFilename(line, cfg) {
|
||
var prefixes = ["b/", "i/", "w/", "c/", "o/"];
|
||
|
||
if (cfg.dstPrefix) prefixes.push(cfg.dstPrefix);
|
||
|
||
return _getFilename('\\+\\+\\+', line, prefixes);
|
||
}
|
||
|
||
function _getFilename(linePrefix, line, prefixes) {
|
||
var FilenameRegExp = new RegExp('^' + linePrefix + ' "?(.+?)"?$');
|
||
|
||
var filename;
|
||
var values = FilenameRegExp.exec(line);
|
||
if (values && values[1]) {
|
||
filename = values[1];
|
||
var matchingPrefixes = prefixes.filter(function(p) {
|
||
return filename.indexOf(p) === 0;
|
||
});
|
||
|
||
if (matchingPrefixes[0]) filename = filename.slice(matchingPrefixes[0].length); // remove prefix if exists
|
||
}
|
||
|
||
return filename;
|
||
}
|
||
|
||
module.exports.DiffParser = new DiffParser();
|
||
|
||
})();
|
||
|
||
|
||
/***/ },
|
||
/* 2 */
|
||
/***/ function(module, exports) {
|
||
|
||
/*
|
||
*
|
||
* Utils (utils.js)
|
||
* Author: rtfpessoa
|
||
*
|
||
*/
|
||
|
||
(function() {
|
||
|
||
function Utils() {
|
||
}
|
||
|
||
Utils.prototype.convertWhiteSpaceToNonBreakingSpace = function(str) {
|
||
return str.slice(0).replace(/ /g, ' ');
|
||
};
|
||
|
||
Utils.prototype.escape = function(str) {
|
||
return str.slice(0)
|
||
.replace(/&/g, '&')
|
||
.replace(/</g, '<')
|
||
.replace(/>/g, '>')
|
||
.replace(/\t/g, ' ');
|
||
};
|
||
|
||
Utils.prototype.startsWith = function(str, start) {
|
||
if (typeof start === 'object') {
|
||
var result = false;
|
||
start.forEach(function(s) {
|
||
if (str.indexOf(s) === 0) {
|
||
result = true;
|
||
}
|
||
});
|
||
|
||
return result;
|
||
}
|
||
|
||
return str.indexOf(start) === 0;
|
||
};
|
||
|
||
Utils.prototype.valueOrEmpty = function(value) {
|
||
return value ? value : '';
|
||
};
|
||
|
||
module.exports.Utils = new Utils();
|
||
|
||
})();
|
||
|
||
|
||
/***/ },
|
||
/* 3 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
/*
|
||
*
|
||
* FileListPrinter (file-list-printer.js)
|
||
* Author: nmatpt
|
||
*
|
||
*/
|
||
|
||
(function() {
|
||
|
||
var printerUtils = __webpack_require__(4).PrinterUtils;
|
||
|
||
function FileListPrinter() {
|
||
}
|
||
|
||
FileListPrinter.prototype.generateFileList = function(diffFiles) {
|
||
return '<div class="d2h-file-list-wrapper">\n' +
|
||
' <div class="d2h-file-list-header">\n' +
|
||
' <span class="d2h-file-list-title">Files changed (' + diffFiles.length + ')  </span>\n' +
|
||
' <a class="d2h-file-switch d2h-hide">hide</a>\n' +
|
||
' <a class="d2h-file-switch d2h-show">show</a>\n' +
|
||
' </div>\n' +
|
||
' <table class="d2h-file-list">\n' +
|
||
|
||
diffFiles.map(function(file) {
|
||
return ' <tr class="d2h-file-list-line">\n' +
|
||
' <td class="d2h-lines-added">\n' +
|
||
' <span>+' + file.addedLines + '</span>\n' +
|
||
' </td>\n' +
|
||
' <td class="d2h-lines-deleted">\n' +
|
||
' <span>-' + file.deletedLines + '</span>\n' +
|
||
' </td>\n' +
|
||
' <td class="d2h-file-name-wrapper">\n' +
|
||
' <a href="#' + printerUtils.getHtmlId(file) + '" class="d2h-file-name">' +
|
||
' ' + printerUtils.getDiffName(file) +
|
||
' </a>\n' +
|
||
' </td>\n' +
|
||
' </tr>\n';
|
||
}).join('\n') +
|
||
'</table></div>\n';
|
||
};
|
||
|
||
module.exports.FileListPrinter = new FileListPrinter();
|
||
|
||
})();
|
||
|
||
|
||
/***/ },
|
||
/* 4 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
/*
|
||
*
|
||
* PrinterUtils (printer-utils.js)
|
||
* Author: rtfpessoa
|
||
*
|
||
*/
|
||
|
||
(function() {
|
||
|
||
var jsDiff = __webpack_require__(5);
|
||
var utils = __webpack_require__(2).Utils;
|
||
var Rematch = __webpack_require__(20).Rematch;
|
||
|
||
function PrinterUtils() {
|
||
}
|
||
|
||
PrinterUtils.prototype.getHtmlId = function(file) {
|
||
var hashCode = function(text) {
|
||
var i, chr, len;
|
||
var hash = 0;
|
||
|
||
if (text.length === 0) {
|
||
return hash;
|
||
}
|
||
|
||
for (i = 0, len = text.length; i < len; i++) {
|
||
chr = text.charCodeAt(i);
|
||
hash = ((hash << 5) - hash) + chr;
|
||
hash |= 0; // Convert to 32bit integer
|
||
}
|
||
|
||
return hash;
|
||
};
|
||
|
||
return 'd2h-' + hashCode(this.getDiffName(file)).toString().slice(-6);
|
||
};
|
||
|
||
PrinterUtils.prototype.getDiffName = function(file) {
|
||
var oldFilename = file.oldName;
|
||
var newFilename = file.newName;
|
||
|
||
if (oldFilename && newFilename && oldFilename !== newFilename
|
||
&& !isDevNullName(oldFilename) && !isDevNullName(newFilename)) {
|
||
return oldFilename + ' -> ' + newFilename;
|
||
} else if (newFilename && !isDevNullName(newFilename)) {
|
||
return newFilename;
|
||
} else if (oldFilename) {
|
||
return oldFilename;
|
||
}
|
||
|
||
return 'Unknown filename';
|
||
};
|
||
|
||
PrinterUtils.prototype.diffHighlight = function(diffLine1, diffLine2, config) {
|
||
var linePrefix1, linePrefix2, unprefixedLine1, unprefixedLine2;
|
||
|
||
var prefixSize = 1;
|
||
|
||
if (config.isCombined) {
|
||
prefixSize = 2;
|
||
}
|
||
|
||
linePrefix1 = diffLine1.substr(0, prefixSize);
|
||
linePrefix2 = diffLine2.substr(0, prefixSize);
|
||
unprefixedLine1 = diffLine1.substr(prefixSize);
|
||
unprefixedLine2 = diffLine2.substr(prefixSize);
|
||
|
||
var diff;
|
||
if (config.charByChar) {
|
||
diff = jsDiff.diffChars(unprefixedLine1, unprefixedLine2);
|
||
} else {
|
||
diff = jsDiff.diffWordsWithSpace(unprefixedLine1, unprefixedLine2);
|
||
}
|
||
|
||
var highlightedLine = '';
|
||
|
||
var changedWords = [];
|
||
if (!config.charByChar && config.matching === 'words') {
|
||
var treshold = 0.25;
|
||
|
||
if (typeof (config.matchWordsThreshold) !== 'undefined') {
|
||
treshold = config.matchWordsThreshold;
|
||
}
|
||
|
||
var matcher = Rematch.rematch(function(a, b) {
|
||
var amod = a.value;
|
||
var bmod = b.value;
|
||
|
||
return Rematch.distance(amod, bmod);
|
||
});
|
||
|
||
var removed = diff.filter(function isRemoved(element) {
|
||
return element.removed;
|
||
});
|
||
|
||
var added = diff.filter(function isAdded(element) {
|
||
return element.added;
|
||
});
|
||
|
||
var chunks = matcher(added, removed);
|
||
chunks.forEach(function(chunk) {
|
||
if (chunk[0].length === 1 && chunk[1].length === 1) {
|
||
var dist = Rematch.distance(chunk[0][0].value, chunk[1][0].value);
|
||
if (dist < treshold) {
|
||
changedWords.push(chunk[0][0]);
|
||
changedWords.push(chunk[1][0]);
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
diff.forEach(function(part) {
|
||
var addClass = changedWords.indexOf(part) > -1 ? ' class="d2h-change"' : '';
|
||
var elemType = part.added ? 'ins' : part.removed ? 'del' : null;
|
||
var escapedValue = utils.escape(part.value);
|
||
|
||
if (elemType !== null) {
|
||
highlightedLine += '<' + elemType + addClass + '>' + escapedValue + '</' + elemType + '>';
|
||
} else {
|
||
highlightedLine += escapedValue;
|
||
}
|
||
});
|
||
|
||
return {
|
||
first: {
|
||
prefix: linePrefix1,
|
||
line: removeIns(highlightedLine)
|
||
},
|
||
second: {
|
||
prefix: linePrefix2,
|
||
line: removeDel(highlightedLine)
|
||
}
|
||
};
|
||
};
|
||
|
||
function isDevNullName(name) {
|
||
return name.indexOf('dev/null') !== -1;
|
||
}
|
||
|
||
function removeIns(line) {
|
||
return line.replace(/(<ins[^>]*>((.|\n)*?)<\/ins>)/g, '');
|
||
}
|
||
|
||
function removeDel(line) {
|
||
return line.replace(/(<del[^>]*>((.|\n)*?)<\/del>)/g, '');
|
||
}
|
||
|
||
module.exports.PrinterUtils = new PrinterUtils();
|
||
|
||
})();
|
||
|
||
|
||
/***/ },
|
||
/* 5 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
/*istanbul ignore start*/'use strict';
|
||
|
||
exports.__esModule = true;
|
||
exports.canonicalize = exports.convertChangesToXML = exports.convertChangesToDMP = exports.parsePatch = exports.applyPatches = exports.applyPatch = exports.createPatch = exports.createTwoFilesPatch = exports.structuredPatch = exports.diffJson = exports.diffCss = exports.diffSentences = exports.diffTrimmedLines = exports.diffLines = exports.diffWordsWithSpace = exports.diffWords = exports.diffChars = exports.Diff = undefined;
|
||
/*istanbul ignore end*/
|
||
var /*istanbul ignore start*/_base = __webpack_require__(6) /*istanbul ignore end*/;
|
||
|
||
/*istanbul ignore start*/
|
||
var _base2 = _interopRequireDefault(_base);
|
||
|
||
/*istanbul ignore end*/
|
||
var /*istanbul ignore start*/_character = __webpack_require__(7) /*istanbul ignore end*/;
|
||
|
||
var /*istanbul ignore start*/_word = __webpack_require__(8) /*istanbul ignore end*/;
|
||
|
||
var /*istanbul ignore start*/_line = __webpack_require__(10) /*istanbul ignore end*/;
|
||
|
||
var /*istanbul ignore start*/_sentence = __webpack_require__(11) /*istanbul ignore end*/;
|
||
|
||
var /*istanbul ignore start*/_css = __webpack_require__(12) /*istanbul ignore end*/;
|
||
|
||
var /*istanbul ignore start*/_json = __webpack_require__(13) /*istanbul ignore end*/;
|
||
|
||
var /*istanbul ignore start*/_apply = __webpack_require__(14) /*istanbul ignore end*/;
|
||
|
||
var /*istanbul ignore start*/_parse = __webpack_require__(15) /*istanbul ignore end*/;
|
||
|
||
var /*istanbul ignore start*/_create = __webpack_require__(17) /*istanbul ignore end*/;
|
||
|
||
var /*istanbul ignore start*/_dmp = __webpack_require__(18) /*istanbul ignore end*/;
|
||
|
||
var /*istanbul ignore start*/_xml = __webpack_require__(19) /*istanbul ignore end*/;
|
||
|
||
/*istanbul ignore start*/
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
/* See LICENSE file for terms of use */
|
||
|
||
/*
|
||
* Text diff implementation.
|
||
*
|
||
* This library supports the following APIS:
|
||
* JsDiff.diffChars: Character by character diff
|
||
* JsDiff.diffWords: Word (as defined by \b regex) diff which ignores whitespace
|
||
* JsDiff.diffLines: Line based diff
|
||
*
|
||
* JsDiff.diffCss: Diff targeted at CSS content
|
||
*
|
||
* These methods are based on the implementation proposed in
|
||
* "An O(ND) Difference Algorithm and its Variations" (Myers, 1986).
|
||
* http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.4.6927
|
||
*/
|
||
exports. /*istanbul ignore end*/Diff = _base2.default;
|
||
/*istanbul ignore start*/exports. /*istanbul ignore end*/diffChars = _character.diffChars;
|
||
/*istanbul ignore start*/exports. /*istanbul ignore end*/diffWords = _word.diffWords;
|
||
/*istanbul ignore start*/exports. /*istanbul ignore end*/diffWordsWithSpace = _word.diffWordsWithSpace;
|
||
/*istanbul ignore start*/exports. /*istanbul ignore end*/diffLines = _line.diffLines;
|
||
/*istanbul ignore start*/exports. /*istanbul ignore end*/diffTrimmedLines = _line.diffTrimmedLines;
|
||
/*istanbul ignore start*/exports. /*istanbul ignore end*/diffSentences = _sentence.diffSentences;
|
||
/*istanbul ignore start*/exports. /*istanbul ignore end*/diffCss = _css.diffCss;
|
||
/*istanbul ignore start*/exports. /*istanbul ignore end*/diffJson = _json.diffJson;
|
||
/*istanbul ignore start*/exports. /*istanbul ignore end*/structuredPatch = _create.structuredPatch;
|
||
/*istanbul ignore start*/exports. /*istanbul ignore end*/createTwoFilesPatch = _create.createTwoFilesPatch;
|
||
/*istanbul ignore start*/exports. /*istanbul ignore end*/createPatch = _create.createPatch;
|
||
/*istanbul ignore start*/exports. /*istanbul ignore end*/applyPatch = _apply.applyPatch;
|
||
/*istanbul ignore start*/exports. /*istanbul ignore end*/applyPatches = _apply.applyPatches;
|
||
/*istanbul ignore start*/exports. /*istanbul ignore end*/parsePatch = _parse.parsePatch;
|
||
/*istanbul ignore start*/exports. /*istanbul ignore end*/convertChangesToDMP = _dmp.convertChangesToDMP;
|
||
/*istanbul ignore start*/exports. /*istanbul ignore end*/convertChangesToXML = _xml.convertChangesToXML;
|
||
/*istanbul ignore start*/exports. /*istanbul ignore end*/canonicalize = _json.canonicalize;
|
||
//# sourceMappingURL=data:application/json;base64,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
|
||
|
||
|
||
/***/ },
|
||
/* 6 */
|
||
/***/ function(module, exports) {
|
||
|
||
/*istanbul ignore start*/'use strict';
|
||
|
||
exports.__esModule = true;
|
||
exports.default = /*istanbul ignore end*/Diff;
|
||
function Diff() {}
|
||
|
||
Diff.prototype = { /*istanbul ignore start*/
|
||
/*istanbul ignore end*/diff: function diff(oldString, newString) {
|
||
/*istanbul ignore start*/var /*istanbul ignore end*/options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
|
||
|
||
var callback = options.callback;
|
||
if (typeof options === 'function') {
|
||
callback = options;
|
||
options = {};
|
||
}
|
||
this.options = options;
|
||
|
||
var self = this;
|
||
|
||
function done(value) {
|
||
if (callback) {
|
||
setTimeout(function () {
|
||
callback(undefined, value);
|
||
}, 0);
|
||
return true;
|
||
} else {
|
||
return value;
|
||
}
|
||
}
|
||
|
||
// Allow subclasses to massage the input prior to running
|
||
oldString = this.castInput(oldString);
|
||
newString = this.castInput(newString);
|
||
|
||
oldString = this.removeEmpty(this.tokenize(oldString));
|
||
newString = this.removeEmpty(this.tokenize(newString));
|
||
|
||
var newLen = newString.length,
|
||
oldLen = oldString.length;
|
||
var editLength = 1;
|
||
var maxEditLength = newLen + oldLen;
|
||
var bestPath = [{ newPos: -1, components: [] }];
|
||
|
||
// Seed editLength = 0, i.e. the content starts with the same values
|
||
var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);
|
||
if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) {
|
||
// Identity per the equality and tokenizer
|
||
return done([{ value: newString.join(''), count: newString.length }]);
|
||
}
|
||
|
||
// Main worker method. checks all permutations of a given edit length for acceptance.
|
||
function execEditLength() {
|
||
for (var diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) {
|
||
var basePath = /*istanbul ignore start*/void 0 /*istanbul ignore end*/;
|
||
var addPath = bestPath[diagonalPath - 1],
|
||
removePath = bestPath[diagonalPath + 1],
|
||
_oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;
|
||
if (addPath) {
|
||
// 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;
|
||
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
|
||
// and does not pass the bounds of the diff graph
|
||
if (!canAdd || canRemove && addPath.newPos < removePath.newPos) {
|
||
basePath = clonePath(removePath);
|
||
self.pushComponent(basePath.components, undefined, true);
|
||
} else {
|
||
basePath = addPath; // No need to clone, we've pulled it from the list
|
||
basePath.newPos++;
|
||
self.pushComponent(basePath.components, true, undefined);
|
||
}
|
||
|
||
_oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath);
|
||
|
||
// If we have hit the end of both strings, then we are done
|
||
if (basePath.newPos + 1 >= newLen && _oldPos + 1 >= oldLen) {
|
||
return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken));
|
||
} else {
|
||
// Otherwise track this path as a potential candidate and continue.
|
||
bestPath[diagonalPath] = basePath;
|
||
}
|
||
}
|
||
|
||
editLength++;
|
||
}
|
||
|
||
// Performs the length of edit iteration. Is a bit fugly as this has to support the
|
||
// sync and async mode which is never fun. Loops over execEditLength until a value
|
||
// is produced.
|
||
if (callback) {
|
||
(function exec() {
|
||
setTimeout(function () {
|
||
// This should not happen, but we want to be safe.
|
||
/* istanbul ignore next */
|
||
if (editLength > maxEditLength) {
|
||
return callback();
|
||
}
|
||
|
||
if (!execEditLength()) {
|
||
exec();
|
||
}
|
||
}, 0);
|
||
})();
|
||
} else {
|
||
while (editLength <= maxEditLength) {
|
||
var ret = execEditLength();
|
||
if (ret) {
|
||
return ret;
|
||
}
|
||
}
|
||
}
|
||
},
|
||
/*istanbul ignore start*/ /*istanbul ignore end*/pushComponent: function pushComponent(components, added, removed) {
|
||
var last = components[components.length - 1];
|
||
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 };
|
||
} else {
|
||
components.push({ count: 1, added: added, removed: removed });
|
||
}
|
||
},
|
||
/*istanbul ignore start*/ /*istanbul ignore end*/extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) {
|
||
var newLen = newString.length,
|
||
oldLen = oldString.length,
|
||
newPos = basePath.newPos,
|
||
oldPos = newPos - diagonalPath,
|
||
commonCount = 0;
|
||
while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) {
|
||
newPos++;
|
||
oldPos++;
|
||
commonCount++;
|
||
}
|
||
|
||
if (commonCount) {
|
||
basePath.components.push({ count: commonCount });
|
||
}
|
||
|
||
basePath.newPos = newPos;
|
||
return oldPos;
|
||
},
|
||
/*istanbul ignore start*/ /*istanbul ignore end*/equals: function equals(left, right) {
|
||
return left === right;
|
||
},
|
||
/*istanbul ignore start*/ /*istanbul ignore end*/removeEmpty: function removeEmpty(array) {
|
||
var ret = [];
|
||
for (var i = 0; i < array.length; i++) {
|
||
if (array[i]) {
|
||
ret.push(array[i]);
|
||
}
|
||
}
|
||
return ret;
|
||
},
|
||
/*istanbul ignore start*/ /*istanbul ignore end*/castInput: function castInput(value) {
|
||
return value;
|
||
},
|
||
/*istanbul ignore start*/ /*istanbul ignore end*/tokenize: function tokenize(value) {
|
||
return value.split('');
|
||
}
|
||
};
|
||
|
||
function buildValues(diff, components, newString, oldString, useLongestToken) {
|
||
var componentPos = 0,
|
||
componentLen = components.length,
|
||
newPos = 0,
|
||
oldPos = 0;
|
||
|
||
for (; componentPos < componentLen; componentPos++) {
|
||
var component = components[componentPos];
|
||
if (!component.removed) {
|
||
if (!component.added && useLongestToken) {
|
||
var value = newString.slice(newPos, newPos + component.count);
|
||
value = value.map(function (value, i) {
|
||
var oldValue = oldString[oldPos + i];
|
||
return oldValue.length > value.length ? oldValue : value;
|
||
});
|
||
|
||
component.value = value.join('');
|
||
} else {
|
||
component.value = newString.slice(newPos, newPos + component.count).join('');
|
||
}
|
||
newPos += component.count;
|
||
|
||
// Common case
|
||
if (!component.added) {
|
||
oldPos += component.count;
|
||
}
|
||
} else {
|
||
component.value = oldString.slice(oldPos, oldPos + component.count).join('');
|
||
oldPos += component.count;
|
||
|
||
// Reverse add and remove so removes are output first to match common convention
|
||
// The diffing algorithm is tied to add then remove output and this is the simplest
|
||
// route to get the desired output with minimal overhead.
|
||
if (componentPos && components[componentPos - 1].added) {
|
||
var tmp = components[componentPos - 1];
|
||
components[componentPos - 1] = components[componentPos];
|
||
components[componentPos] = tmp;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Special case handle for when one terminal is ignored. For this case we merge the
|
||
// terminal into the prior string and drop the change.
|
||
var lastComponent = components[componentLen - 1];
|
||
if (componentLen > 1 && (lastComponent.added || lastComponent.removed) && diff.equals('', lastComponent.value)) {
|
||
components[componentLen - 2].value += lastComponent.value;
|
||
components.pop();
|
||
}
|
||
|
||
return components;
|
||
}
|
||
|
||
function clonePath(path) {
|
||
return { newPos: path.newPos, components: path.components.slice(0) };
|
||
}
|
||
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/diff/base.js"],"names":[],"mappings":"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","file":"base.js","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    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: newString.join(''), 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.\n    if (callback) {\n      (function exec() {\n        setTimeout(function() {\n          // This should not happen, but we want to be safe.\n          /* istanbul ignore next */\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    return left === right;\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};\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 = value.join('');\n      } else {\n        component.value = newString.slice(newPos, newPos + component.count).join('');\n      }\n      newPos += component.count;\n\n      // Common case\n      if (!component.added) {\n        oldPos += component.count;\n      }\n    } else {\n      component.value = oldString.slice(oldPos, oldPos + component.count).join('');\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. For this case we merge the\n  // terminal into the prior string and drop the change.\n  let lastComponent = components[componentLen - 1];\n  if (componentLen > 1\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"]}
|
||
|
||
|
||
/***/ },
|
||
/* 7 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
/*istanbul ignore start*/'use strict';
|
||
|
||
exports.__esModule = true;
|
||
exports.characterDiff = undefined;
|
||
exports. /*istanbul ignore end*/diffChars = diffChars;
|
||
|
||
var /*istanbul ignore start*/_base = __webpack_require__(6) /*istanbul ignore end*/;
|
||
|
||
/*istanbul ignore start*/
|
||
var _base2 = _interopRequireDefault(_base);
|
||
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
/*istanbul ignore end*/var characterDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/characterDiff = new /*istanbul ignore start*/_base2.default() /*istanbul ignore end*/;
|
||
function diffChars(oldStr, newStr, callback) {
|
||
return characterDiff.diff(oldStr, newStr, callback);
|
||
}
|
||
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kaWZmL2NoYXJhY3Rlci5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O2dDQUdnQjs7QUFIaEI7Ozs7Ozs7dUJBRU8sSUFBTSx5RkFBZ0IscUVBQWhCO0FBQ04sU0FBUyxTQUFULENBQW1CLE1BQW5CLEVBQTJCLE1BQTNCLEVBQW1DLFFBQW5DLEVBQTZDO0FBQUUsU0FBTyxjQUFjLElBQWQsQ0FBbUIsTUFBbkIsRUFBMkIsTUFBM0IsRUFBbUMsUUFBbkMsQ0FBUCxDQUFGO0NBQTdDIiwiZmlsZSI6ImNoYXJhY3Rlci5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBEaWZmIGZyb20gJy4vYmFzZSc7XG5cbmV4cG9ydCBjb25zdCBjaGFyYWN0ZXJEaWZmID0gbmV3IERpZmYoKTtcbmV4cG9ydCBmdW5jdGlvbiBkaWZmQ2hhcnMob2xkU3RyLCBuZXdTdHIsIGNhbGxiYWNrKSB7IHJldHVybiBjaGFyYWN0ZXJEaWZmLmRpZmYob2xkU3RyLCBuZXdTdHIsIGNhbGxiYWNrKTsgfVxuIl19
|
||
|
||
|
||
/***/ },
|
||
/* 8 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
/*istanbul ignore start*/'use strict';
|
||
|
||
exports.__esModule = true;
|
||
exports.wordDiff = undefined;
|
||
exports. /*istanbul ignore end*/diffWords = diffWords;
|
||
/*istanbul ignore start*/exports. /*istanbul ignore end*/diffWordsWithSpace = diffWordsWithSpace;
|
||
|
||
var /*istanbul ignore start*/_base = __webpack_require__(6) /*istanbul ignore end*/;
|
||
|
||
/*istanbul ignore start*/
|
||
var _base2 = _interopRequireDefault(_base);
|
||
|
||
/*istanbul ignore end*/
|
||
var /*istanbul ignore start*/_params = __webpack_require__(9) /*istanbul ignore end*/;
|
||
|
||
/*istanbul ignore start*/
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
/*istanbul ignore end*/
|
||
|
||
// Based on https://en.wikipedia.org/wiki/Latin_script_in_Unicode
|
||
//
|
||
// Ranges and exceptions:
|
||
// Latin-1 Supplement, 0080–00FF
|
||
// - U+00D7 × Multiplication sign
|
||
// - U+00F7 ÷ Division sign
|
||
// Latin Extended-A, 0100–017F
|
||
// Latin Extended-B, 0180–024F
|
||
// IPA Extensions, 0250–02AF
|
||
// Spacing Modifier Letters, 02B0–02FF
|
||
// - U+02C7 ˇ ˇ Caron
|
||
// - U+02D8 ˘ ˘ Breve
|
||
// - U+02D9 ˙ ˙ Dot Above
|
||
// - U+02DA ˚ ˚ Ring Above
|
||
// - U+02DB ˛ ˛ Ogonek
|
||
// - U+02DC ˜ ˜ Small Tilde
|
||
// - U+02DD ˝ ˝ Double Acute Accent
|
||
// Latin Extended Additional, 1E00–1EFF
|
||
var extendedWordChars = /^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/;
|
||
|
||
var reWhitespace = /\S/;
|
||
|
||
var wordDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/wordDiff = new /*istanbul ignore start*/_base2.default() /*istanbul ignore end*/;
|
||
wordDiff.equals = function (left, right) {
|
||
return left === right || this.options.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right);
|
||
};
|
||
wordDiff.tokenize = function (value) {
|
||
var tokens = value.split(/(\s+|\b)/);
|
||
|
||
// Join the boundary splits that we do not consider to be boundaries. This is primarily the extended Latin character set.
|
||
for (var i = 0; i < tokens.length - 1; i++) {
|
||
// If we have an empty string in the next field and we have only word chars before and after, merge
|
||
if (!tokens[i + 1] && tokens[i + 2] && extendedWordChars.test(tokens[i]) && extendedWordChars.test(tokens[i + 2])) {
|
||
tokens[i] += tokens[i + 2];
|
||
tokens.splice(i + 1, 2);
|
||
i--;
|
||
}
|
||
}
|
||
|
||
return tokens;
|
||
};
|
||
|
||
function diffWords(oldStr, newStr, callback) {
|
||
var options = /*istanbul ignore start*/(0, _params.generateOptions) /*istanbul ignore end*/(callback, { ignoreWhitespace: true });
|
||
return wordDiff.diff(oldStr, newStr, options);
|
||
}
|
||
function diffWordsWithSpace(oldStr, newStr, callback) {
|
||
return wordDiff.diff(oldStr, newStr, callback);
|
||
}
|
||
//# sourceMappingURL=data:application/json;base64,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
|
||
|
||
|
||
/***/ },
|
||
/* 9 */
|
||
/***/ function(module, exports) {
|
||
|
||
/*istanbul ignore start*/'use strict';
|
||
|
||
exports.__esModule = true;
|
||
exports. /*istanbul ignore end*/generateOptions = generateOptions;
|
||
function generateOptions(options, defaults) {
|
||
if (typeof options === 'function') {
|
||
defaults.callback = options;
|
||
} else if (options) {
|
||
for (var name in options) {
|
||
/* istanbul ignore else */
|
||
if (options.hasOwnProperty(name)) {
|
||
defaults[name] = options[name];
|
||
}
|
||
}
|
||
}
|
||
return defaults;
|
||
}
|
||
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlsL3BhcmFtcy5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Z0NBQWdCO0FBQVQsU0FBUyxlQUFULENBQXlCLE9BQXpCLEVBQWtDLFFBQWxDLEVBQTRDO0FBQ2pELE1BQUksT0FBTyxPQUFQLEtBQW1CLFVBQW5CLEVBQStCO0FBQ2pDLGFBQVMsUUFBVCxHQUFvQixPQUFwQixDQURpQztHQUFuQyxNQUVPLElBQUksT0FBSixFQUFhO0FBQ2xCLFNBQUssSUFBSSxJQUFKLElBQVksT0FBakIsRUFBMEI7O0FBRXhCLFVBQUksUUFBUSxjQUFSLENBQXVCLElBQXZCLENBQUosRUFBa0M7QUFDaEMsaUJBQVMsSUFBVCxJQUFpQixRQUFRLElBQVIsQ0FBakIsQ0FEZ0M7T0FBbEM7S0FGRjtHQURLO0FBUVAsU0FBTyxRQUFQLENBWGlEO0NBQTVDIiwiZmlsZSI6InBhcmFtcy5qcyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBmdW5jdGlvbiBnZW5lcmF0ZU9wdGlvbnMob3B0aW9ucywgZGVmYXVsdHMpIHtcbiAgaWYgKHR5cGVvZiBvcHRpb25zID09PSAnZnVuY3Rpb24nKSB7XG4gICAgZGVmYXVsdHMuY2FsbGJhY2sgPSBvcHRpb25zO1xuICB9IGVsc2UgaWYgKG9wdGlvbnMpIHtcbiAgICBmb3IgKGxldCBuYW1lIGluIG9wdGlvbnMpIHtcbiAgICAgIC8qIGlzdGFuYnVsIGlnbm9yZSBlbHNlICovXG4gICAgICBpZiAob3B0aW9ucy5oYXNPd25Qcm9wZXJ0eShuYW1lKSkge1xuICAgICAgICBkZWZhdWx0c1tuYW1lXSA9IG9wdGlvbnNbbmFtZV07XG4gICAgICB9XG4gICAgfVxuICB9XG4gIHJldHVybiBkZWZhdWx0cztcbn1cbiJdfQ==
|
||
|
||
|
||
/***/ },
|
||
/* 10 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
/*istanbul ignore start*/'use strict';
|
||
|
||
exports.__esModule = true;
|
||
exports.lineDiff = undefined;
|
||
exports. /*istanbul ignore end*/diffLines = diffLines;
|
||
/*istanbul ignore start*/exports. /*istanbul ignore end*/diffTrimmedLines = diffTrimmedLines;
|
||
|
||
var /*istanbul ignore start*/_base = __webpack_require__(6) /*istanbul ignore end*/;
|
||
|
||
/*istanbul ignore start*/
|
||
var _base2 = _interopRequireDefault(_base);
|
||
|
||
/*istanbul ignore end*/
|
||
var /*istanbul ignore start*/_params = __webpack_require__(9) /*istanbul ignore end*/;
|
||
|
||
/*istanbul ignore start*/
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
/*istanbul ignore end*/var lineDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/lineDiff = new /*istanbul ignore start*/_base2.default() /*istanbul ignore end*/;
|
||
lineDiff.tokenize = function (value) {
|
||
var retLines = [],
|
||
linesAndNewlines = value.split(/(\n|\r\n)/);
|
||
|
||
// Ignore the final empty token that occurs if the string ends with a new line
|
||
if (!linesAndNewlines[linesAndNewlines.length - 1]) {
|
||
linesAndNewlines.pop();
|
||
}
|
||
|
||
// Merge the content and line separators into single tokens
|
||
for (var i = 0; i < linesAndNewlines.length; i++) {
|
||
var line = linesAndNewlines[i];
|
||
|
||
if (i % 2 && !this.options.newlineIsToken) {
|
||
retLines[retLines.length - 1] += line;
|
||
} else {
|
||
if (this.options.ignoreWhitespace) {
|
||
line = line.trim();
|
||
}
|
||
retLines.push(line);
|
||
}
|
||
}
|
||
|
||
return retLines;
|
||
};
|
||
|
||
function diffLines(oldStr, newStr, callback) {
|
||
return lineDiff.diff(oldStr, newStr, callback);
|
||
}
|
||
function diffTrimmedLines(oldStr, newStr, callback) {
|
||
var options = /*istanbul ignore start*/(0, _params.generateOptions) /*istanbul ignore end*/(callback, { ignoreWhitespace: true });
|
||
return lineDiff.diff(oldStr, newStr, options);
|
||
}
|
||
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kaWZmL2xpbmUuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztnQ0E4QmdCO3lEQUNBOztBQS9CaEI7Ozs7OztBQUNBOzs7Ozt1QkFFTyxJQUFNLCtFQUFXLHFFQUFYO0FBQ2IsU0FBUyxRQUFULEdBQW9CLFVBQVMsS0FBVCxFQUFnQjtBQUNsQyxNQUFJLFdBQVcsRUFBWDtNQUNBLG1CQUFtQixNQUFNLEtBQU4sQ0FBWSxXQUFaLENBQW5COzs7QUFGOEIsTUFLOUIsQ0FBQyxpQkFBaUIsaUJBQWlCLE1BQWpCLEdBQTBCLENBQTFCLENBQWxCLEVBQWdEO0FBQ2xELHFCQUFpQixHQUFqQixHQURrRDtHQUFwRDs7O0FBTGtDLE9BVTdCLElBQUksSUFBSSxDQUFKLEVBQU8sSUFBSSxpQkFBaUIsTUFBakIsRUFBeUIsR0FBN0MsRUFBa0Q7QUFDaEQsUUFBSSxPQUFPLGlCQUFpQixDQUFqQixDQUFQLENBRDRDOztBQUdoRCxRQUFJLElBQUksQ0FBSixJQUFTLENBQUMsS0FBSyxPQUFMLENBQWEsY0FBYixFQUE2QjtBQUN6QyxlQUFTLFNBQVMsTUFBVCxHQUFrQixDQUFsQixDQUFULElBQWlDLElBQWpDLENBRHlDO0tBQTNDLE1BRU87QUFDTCxVQUFJLEtBQUssT0FBTCxDQUFhLGdCQUFiLEVBQStCO0FBQ2pDLGVBQU8sS0FBSyxJQUFMLEVBQVAsQ0FEaUM7T0FBbkM7QUFHQSxlQUFTLElBQVQsQ0FBYyxJQUFkLEVBSks7S0FGUDtHQUhGOztBQWFBLFNBQU8sUUFBUCxDQXZCa0M7Q0FBaEI7O0FBMEJiLFNBQVMsU0FBVCxDQUFtQixNQUFuQixFQUEyQixNQUEzQixFQUFtQyxRQUFuQyxFQUE2QztBQUFFLFNBQU8sU0FBUyxJQUFULENBQWMsTUFBZCxFQUFzQixNQUF0QixFQUE4QixRQUE5QixDQUFQLENBQUY7Q0FBN0M7QUFDQSxTQUFTLGdCQUFULENBQTBCLE1BQTFCLEVBQWtDLE1BQWxDLEVBQTBDLFFBQTFDLEVBQW9EO0FBQ3pELE1BQUksVUFBVSw4RUFBZ0IsUUFBaEIsRUFBMEIsRUFBQyxrQkFBa0IsSUFBbEIsRUFBM0IsQ0FBVixDQURxRDtBQUV6RCxTQUFPLFNBQVMsSUFBVCxDQUFjLE1BQWQsRUFBc0IsTUFBdEIsRUFBOEIsT0FBOUIsQ0FBUCxDQUZ5RDtDQUFwRCIsImZpbGUiOiJsaW5lLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IERpZmYgZnJvbSAnLi9iYXNlJztcbmltcG9ydCB7Z2VuZXJhdGVPcHRpb25zfSBmcm9tICcuLi91dGlsL3BhcmFtcyc7XG5cbmV4cG9ydCBjb25zdCBsaW5lRGlmZiA9IG5ldyBEaWZmKCk7XG5saW5lRGlmZi50b2tlbml6ZSA9IGZ1bmN0aW9uKHZhbHVlKSB7XG4gIGxldCByZXRMaW5lcyA9IFtdLFxuICAgICAgbGluZXNBbmROZXdsaW5lcyA9IHZhbHVlLnNwbGl0KC8oXFxufFxcclxcbikvKTtcblxuICAvLyBJZ25vcmUgdGhlIGZpbmFsIGVtcHR5IHRva2VuIHRoYXQgb2NjdXJzIGlmIHRoZSBzdHJpbmcgZW5kcyB3aXRoIGEgbmV3IGxpbmVcbiAgaWYgKCFsaW5lc0FuZE5ld2xpbmVzW2xpbmVzQW5kTmV3bGluZXMubGVuZ3RoIC0gMV0pIHtcbiAgICBsaW5lc0FuZE5ld2xpbmVzLnBvcCgpO1xuICB9XG5cbiAgLy8gTWVyZ2UgdGhlIGNvbnRlbnQgYW5kIGxpbmUgc2VwYXJhdG9ycyBpbnRvIHNpbmdsZSB0b2tlbnNcbiAgZm9yIChsZXQgaSA9IDA7IGkgPCBsaW5lc0FuZE5ld2xpbmVzLmxlbmd0aDsgaSsrKSB7XG4gICAgbGV0IGxpbmUgPSBsaW5lc0FuZE5ld2xpbmVzW2ldO1xuXG4gICAgaWYgKGkgJSAyICYmICF0aGlzLm9wdGlvbnMubmV3bGluZUlzVG9rZW4pIHtcbiAgICAgIHJldExpbmVzW3JldExpbmVzLmxlbmd0aCAtIDFdICs9IGxpbmU7XG4gICAgfSBlbHNlIHtcbiAgICAgIGlmICh0aGlzLm9wdGlvbnMuaWdub3JlV2hpdGVzcGFjZSkge1xuICAgICAgICBsaW5lID0gbGluZS50cmltKCk7XG4gICAgICB9XG4gICAgICByZXRMaW5lcy5wdXNoKGxpbmUpO1xuICAgIH1cbiAgfVxuXG4gIHJldHVybiByZXRMaW5lcztcbn07XG5cbmV4cG9ydCBmdW5jdGlvbiBkaWZmTGluZXMob2xkU3RyLCBuZXdTdHIsIGNhbGxiYWNrKSB7IHJldHVybiBsaW5lRGlmZi5kaWZmKG9sZFN0ciwgbmV3U3RyLCBjYWxsYmFjayk7IH1cbmV4cG9ydCBmdW5jdGlvbiBkaWZmVHJpbW1lZExpbmVzKG9sZFN0ciwgbmV3U3RyLCBjYWxsYmFjaykge1xuICBsZXQgb3B0aW9ucyA9IGdlbmVyYXRlT3B0aW9ucyhjYWxsYmFjaywge2lnbm9yZVdoaXRlc3BhY2U6IHRydWV9KTtcbiAgcmV0dXJuIGxpbmVEaWZmLmRpZmYob2xkU3RyLCBuZXdTdHIsIG9wdGlvbnMpO1xufVxuIl19
|
||
|
||
|
||
/***/ },
|
||
/* 11 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
/*istanbul ignore start*/'use strict';
|
||
|
||
exports.__esModule = true;
|
||
exports.sentenceDiff = undefined;
|
||
exports. /*istanbul ignore end*/diffSentences = diffSentences;
|
||
|
||
var /*istanbul ignore start*/_base = __webpack_require__(6) /*istanbul ignore end*/;
|
||
|
||
/*istanbul ignore start*/
|
||
var _base2 = _interopRequireDefault(_base);
|
||
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
/*istanbul ignore end*/var sentenceDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/sentenceDiff = new /*istanbul ignore start*/_base2.default() /*istanbul ignore end*/;
|
||
sentenceDiff.tokenize = function (value) {
|
||
return value.split(/(\S.+?[.!?])(?=\s+|$)/);
|
||
};
|
||
|
||
function diffSentences(oldStr, newStr, callback) {
|
||
return sentenceDiff.diff(oldStr, newStr, callback);
|
||
}
|
||
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kaWZmL3NlbnRlbmNlLmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Z0NBUWdCOztBQVJoQjs7Ozs7Ozt1QkFHTyxJQUFNLHVGQUFlLHFFQUFmO0FBQ2IsYUFBYSxRQUFiLEdBQXdCLFVBQVMsS0FBVCxFQUFnQjtBQUN0QyxTQUFPLE1BQU0sS0FBTixDQUFZLHVCQUFaLENBQVAsQ0FEc0M7Q0FBaEI7O0FBSWpCLFNBQVMsYUFBVCxDQUF1QixNQUF2QixFQUErQixNQUEvQixFQUF1QyxRQUF2QyxFQUFpRDtBQUFFLFNBQU8sYUFBYSxJQUFiLENBQWtCLE1BQWxCLEVBQTBCLE1BQTFCLEVBQWtDLFFBQWxDLENBQVAsQ0FBRjtDQUFqRCIsImZpbGUiOiJzZW50ZW5jZS5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBEaWZmIGZyb20gJy4vYmFzZSc7XG5cblxuZXhwb3J0IGNvbnN0IHNlbnRlbmNlRGlmZiA9IG5ldyBEaWZmKCk7XG5zZW50ZW5jZURpZmYudG9rZW5pemUgPSBmdW5jdGlvbih2YWx1ZSkge1xuICByZXR1cm4gdmFsdWUuc3BsaXQoLyhcXFMuKz9bLiE/XSkoPz1cXHMrfCQpLyk7XG59O1xuXG5leHBvcnQgZnVuY3Rpb24gZGlmZlNlbnRlbmNlcyhvbGRTdHIsIG5ld1N0ciwgY2FsbGJhY2spIHsgcmV0dXJuIHNlbnRlbmNlRGlmZi5kaWZmKG9sZFN0ciwgbmV3U3RyLCBjYWxsYmFjayk7IH1cbiJdfQ==
|
||
|
||
|
||
/***/ },
|
||
/* 12 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
/*istanbul ignore start*/'use strict';
|
||
|
||
exports.__esModule = true;
|
||
exports.cssDiff = undefined;
|
||
exports. /*istanbul ignore end*/diffCss = diffCss;
|
||
|
||
var /*istanbul ignore start*/_base = __webpack_require__(6) /*istanbul ignore end*/;
|
||
|
||
/*istanbul ignore start*/
|
||
var _base2 = _interopRequireDefault(_base);
|
||
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
/*istanbul ignore end*/var cssDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/cssDiff = new /*istanbul ignore start*/_base2.default() /*istanbul ignore end*/;
|
||
cssDiff.tokenize = function (value) {
|
||
return value.split(/([{}:;,]|\s+)/);
|
||
};
|
||
|
||
function diffCss(oldStr, newStr, callback) {
|
||
return cssDiff.diff(oldStr, newStr, callback);
|
||
}
|
||
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kaWZmL2Nzcy5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O2dDQU9nQjs7QUFQaEI7Ozs7Ozs7dUJBRU8sSUFBTSw2RUFBVSxxRUFBVjtBQUNiLFFBQVEsUUFBUixHQUFtQixVQUFTLEtBQVQsRUFBZ0I7QUFDakMsU0FBTyxNQUFNLEtBQU4sQ0FBWSxlQUFaLENBQVAsQ0FEaUM7Q0FBaEI7O0FBSVosU0FBUyxPQUFULENBQWlCLE1BQWpCLEVBQXlCLE1BQXpCLEVBQWlDLFFBQWpDLEVBQTJDO0FBQUUsU0FBTyxRQUFRLElBQVIsQ0FBYSxNQUFiLEVBQXFCLE1BQXJCLEVBQTZCLFFBQTdCLENBQVAsQ0FBRjtDQUEzQyIsImZpbGUiOiJjc3MuanMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgRGlmZiBmcm9tICcuL2Jhc2UnO1xuXG5leHBvcnQgY29uc3QgY3NzRGlmZiA9IG5ldyBEaWZmKCk7XG5jc3NEaWZmLnRva2VuaXplID0gZnVuY3Rpb24odmFsdWUpIHtcbiAgcmV0dXJuIHZhbHVlLnNwbGl0KC8oW3t9OjssXXxcXHMrKS8pO1xufTtcblxuZXhwb3J0IGZ1bmN0aW9uIGRpZmZDc3Mob2xkU3RyLCBuZXdTdHIsIGNhbGxiYWNrKSB7IHJldHVybiBjc3NEaWZmLmRpZmYob2xkU3RyLCBuZXdTdHIsIGNhbGxiYWNrKTsgfVxuIl19
|
||
|
||
|
||
/***/ },
|
||
/* 13 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
/*istanbul ignore start*/'use strict';
|
||
|
||
exports.__esModule = true;
|
||
exports.jsonDiff = undefined;
|
||
|
||
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
|
||
|
||
exports. /*istanbul ignore end*/diffJson = diffJson;
|
||
/*istanbul ignore start*/exports. /*istanbul ignore end*/canonicalize = canonicalize;
|
||
|
||
var /*istanbul ignore start*/_base = __webpack_require__(6) /*istanbul ignore end*/;
|
||
|
||
/*istanbul ignore start*/
|
||
var _base2 = _interopRequireDefault(_base);
|
||
|
||
/*istanbul ignore end*/
|
||
var /*istanbul ignore start*/_line = __webpack_require__(10) /*istanbul ignore end*/;
|
||
|
||
/*istanbul ignore start*/
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
/*istanbul ignore end*/
|
||
|
||
var objectPrototypeToString = Object.prototype.toString;
|
||
|
||
var jsonDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/jsonDiff = new /*istanbul ignore start*/_base2.default() /*istanbul ignore end*/;
|
||
// Discriminate between two lines of pretty-printed, serialized JSON where one of them has a
|
||
// dangling comma and the other doesn't. Turns out including the dangling comma yields the nicest output:
|
||
jsonDiff.useLongestToken = true;
|
||
|
||
jsonDiff.tokenize = /*istanbul ignore start*/_line.lineDiff. /*istanbul ignore end*/tokenize;
|
||
jsonDiff.castInput = function (value) {
|
||
return typeof value === 'string' ? value : JSON.stringify(canonicalize(value), undefined, ' ');
|
||
};
|
||
jsonDiff.equals = function (left, right) {
|
||
return (/*istanbul ignore start*/_base2.default. /*istanbul ignore end*/prototype.equals(left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1'))
|
||
);
|
||
};
|
||
|
||
function diffJson(oldObj, newObj, callback) {
|
||
return jsonDiff.diff(oldObj, newObj, callback);
|
||
}
|
||
|
||
// This function handles the presence of circular references by bailing out when encountering an
|
||
// object that is already on the "stack" of items being processed.
|
||
function canonicalize(obj, stack, replacementStack) {
|
||
stack = stack || [];
|
||
replacementStack = replacementStack || [];
|
||
|
||
var i = /*istanbul ignore start*/void 0 /*istanbul ignore end*/;
|
||
|
||
for (i = 0; i < stack.length; i += 1) {
|
||
if (stack[i] === obj) {
|
||
return replacementStack[i];
|
||
}
|
||
}
|
||
|
||
var canonicalizedObj = /*istanbul ignore start*/void 0 /*istanbul ignore end*/;
|
||
|
||
if ('[object Array]' === objectPrototypeToString.call(obj)) {
|
||
stack.push(obj);
|
||
canonicalizedObj = new Array(obj.length);
|
||
replacementStack.push(canonicalizedObj);
|
||
for (i = 0; i < obj.length; i += 1) {
|
||
canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack);
|
||
}
|
||
stack.pop();
|
||
replacementStack.pop();
|
||
return canonicalizedObj;
|
||
}
|
||
|
||
if (obj && obj.toJSON) {
|
||
obj = obj.toJSON();
|
||
}
|
||
|
||
if ( /*istanbul ignore start*/(typeof /*istanbul ignore end*/obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object' && obj !== null) {
|
||
stack.push(obj);
|
||
canonicalizedObj = {};
|
||
replacementStack.push(canonicalizedObj);
|
||
var sortedKeys = [],
|
||
key = /*istanbul ignore start*/void 0 /*istanbul ignore end*/;
|
||
for (key in obj) {
|
||
/* istanbul ignore else */
|
||
if (obj.hasOwnProperty(key)) {
|
||
sortedKeys.push(key);
|
||
}
|
||
}
|
||
sortedKeys.sort();
|
||
for (i = 0; i < sortedKeys.length; i += 1) {
|
||
key = sortedKeys[i];
|
||
canonicalizedObj[key] = canonicalize(obj[key], stack, replacementStack);
|
||
}
|
||
stack.pop();
|
||
replacementStack.pop();
|
||
} else {
|
||
canonicalizedObj = obj;
|
||
}
|
||
return canonicalizedObj;
|
||
}
|
||
//# sourceMappingURL=data:application/json;base64,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
|
||
|
||
|
||
/***/ },
|
||
/* 14 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
/*istanbul ignore start*/'use strict';
|
||
|
||
exports.__esModule = true;
|
||
exports. /*istanbul ignore end*/applyPatch = applyPatch;
|
||
/*istanbul ignore start*/exports. /*istanbul ignore end*/applyPatches = applyPatches;
|
||
|
||
var /*istanbul ignore start*/_parse = __webpack_require__(15) /*istanbul ignore end*/;
|
||
|
||
var /*istanbul ignore start*/_distanceIterator = __webpack_require__(16) /*istanbul ignore end*/;
|
||
|
||
/*istanbul ignore start*/
|
||
var _distanceIterator2 = _interopRequireDefault(_distanceIterator);
|
||
|
||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||
|
||
/*istanbul ignore end*/function applyPatch(source, uniDiff) {
|
||
/*istanbul ignore start*/var /*istanbul ignore end*/options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
|
||
|
||
if (typeof uniDiff === 'string') {
|
||
uniDiff = /*istanbul ignore start*/(0, _parse.parsePatch) /*istanbul ignore end*/(uniDiff);
|
||
}
|
||
|
||
if (Array.isArray(uniDiff)) {
|
||
if (uniDiff.length > 1) {
|
||
throw new Error('applyPatch only works with a single input.');
|
||
}
|
||
|
||
uniDiff = uniDiff[0];
|
||
}
|
||
|
||
// Apply the diff to the input
|
||
var lines = source.split('\n'),
|
||
hunks = uniDiff.hunks,
|
||
compareLine = options.compareLine || function (lineNumber, line, operation, patchContent) /*istanbul ignore start*/{
|
||
return (/*istanbul ignore end*/line === patchContent
|
||
);
|
||
},
|
||
errorCount = 0,
|
||
fuzzFactor = options.fuzzFactor || 0,
|
||
minLine = 0,
|
||
offset = 0,
|
||
removeEOFNL = /*istanbul ignore start*/void 0 /*istanbul ignore end*/,
|
||
addEOFNL = /*istanbul ignore start*/void 0 /*istanbul ignore end*/;
|
||
|
||
/**
|
||
* Checks if the hunk exactly fits on the provided location
|
||
*/
|
||
function hunkFits(hunk, toPos) {
|
||
for (var j = 0; j < hunk.lines.length; j++) {
|
||
var line = hunk.lines[j],
|
||
operation = line[0],
|
||
content = line.substr(1);
|
||
|
||
if (operation === ' ' || operation === '-') {
|
||
// Context sanity check
|
||
if (!compareLine(toPos + 1, lines[toPos], operation, content)) {
|
||
errorCount++;
|
||
|
||
if (errorCount > fuzzFactor) {
|
||
return false;
|
||
}
|
||
}
|
||
toPos++;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
// Search best fit offsets for each hunk based on the previous ones
|
||
for (var i = 0; i < hunks.length; i++) {
|
||
var hunk = hunks[i],
|
||
maxLine = lines.length - hunk.oldLines,
|
||
localOffset = 0,
|
||
toPos = offset + hunk.oldStart - 1;
|
||
|
||
var iterator = /*istanbul ignore start*/(0, _distanceIterator2.default) /*istanbul ignore end*/(toPos, minLine, maxLine);
|
||
|
||
for (; localOffset !== undefined; localOffset = iterator()) {
|
||
if (hunkFits(hunk, toPos + localOffset)) {
|
||
hunk.offset = offset += localOffset;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (localOffset === undefined) {
|
||
return false;
|
||
}
|
||
|
||
// Set lower text limit to end of the current hunk, so next ones don't try
|
||
// to fit over already patched text
|
||
minLine = hunk.offset + hunk.oldStart + hunk.oldLines;
|
||
}
|
||
|
||
// Apply patch hunks
|
||
for (var _i = 0; _i < hunks.length; _i++) {
|
||
var _hunk = hunks[_i],
|
||
_toPos = _hunk.offset + _hunk.newStart - 1;
|
||
|
||
for (var j = 0; j < _hunk.lines.length; j++) {
|
||
var line = _hunk.lines[j],
|
||
operation = line[0],
|
||
content = line.substr(1);
|
||
|
||
if (operation === ' ') {
|
||
_toPos++;
|
||
} else if (operation === '-') {
|
||
lines.splice(_toPos, 1);
|
||
/* istanbul ignore else */
|
||
} else if (operation === '+') {
|
||
lines.splice(_toPos, 0, content);
|
||
_toPos++;
|
||
} else if (operation === '\\') {
|
||
var previousOperation = _hunk.lines[j - 1] ? _hunk.lines[j - 1][0] : null;
|
||
if (previousOperation === '+') {
|
||
removeEOFNL = true;
|
||
} else if (previousOperation === '-') {
|
||
addEOFNL = true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Handle EOFNL insertion/removal
|
||
if (removeEOFNL) {
|
||
while (!lines[lines.length - 1]) {
|
||
lines.pop();
|
||
}
|
||
} else if (addEOFNL) {
|
||
lines.push('');
|
||
}
|
||
return lines.join('\n');
|
||
}
|
||
|
||
// Wrapper that supports multiple file patches via callbacks.
|
||
function applyPatches(uniDiff, options) {
|
||
if (typeof uniDiff === 'string') {
|
||
uniDiff = /*istanbul ignore start*/(0, _parse.parsePatch) /*istanbul ignore end*/(uniDiff);
|
||
}
|
||
|
||
var currentIndex = 0;
|
||
function processIndex() {
|
||
var index = uniDiff[currentIndex++];
|
||
if (!index) {
|
||
return options.complete();
|
||
}
|
||
|
||
options.loadFile(index, function (err, data) {
|
||
if (err) {
|
||
return options.complete(err);
|
||
}
|
||
|
||
var updatedContent = applyPatch(data, index, options);
|
||
options.patched(index, updatedContent);
|
||
|
||
setTimeout(processIndex, 0);
|
||
});
|
||
}
|
||
processIndex();
|
||
}
|
||
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/patch/apply.js"],"names":[],"mappings":"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","file":"apply.js","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('\\n'),\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[0],\n          content = line.substr(1);\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  for (let i = 0; i < hunks.length; i++) {\n    let hunk = hunks[i],\n        toPos = hunk.offset + hunk.newStart - 1;\n\n    for (let j = 0; j < hunk.lines.length; j++) {\n      let line = hunk.lines[j],\n          operation = line[0],\n          content = line.substr(1);\n\n      if (operation === ' ') {\n        toPos++;\n      } else if (operation === '-') {\n        lines.splice(toPos, 1);\n      /* istanbul ignore else */\n      } else if (operation === '+') {\n        lines.splice(toPos, 0, content);\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    }\n  } else if (addEOFNL) {\n    lines.push('');\n  }\n  return lines.join('\\n');\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);\n\n      setTimeout(processIndex, 0);\n    });\n  }\n  processIndex();\n}\n"]}
|
||
|
||
|
||
/***/ },
|
||
/* 15 */
|
||
/***/ function(module, exports) {
|
||
|
||
/*istanbul ignore start*/'use strict';
|
||
|
||
exports.__esModule = true;
|
||
exports. /*istanbul ignore end*/parsePatch = parsePatch;
|
||
function parsePatch(uniDiff) {
|
||
/*istanbul ignore start*/var /*istanbul ignore end*/options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
|
||
|
||
var diffstr = uniDiff.split('\n'),
|
||
list = [],
|
||
i = 0;
|
||
|
||
function parseIndex() {
|
||
var index = {};
|
||
list.push(index);
|
||
|
||
// Parse diff metadata
|
||
while (i < diffstr.length) {
|
||
var line = diffstr[i];
|
||
|
||
// File header found, end parsing diff metadata
|
||
if (/^(\-\-\-|\+\+\+|@@)\s/.test(line)) {
|
||
break;
|
||
}
|
||
|
||
// Diff index
|
||
var header = /^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(line);
|
||
if (header) {
|
||
index.index = header[1];
|
||
}
|
||
|
||
i++;
|
||
}
|
||
|
||
// Parse file headers if they are defined. Unified diff requires them, but
|
||
// there's no technical issues to have an isolated hunk without file header
|
||
parseFileHeader(index);
|
||
parseFileHeader(index);
|
||
|
||
// Parse hunks
|
||
index.hunks = [];
|
||
|
||
while (i < diffstr.length) {
|
||
var _line = diffstr[i];
|
||
|
||
if (/^(Index:|diff|\-\-\-|\+\+\+)\s/.test(_line)) {
|
||
break;
|
||
} else if (/^@@/.test(_line)) {
|
||
index.hunks.push(parseHunk());
|
||
} else if (_line && options.strict) {
|
||
// Ignore unexpected content unless in strict mode
|
||
throw new Error('Unknown line ' + (i + 1) + ' ' + JSON.stringify(_line));
|
||
} else {
|
||
i++;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Parses the --- and +++ headers, if none are found, no lines
|
||
// are consumed.
|
||
function parseFileHeader(index) {
|
||
var fileHeader = /^(\-\-\-|\+\+\+)\s+(\S*)\s?(.*?)\s*$/.exec(diffstr[i]);
|
||
if (fileHeader) {
|
||
var keyPrefix = fileHeader[1] === '---' ? 'old' : 'new';
|
||
index[keyPrefix + 'FileName'] = fileHeader[2];
|
||
index[keyPrefix + 'Header'] = fileHeader[3];
|
||
|
||
i++;
|
||
}
|
||
}
|
||
|
||
// Parses a hunk
|
||
// This assumes that we are at the start of a hunk.
|
||
function parseHunk() {
|
||
var chunkHeaderIndex = i,
|
||
chunkHeaderLine = diffstr[i++],
|
||
chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
|
||
|
||
var hunk = {
|
||
oldStart: +chunkHeader[1],
|
||
oldLines: +chunkHeader[2] || 1,
|
||
newStart: +chunkHeader[3],
|
||
newLines: +chunkHeader[4] || 1,
|
||
lines: []
|
||
};
|
||
|
||
var addCount = 0,
|
||
removeCount = 0;
|
||
for (; i < diffstr.length; i++) {
|
||
var operation = diffstr[i][0];
|
||
|
||
if (operation === '+' || operation === '-' || operation === ' ' || operation === '\\') {
|
||
hunk.lines.push(diffstr[i]);
|
||
|
||
if (operation === '+') {
|
||
addCount++;
|
||
} else if (operation === '-') {
|
||
removeCount++;
|
||
} else if (operation === ' ') {
|
||
addCount++;
|
||
removeCount++;
|
||
}
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
|
||
// Handle the empty block count case
|
||
if (!addCount && hunk.newLines === 1) {
|
||
hunk.newLines = 0;
|
||
}
|
||
if (!removeCount && hunk.oldLines === 1) {
|
||
hunk.oldLines = 0;
|
||
}
|
||
|
||
// Perform optional sanity checking
|
||
if (options.strict) {
|
||
if (addCount !== hunk.newLines) {
|
||
throw new Error('Added line count did not match for hunk at line ' + (chunkHeaderIndex + 1));
|
||
}
|
||
if (removeCount !== hunk.oldLines) {
|
||
throw new Error('Removed line count did not match for hunk at line ' + (chunkHeaderIndex + 1));
|
||
}
|
||
}
|
||
|
||
return hunk;
|
||
}
|
||
|
||
while (i < diffstr.length) {
|
||
parseIndex();
|
||
}
|
||
|
||
return list;
|
||
}
|
||
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/patch/parse.js"],"names":[],"mappings":";;;gCAAgB;AAAT,SAAS,UAAT,CAAoB,OAApB,EAA2C;sDAAd,gEAAU,kBAAI;;AAChD,MAAI,UAAU,QAAQ,KAAR,CAAc,IAAd,CAAV;MACA,OAAO,EAAP;MACA,IAAI,CAAJ,CAH4C;;AAKhD,WAAS,UAAT,GAAsB;AACpB,QAAI,QAAQ,EAAR,CADgB;AAEpB,SAAK,IAAL,CAAU,KAAV;;;AAFoB,WAKb,IAAI,QAAQ,MAAR,EAAgB;AACzB,UAAI,OAAO,QAAQ,CAAR,CAAP;;;AADqB,UAIrB,wBAAwB,IAAxB,CAA6B,IAA7B,CAAJ,EAAwC;AACtC,cADsC;OAAxC;;;AAJyB,UASrB,SAAS,2CAA6C,IAA7C,CAAkD,IAAlD,CAAT,CATqB;AAUzB,UAAI,MAAJ,EAAY;AACV,cAAM,KAAN,GAAc,OAAO,CAAP,CAAd,CADU;OAAZ;;AAIA,UAdyB;KAA3B;;;;AALoB,mBAwBpB,CAAgB,KAAhB,EAxBoB;AAyBpB,oBAAgB,KAAhB;;;AAzBoB,SA4BpB,CAAM,KAAN,GAAc,EAAd,CA5BoB;;AA8BpB,WAAO,IAAI,QAAQ,MAAR,EAAgB;AACzB,UAAI,QAAO,QAAQ,CAAR,CAAP,CADqB;;AAGzB,UAAI,iCAAiC,IAAjC,CAAsC,KAAtC,CAAJ,EAAiD;AAC/C,cAD+C;OAAjD,MAEO,IAAI,MAAM,IAAN,CAAW,KAAX,CAAJ,EAAsB;AAC3B,cAAM,KAAN,CAAY,IAAZ,CAAiB,WAAjB,EAD2B;OAAtB,MAEA,IAAI,SAAQ,QAAQ,MAAR,EAAgB;;AAEjC,cAAM,IAAI,KAAJ,CAAU,mBAAmB,IAAI,CAAJ,CAAnB,GAA4B,GAA5B,GAAkC,KAAK,SAAL,CAAe,KAAf,CAAlC,CAAhB,CAFiC;OAA5B,MAGA;AACL,YADK;OAHA;KAPT;GA9BF;;;;AALgD,WAqDvC,eAAT,CAAyB,KAAzB,EAAgC;AAC9B,QAAI,aAAa,uCAAyC,IAAzC,CAA8C,QAAQ,CAAR,CAA9C,CAAb,CAD0B;AAE9B,QAAI,UAAJ,EAAgB;AACd,UAAI,YAAY,WAAW,CAAX,MAAkB,KAAlB,GAA0B,KAA1B,GAAkC,KAAlC,CADF;AAEd,YAAM,YAAY,UAAZ,CAAN,GAAgC,WAAW,CAAX,CAAhC,CAFc;AAGd,YAAM,YAAY,QAAZ,CAAN,GAA8B,WAAW,CAAX,CAA9B,CAHc;;AAKd,UALc;KAAhB;GAFF;;;;AArDgD,WAkEvC,SAAT,GAAqB;AACnB,QAAI,mBAAmB,CAAnB;QACA,kBAAkB,QAAQ,GAAR,CAAlB;QACA,cAAc,gBAAgB,KAAhB,CAAsB,4CAAtB,CAAd,CAHe;;AAKnB,QAAI,OAAO;AACT,gBAAU,CAAC,YAAY,CAAZ,CAAD;AACV,gBAAU,CAAC,YAAY,CAAZ,CAAD,IAAmB,CAAnB;AACV,gBAAU,CAAC,YAAY,CAAZ,CAAD;AACV,gBAAU,CAAC,YAAY,CAAZ,CAAD,IAAmB,CAAnB;AACV,aAAO,EAAP;KALE,CALe;;AAanB,QAAI,WAAW,CAAX;QACA,cAAc,CAAd,CAde;AAenB,WAAO,IAAI,QAAQ,MAAR,EAAgB,GAA3B,EAAgC;AAC9B,UAAI,YAAY,QAAQ,CAAR,EAAW,CAAX,CAAZ,CAD0B;;AAG9B,UAAI,cAAc,GAAd,IAAqB,cAAc,GAAd,IAAqB,cAAc,GAAd,IAAqB,cAAc,IAAd,EAAoB;AACrF,aAAK,KAAL,CAAW,IAAX,CAAgB,QAAQ,CAAR,CAAhB,EADqF;;AAGrF,YAAI,cAAc,GAAd,EAAmB;AACrB,qBADqB;SAAvB,MAEO,IAAI,cAAc,GAAd,EAAmB;AAC5B,wBAD4B;SAAvB,MAEA,IAAI,cAAc,GAAd,EAAmB;AAC5B,qBAD4B;AAE5B,wBAF4B;SAAvB;OAPT,MAWO;AACL,cADK;OAXP;KAHF;;;AAfmB,QAmCf,CAAC,QAAD,IAAa,KAAK,QAAL,KAAkB,CAAlB,EAAqB;AACpC,WAAK,QAAL,GAAgB,CAAhB,CADoC;KAAtC;AAGA,QAAI,CAAC,WAAD,IAAgB,KAAK,QAAL,KAAkB,CAAlB,EAAqB;AACvC,WAAK,QAAL,GAAgB,CAAhB,CADuC;KAAzC;;;AAtCmB,QA2Cf,QAAQ,MAAR,EAAgB;AAClB,UAAI,aAAa,KAAK,QAAL,EAAe;AAC9B,cAAM,IAAI,KAAJ,CAAU,sDAAsD,mBAAmB,CAAnB,CAAtD,CAAhB,CAD8B;OAAhC;AAGA,UAAI,gBAAgB,KAAK,QAAL,EAAe;AACjC,cAAM,IAAI,KAAJ,CAAU,wDAAwD,mBAAmB,CAAnB,CAAxD,CAAhB,CADiC;OAAnC;KAJF;;AASA,WAAO,IAAP,CApDmB;GAArB;;AAuDA,SAAO,IAAI,QAAQ,MAAR,EAAgB;AACzB,iBADyB;GAA3B;;AAIA,SAAO,IAAP,CA7HgD;CAA3C","file":"parse.js","sourcesContent":["export function parsePatch(uniDiff, options = {}) {\n  let diffstr = uniDiff.split('\\n'),\n      list = [],\n      i = 0;\n\n  function parseIndex() {\n    let index = {};\n    list.push(index);\n\n    // Parse diff metadata\n    while (i < diffstr.length) {\n      let line = diffstr[i];\n\n      // File header found, end parsing diff metadata\n      if (/^(\\-\\-\\-|\\+\\+\\+|@@)\\s/.test(line)) {\n        break;\n      }\n\n      // Diff index\n      let header = (/^(?:Index:|diff(?: -r \\w+)+)\\s+(.+?)\\s*$/).exec(line);\n      if (header) {\n        index.index = header[1];\n      }\n\n      i++;\n    }\n\n    // Parse file headers if they are defined. Unified diff requires them, but\n    // there's no technical issues to have an isolated hunk without file header\n    parseFileHeader(index);\n    parseFileHeader(index);\n\n    // Parse hunks\n    index.hunks = [];\n\n    while (i < diffstr.length) {\n      let line = diffstr[i];\n\n      if (/^(Index:|diff|\\-\\-\\-|\\+\\+\\+)\\s/.test(line)) {\n        break;\n      } else if (/^@@/.test(line)) {\n        index.hunks.push(parseHunk());\n      } else if (line && options.strict) {\n        // Ignore unexpected content unless in strict mode\n        throw new Error('Unknown line ' + (i + 1) + ' ' + JSON.stringify(line));\n      } else {\n        i++;\n      }\n    }\n  }\n\n  // Parses the --- and +++ headers, if none are found, no lines\n  // are consumed.\n  function parseFileHeader(index) {\n    let fileHeader = (/^(\\-\\-\\-|\\+\\+\\+)\\s+(\\S*)\\s?(.*?)\\s*$/).exec(diffstr[i]);\n    if (fileHeader) {\n      let keyPrefix = fileHeader[1] === '---' ? 'old' : 'new';\n      index[keyPrefix + 'FileName'] = fileHeader[2];\n      index[keyPrefix + 'Header'] = fileHeader[3];\n\n      i++;\n    }\n  }\n\n  // Parses a hunk\n  // This assumes that we are at the start of a hunk.\n  function parseHunk() {\n    let chunkHeaderIndex = i,\n        chunkHeaderLine = diffstr[i++],\n        chunkHeader = chunkHeaderLine.split(/@@ -(\\d+)(?:,(\\d+))? \\+(\\d+)(?:,(\\d+))? @@/);\n\n    let hunk = {\n      oldStart: +chunkHeader[1],\n      oldLines: +chunkHeader[2] || 1,\n      newStart: +chunkHeader[3],\n      newLines: +chunkHeader[4] || 1,\n      lines: []\n    };\n\n    let addCount = 0,\n        removeCount = 0;\n    for (; i < diffstr.length; i++) {\n      let operation = diffstr[i][0];\n\n      if (operation === '+' || operation === '-' || operation === ' ' || operation === '\\\\') {\n        hunk.lines.push(diffstr[i]);\n\n        if (operation === '+') {\n          addCount++;\n        } else if (operation === '-') {\n          removeCount++;\n        } else if (operation === ' ') {\n          addCount++;\n          removeCount++;\n        }\n      } else {\n        break;\n      }\n    }\n\n    // Handle the empty block count case\n    if (!addCount && hunk.newLines === 1) {\n      hunk.newLines = 0;\n    }\n    if (!removeCount && hunk.oldLines === 1) {\n      hunk.oldLines = 0;\n    }\n\n    // Perform optional sanity checking\n    if (options.strict) {\n      if (addCount !== hunk.newLines) {\n        throw new Error('Added line count did not match for hunk at line ' + (chunkHeaderIndex + 1));\n      }\n      if (removeCount !== hunk.oldLines) {\n        throw new Error('Removed line count did not match for hunk at line ' + (chunkHeaderIndex + 1));\n      }\n    }\n\n    return hunk;\n  }\n\n  while (i < diffstr.length) {\n    parseIndex();\n  }\n\n  return list;\n}\n"]}
|
||
|
||
|
||
/***/ },
|
||
/* 16 */
|
||
/***/ function(module, exports) {
|
||
|
||
/*istanbul ignore start*/"use strict";
|
||
|
||
exports.__esModule = true;
|
||
|
||
exports.default = /*istanbul ignore end*/function (start, minLine, maxLine) {
|
||
var wantForward = true,
|
||
backwardExhausted = false,
|
||
forwardExhausted = false,
|
||
localOffset = 1;
|
||
|
||
return function iterator() {
|
||
if (wantForward && !forwardExhausted) {
|
||
if (backwardExhausted) {
|
||
localOffset++;
|
||
} else {
|
||
wantForward = false;
|
||
}
|
||
|
||
// Check if trying to fit beyond text length, and if not, check it fits
|
||
// after offset location (or desired location on first iteration)
|
||
if (start + localOffset <= maxLine) {
|
||
return localOffset;
|
||
}
|
||
|
||
forwardExhausted = true;
|
||
}
|
||
|
||
if (!backwardExhausted) {
|
||
if (!forwardExhausted) {
|
||
wantForward = true;
|
||
}
|
||
|
||
// Check if trying to fit before text beginning, and if not, check it fits
|
||
// before offset location
|
||
if (minLine <= start - localOffset) {
|
||
return - localOffset++;
|
||
}
|
||
|
||
backwardExhausted = true;
|
||
return iterator();
|
||
}
|
||
|
||
// We tried to fit hunk before text beginning and beyond text lenght, then
|
||
// hunk can't fit on the text. Return undefined
|
||
};
|
||
};
|
||
//# sourceMappingURL=data:application/json;base64,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
|
||
|
||
|
||
/***/ },
|
||
/* 17 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
/*istanbul ignore start*/'use strict';
|
||
|
||
exports.__esModule = true;
|
||
exports. /*istanbul ignore end*/structuredPatch = structuredPatch;
|
||
/*istanbul ignore start*/exports. /*istanbul ignore end*/createTwoFilesPatch = createTwoFilesPatch;
|
||
/*istanbul ignore start*/exports. /*istanbul ignore end*/createPatch = createPatch;
|
||
|
||
var /*istanbul ignore start*/_line = __webpack_require__(10) /*istanbul ignore end*/;
|
||
|
||
/*istanbul ignore start*/
|
||
function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
|
||
|
||
/*istanbul ignore end*/function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
|
||
if (!options) {
|
||
options = { context: 4 };
|
||
}
|
||
|
||
var diff = /*istanbul ignore start*/(0, _line.diffLines) /*istanbul ignore end*/(oldStr, newStr);
|
||
diff.push({ value: '', lines: [] }); // Append an empty value to make cleanup easier
|
||
|
||
function contextLines(lines) {
|
||
return lines.map(function (entry) {
|
||
return ' ' + entry;
|
||
});
|
||
}
|
||
|
||
var hunks = [];
|
||
var oldRangeStart = 0,
|
||
newRangeStart = 0,
|
||
curRange = [],
|
||
oldLine = 1,
|
||
newLine = 1;
|
||
/*istanbul ignore start*/
|
||
var _loop = function _loop( /*istanbul ignore end*/i) {
|
||
var current = diff[i],
|
||
lines = current.lines || current.value.replace(/\n$/, '').split('\n');
|
||
current.lines = lines;
|
||
|
||
if (current.added || current.removed) {
|
||
/*istanbul ignore start*/
|
||
var _curRange;
|
||
|
||
/*istanbul ignore end*/
|
||
// If we have previous context, start with that
|
||
if (!oldRangeStart) {
|
||
var prev = diff[i - 1];
|
||
oldRangeStart = oldLine;
|
||
newRangeStart = newLine;
|
||
|
||
if (prev) {
|
||
curRange = options.context > 0 ? contextLines(prev.lines.slice(-options.context)) : [];
|
||
oldRangeStart -= curRange.length;
|
||
newRangeStart -= curRange.length;
|
||
}
|
||
}
|
||
|
||
// Output our changes
|
||
/*istanbul ignore start*/(_curRange = /*istanbul ignore end*/curRange).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_curRange /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/lines.map(function (entry) {
|
||
return (current.added ? '+' : '-') + entry;
|
||
})));
|
||
|
||
// Track the updated file position
|
||
if (current.added) {
|
||
newLine += lines.length;
|
||
} else {
|
||
oldLine += lines.length;
|
||
}
|
||
} else {
|
||
// Identical context lines. Track line changes
|
||
if (oldRangeStart) {
|
||
// Close out any changes that have been output (or join overlapping)
|
||
if (lines.length <= options.context * 2 && i < diff.length - 2) {
|
||
/*istanbul ignore start*/
|
||
var _curRange2;
|
||
|
||
/*istanbul ignore end*/
|
||
// Overlapping
|
||
/*istanbul ignore start*/(_curRange2 = /*istanbul ignore end*/curRange).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_curRange2 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/contextLines(lines)));
|
||
} else {
|
||
/*istanbul ignore start*/
|
||
var _curRange3;
|
||
|
||
/*istanbul ignore end*/
|
||
// end the range and output
|
||
var contextSize = Math.min(lines.length, options.context);
|
||
/*istanbul ignore start*/(_curRange3 = /*istanbul ignore end*/curRange).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_curRange3 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/contextLines(lines.slice(0, contextSize))));
|
||
|
||
var hunk = {
|
||
oldStart: oldRangeStart,
|
||
oldLines: oldLine - oldRangeStart + contextSize,
|
||
newStart: newRangeStart,
|
||
newLines: newLine - newRangeStart + contextSize,
|
||
lines: curRange
|
||
};
|
||
if (i >= diff.length - 2 && lines.length <= options.context) {
|
||
// EOF is inside this hunk
|
||
var oldEOFNewline = /\n$/.test(oldStr);
|
||
var newEOFNewline = /\n$/.test(newStr);
|
||
if (lines.length == 0 && !oldEOFNewline) {
|
||
// special case: old has no eol and no trailing context; no-nl can end up before adds
|
||
curRange.splice(hunk.oldLines, 0, '\\ No newline at end of file');
|
||
} else if (!oldEOFNewline || !newEOFNewline) {
|
||
curRange.push('\\ No newline at end of file');
|
||
}
|
||
}
|
||
hunks.push(hunk);
|
||
|
||
oldRangeStart = 0;
|
||
newRangeStart = 0;
|
||
curRange = [];
|
||
}
|
||
}
|
||
oldLine += lines.length;
|
||
newLine += lines.length;
|
||
}
|
||
};
|
||
|
||
for (var i = 0; i < diff.length; i++) {
|
||
/*istanbul ignore start*/
|
||
_loop( /*istanbul ignore end*/i);
|
||
}
|
||
|
||
return {
|
||
oldFileName: oldFileName, newFileName: newFileName,
|
||
oldHeader: oldHeader, newHeader: newHeader,
|
||
hunks: hunks
|
||
};
|
||
}
|
||
|
||
function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
|
||
var diff = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
|
||
|
||
var ret = [];
|
||
if (oldFileName == newFileName) {
|
||
ret.push('Index: ' + oldFileName);
|
||
}
|
||
ret.push('===================================================================');
|
||
ret.push('--- ' + diff.oldFileName + (typeof diff.oldHeader === 'undefined' ? '' : '\t' + diff.oldHeader));
|
||
ret.push('+++ ' + diff.newFileName + (typeof diff.newHeader === 'undefined' ? '' : '\t' + diff.newHeader));
|
||
|
||
for (var i = 0; i < diff.hunks.length; i++) {
|
||
var hunk = diff.hunks[i];
|
||
ret.push('@@ -' + hunk.oldStart + ',' + hunk.oldLines + ' +' + hunk.newStart + ',' + hunk.newLines + ' @@');
|
||
ret.push.apply(ret, hunk.lines);
|
||
}
|
||
|
||
return ret.join('\n') + '\n';
|
||
}
|
||
|
||
function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {
|
||
return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options);
|
||
}
|
||
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/patch/create.js"],"names":[],"mappings":"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","file":"create.js","sourcesContent":["import {diffLines} from '../diff/line';\n\nexport function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {\n  if (!options) {\n    options = { context: 4 };\n  }\n\n  const diff = diffLines(oldStr, newStr);\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            if (lines.length == 0 && !oldEOFNewline) {\n              // special case: old has no eol and no trailing context; no-nl can end up before adds\n              curRange.splice(hunk.oldLines, 0, '\\\\ No newline at end of file');\n            } else if (!oldEOFNewline || !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 createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {\n  const diff = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);\n\n  const ret = [];\n  if (oldFileName == newFileName) {\n    ret.push('Index: ' + 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    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 createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {\n  return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options);\n}\n"]}
|
||
|
||
|
||
/***/ },
|
||
/* 18 */
|
||
/***/ function(module, exports) {
|
||
|
||
/*istanbul ignore start*/"use strict";
|
||
|
||
exports.__esModule = true;
|
||
exports. /*istanbul ignore end*/convertChangesToDMP = convertChangesToDMP;
|
||
// See: http://code.google.com/p/google-diff-match-patch/wiki/API
|
||
function convertChangesToDMP(changes) {
|
||
var ret = [],
|
||
change = /*istanbul ignore start*/void 0 /*istanbul ignore end*/,
|
||
operation = /*istanbul ignore start*/void 0 /*istanbul ignore end*/;
|
||
for (var i = 0; i < changes.length; i++) {
|
||
change = changes[i];
|
||
if (change.added) {
|
||
operation = 1;
|
||
} else if (change.removed) {
|
||
operation = -1;
|
||
} else {
|
||
operation = 0;
|
||
}
|
||
|
||
ret.push([operation, change.value]);
|
||
}
|
||
return ret;
|
||
}
|
||
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb252ZXJ0L2RtcC5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Z0NBQ2dCOztBQUFULFNBQVMsbUJBQVQsQ0FBNkIsT0FBN0IsRUFBc0M7QUFDM0MsTUFBSSxNQUFNLEVBQU47TUFDQSxnRUFESjtNQUVJLG1FQUZKLENBRDJDO0FBSTNDLE9BQUssSUFBSSxJQUFJLENBQUosRUFBTyxJQUFJLFFBQVEsTUFBUixFQUFnQixHQUFwQyxFQUF5QztBQUN2QyxhQUFTLFFBQVEsQ0FBUixDQUFULENBRHVDO0FBRXZDLFFBQUksT0FBTyxLQUFQLEVBQWM7QUFDaEIsa0JBQVksQ0FBWixDQURnQjtLQUFsQixNQUVPLElBQUksT0FBTyxPQUFQLEVBQWdCO0FBQ3pCLGtCQUFZLENBQUMsQ0FBRCxDQURhO0tBQXBCLE1BRUE7QUFDTCxrQkFBWSxDQUFaLENBREs7S0FGQTs7QUFNUCxRQUFJLElBQUosQ0FBUyxDQUFDLFNBQUQsRUFBWSxPQUFPLEtBQVAsQ0FBckIsRUFWdUM7R0FBekM7QUFZQSxTQUFPLEdBQVAsQ0FoQjJDO0NBQXRDIiwiZmlsZSI6ImRtcC5qcyIsInNvdXJjZXNDb250ZW50IjpbIi8vIFNlZTogaHR0cDovL2NvZGUuZ29vZ2xlLmNvbS9wL2dvb2dsZS1kaWZmLW1hdGNoLXBhdGNoL3dpa2kvQVBJXG5leHBvcnQgZnVuY3Rpb24gY29udmVydENoYW5nZXNUb0RNUChjaGFuZ2VzKSB7XG4gIGxldCByZXQgPSBbXSxcbiAgICAgIGNoYW5nZSxcbiAgICAgIG9wZXJhdGlvbjtcbiAgZm9yIChsZXQgaSA9IDA7IGkgPCBjaGFuZ2VzLmxlbmd0aDsgaSsrKSB7XG4gICAgY2hhbmdlID0gY2hhbmdlc1tpXTtcbiAgICBpZiAoY2hhbmdlLmFkZGVkKSB7XG4gICAgICBvcGVyYXRpb24gPSAxO1xuICAgIH0gZWxzZSBpZiAoY2hhbmdlLnJlbW92ZWQpIHtcbiAgICAgIG9wZXJhdGlvbiA9IC0xO1xuICAgIH0gZWxzZSB7XG4gICAgICBvcGVyYXRpb24gPSAwO1xuICAgIH1cblxuICAgIHJldC5wdXNoKFtvcGVyYXRpb24sIGNoYW5nZS52YWx1ZV0pO1xuICB9XG4gIHJldHVybiByZXQ7XG59XG4iXX0=
|
||
|
||
|
||
/***/ },
|
||
/* 19 */
|
||
/***/ function(module, exports) {
|
||
|
||
/*istanbul ignore start*/'use strict';
|
||
|
||
exports.__esModule = true;
|
||
exports. /*istanbul ignore end*/convertChangesToXML = convertChangesToXML;
|
||
function convertChangesToXML(changes) {
|
||
var ret = [];
|
||
for (var i = 0; i < changes.length; i++) {
|
||
var change = changes[i];
|
||
if (change.added) {
|
||
ret.push('<ins>');
|
||
} else if (change.removed) {
|
||
ret.push('<del>');
|
||
}
|
||
|
||
ret.push(escapeHTML(change.value));
|
||
|
||
if (change.added) {
|
||
ret.push('</ins>');
|
||
} else if (change.removed) {
|
||
ret.push('</del>');
|
||
}
|
||
}
|
||
return ret.join('');
|
||
}
|
||
|
||
function escapeHTML(s) {
|
||
var n = s;
|
||
n = n.replace(/&/g, '&');
|
||
n = n.replace(/</g, '<');
|
||
n = n.replace(/>/g, '>');
|
||
n = n.replace(/"/g, '"');
|
||
|
||
return n;
|
||
}
|
||
//# sourceMappingURL=data:application/json;base64,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
|
||
|
||
|
||
/***/ },
|
||
/* 20 */
|
||
/***/ function(module, exports) {
|
||
|
||
/*
|
||
*
|
||
* Rematch (rematch.js)
|
||
* Matching two sequences of objects by similarity
|
||
* Author: W. Illmeyer, Nexxar GmbH
|
||
*
|
||
*/
|
||
|
||
(function() {
|
||
|
||
var Rematch = {};
|
||
Rematch.arrayToString = function arrayToString(a) {
|
||
if (Object.prototype.toString.apply(a, []) === "[object Array]") {
|
||
return "[" + a.map(arrayToString).join(", ") + "]";
|
||
} else {
|
||
return a;
|
||
}
|
||
};
|
||
|
||
/*
|
||
Copyright (c) 2011 Andrei Mackenzie
|
||
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
|
||
documentation files (the "Software"), to deal in the Software without restriction, including without limitation
|
||
the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
|
||
and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
|
||
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
|
||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
|
||
THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||
*/
|
||
function levenshtein(a, b) {
|
||
if (a.length == 0) {
|
||
return b.length;
|
||
}
|
||
if (b.length == 0) {
|
||
return a.length;
|
||
}
|
||
|
||
var matrix = [];
|
||
|
||
// Increment along the first column of each row
|
||
var i;
|
||
for (i = 0; i <= b.length; i++) {
|
||
matrix[i] = [i];
|
||
}
|
||
|
||
// Increment each column in the first row
|
||
var j;
|
||
for (j = 0; j <= a.length; j++) {
|
||
matrix[0][j] = j;
|
||
}
|
||
|
||
// Fill in the rest of the matrix
|
||
for (i = 1; i <= b.length; i++) {
|
||
for (j = 1; j <= a.length; j++) {
|
||
if (b.charAt(i - 1) == a.charAt(j - 1)) {
|
||
matrix[i][j] = matrix[i - 1][j - 1];
|
||
} else {
|
||
matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, // Substitution
|
||
Math.min(matrix[i][j - 1] + 1, // Insertion
|
||
matrix[i - 1][j] + 1)); // Deletion
|
||
}
|
||
}
|
||
}
|
||
|
||
return matrix[b.length][a.length];
|
||
}
|
||
|
||
Rematch.levenshtein = levenshtein;
|
||
|
||
Rematch.distance = function distance(x, y) {
|
||
x = x.trim();
|
||
y = y.trim();
|
||
var lev = levenshtein(x, y);
|
||
var score = lev / (x.length + y.length);
|
||
|
||
return score;
|
||
};
|
||
|
||
Rematch.rematch = function rematch(distanceFunction) {
|
||
function findBestMatch(a, b, cache) {
|
||
var cachecount = 0;
|
||
|
||
for (var key in cache) {
|
||
cachecount++;
|
||
}
|
||
|
||
var bestMatchDist = Infinity;
|
||
var bestMatch;
|
||
for (var i = 0; i < a.length; ++i) {
|
||
for (var j = 0; j < b.length; ++j) {
|
||
var cacheKey = JSON.stringify([a[i], b[j]]);
|
||
var md;
|
||
if (cache.hasOwnProperty(cacheKey)) {
|
||
md = cache[cacheKey];
|
||
} else {
|
||
md = distanceFunction(a[i], b[j]);
|
||
cache[cacheKey] = md;
|
||
}
|
||
if (md < bestMatchDist) {
|
||
bestMatchDist = md;
|
||
bestMatch = {indexA: i, indexB: j, score: bestMatchDist};
|
||
}
|
||
}
|
||
}
|
||
|
||
return bestMatch;
|
||
}
|
||
|
||
function group(a, b, level, cache) {
|
||
if (typeof (cache) === "undefined") {
|
||
cache = {};
|
||
}
|
||
|
||
var bm = findBestMatch(a, b, cache);
|
||
|
||
if (!level) {
|
||
level = 0;
|
||
}
|
||
|
||
if (!bm || (a.length + b.length < 3)) {
|
||
return [[a, b]];
|
||
}
|
||
|
||
var a1 = a.slice(0, bm.indexA);
|
||
var b1 = b.slice(0, bm.indexB);
|
||
var aMatch = [a[bm.indexA]];
|
||
var bMatch = [b[bm.indexB]];
|
||
var tailA = bm.indexA + 1;
|
||
var tailB = bm.indexB + 1;
|
||
var a2 = a.slice(tailA);
|
||
var b2 = b.slice(tailB);
|
||
|
||
var group1 = group(a1, b1, level + 1, cache);
|
||
var groupMatch = group(aMatch, bMatch, level + 1, cache);
|
||
var group2 = group(a2, b2, level + 1, cache);
|
||
var result = groupMatch;
|
||
|
||
if (bm.indexA > 0 || bm.indexB > 0) {
|
||
result = group1.concat(result);
|
||
}
|
||
|
||
if (a.length > tailA || b.length > tailB) {
|
||
result = result.concat(group2);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
return group;
|
||
};
|
||
|
||
module.exports.Rematch = Rematch;
|
||
|
||
})();
|
||
|
||
|
||
/***/ },
|
||
/* 21 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
/*
|
||
*
|
||
* HtmlPrinter (html-printer.js)
|
||
* Author: rtfpessoa
|
||
*
|
||
*/
|
||
|
||
(function() {
|
||
|
||
var LineByLinePrinter = __webpack_require__(22).LineByLinePrinter;
|
||
var SideBySidePrinter = __webpack_require__(39).SideBySidePrinter;
|
||
|
||
function HtmlPrinter() {
|
||
}
|
||
|
||
HtmlPrinter.prototype.generateLineByLineJsonHtml = function(diffFiles, config) {
|
||
var lineByLinePrinter = new LineByLinePrinter(config);
|
||
return lineByLinePrinter.generateLineByLineJsonHtml(diffFiles);
|
||
};
|
||
|
||
HtmlPrinter.prototype.generateSideBySideJsonHtml = function(diffFiles, config) {
|
||
var sideBySidePrinter = new SideBySidePrinter(config);
|
||
return sideBySidePrinter.generateSideBySideJsonHtml(diffFiles);
|
||
};
|
||
|
||
module.exports.HtmlPrinter = new HtmlPrinter();
|
||
|
||
})();
|
||
|
||
|
||
/***/ },
|
||
/* 22 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
/*
|
||
*
|
||
* LineByLinePrinter (line-by-line-printer.js)
|
||
* Author: rtfpessoa
|
||
*
|
||
*/
|
||
|
||
(function() {
|
||
|
||
var diffParser = __webpack_require__(1).DiffParser;
|
||
var printerUtils = __webpack_require__(4).PrinterUtils;
|
||
var utils = __webpack_require__(2).Utils;
|
||
var Rematch = __webpack_require__(20).Rematch;
|
||
|
||
var nunjucksUtils = __webpack_require__(23).NunjucksUtils;
|
||
var baseTemplatesPath = 'line-by-line';
|
||
|
||
function LineByLinePrinter(config) {
|
||
this.config = config;
|
||
}
|
||
|
||
LineByLinePrinter.prototype.makeFileDiffHtml = function(file, diffs) {
|
||
return nunjucksUtils.render(baseTemplatesPath, 'file-diff.html', {'file': file, 'diffs': diffs});
|
||
};
|
||
|
||
LineByLinePrinter.prototype.makeLineByLineHtmlWrapper = function(content) {
|
||
return nunjucksUtils.render(baseTemplatesPath, 'wrapper.html', {'content': content});
|
||
};
|
||
|
||
LineByLinePrinter.prototype.generateLineByLineJsonHtml = function(diffFiles) {
|
||
var that = this;
|
||
var htmlDiffs = diffFiles.map(function(file) {
|
||
var diffs;
|
||
if (file.blocks.length) {
|
||
diffs = that._generateFileHtml(file);
|
||
} else {
|
||
diffs = that._generateEmptyDiff();
|
||
}
|
||
return that.makeFileDiffHtml(file, diffs);
|
||
});
|
||
|
||
return this.makeLineByLineHtmlWrapper(htmlDiffs.join('\n'));
|
||
};
|
||
|
||
var matcher = Rematch.rematch(function(a, b) {
|
||
var amod = a.content.substr(1);
|
||
var bmod = b.content.substr(1);
|
||
|
||
return Rematch.distance(amod, bmod);
|
||
});
|
||
|
||
LineByLinePrinter.prototype.makeColumnLineNumberHtml = function(block) {
|
||
return nunjucksUtils.render(baseTemplatesPath, 'column-line-number.html', {block: block});
|
||
};
|
||
|
||
LineByLinePrinter.prototype._generateFileHtml = function(file) {
|
||
var that = this;
|
||
return file.blocks.map(function(block) {
|
||
|
||
var lines = that.makeColumnLineNumberHtml(block);
|
||
var oldLines = [];
|
||
var newLines = [];
|
||
|
||
function processChangeBlock() {
|
||
var matches;
|
||
var insertType;
|
||
var deleteType;
|
||
|
||
var comparisons = oldLines.length * newLines.length;
|
||
var maxComparisons = that.config.matchingMaxComparisons || 2500;
|
||
var doMatching = comparisons < maxComparisons && (that.config.matching === 'lines' ||
|
||
that.config.matching === 'words');
|
||
|
||
if (doMatching) {
|
||
matches = matcher(oldLines, newLines);
|
||
insertType = diffParser.LINE_TYPE.INSERT_CHANGES;
|
||
deleteType = diffParser.LINE_TYPE.DELETE_CHANGES;
|
||
} else {
|
||
matches = [[oldLines, newLines]];
|
||
insertType = diffParser.LINE_TYPE.INSERTS;
|
||
deleteType = diffParser.LINE_TYPE.DELETES;
|
||
}
|
||
|
||
matches.forEach(function(match) {
|
||
oldLines = match[0];
|
||
newLines = match[1];
|
||
|
||
var processedOldLines = [];
|
||
var processedNewLines = [];
|
||
|
||
var common = Math.min(oldLines.length, newLines.length);
|
||
|
||
var oldLine, newLine;
|
||
for (var j = 0; j < common; j++) {
|
||
oldLine = oldLines[j];
|
||
newLine = newLines[j];
|
||
|
||
that.config.isCombined = file.isCombined;
|
||
var diff = printerUtils.diffHighlight(oldLine.content, newLine.content, that.config);
|
||
|
||
processedOldLines +=
|
||
that.makeLineHtml(deleteType, oldLine.oldNumber, oldLine.newNumber,
|
||
diff.first.line, diff.first.prefix);
|
||
processedNewLines +=
|
||
that.makeLineHtml(insertType, newLine.oldNumber, newLine.newNumber,
|
||
diff.second.line, diff.second.prefix);
|
||
}
|
||
|
||
lines += processedOldLines + processedNewLines;
|
||
lines += that._processLines(oldLines.slice(common), newLines.slice(common));
|
||
});
|
||
|
||
oldLines = [];
|
||
newLines = [];
|
||
}
|
||
|
||
for (var i = 0; i < block.lines.length; i++) {
|
||
var line = block.lines[i];
|
||
var escapedLine = utils.escape(line.content);
|
||
|
||
if (line.type !== diffParser.LINE_TYPE.INSERTS &&
|
||
(newLines.length > 0 || (line.type !== diffParser.LINE_TYPE.DELETES && oldLines.length > 0))) {
|
||
processChangeBlock();
|
||
}
|
||
|
||
if (line.type === diffParser.LINE_TYPE.CONTEXT) {
|
||
lines += that.makeLineHtml(line.type, line.oldNumber, line.newNumber, escapedLine);
|
||
} else if (line.type === diffParser.LINE_TYPE.INSERTS && !oldLines.length) {
|
||
lines += that.makeLineHtml(line.type, line.oldNumber, line.newNumber, escapedLine);
|
||
} else if (line.type === diffParser.LINE_TYPE.DELETES) {
|
||
oldLines.push(line);
|
||
} else if (line.type === diffParser.LINE_TYPE.INSERTS && Boolean(oldLines.length)) {
|
||
newLines.push(line);
|
||
} else {
|
||
console.error('Unknown state in html line-by-line generator');
|
||
processChangeBlock();
|
||
}
|
||
}
|
||
|
||
processChangeBlock();
|
||
|
||
return lines;
|
||
}).join('\n');
|
||
};
|
||
|
||
LineByLinePrinter.prototype._processLines = function(oldLines, newLines) {
|
||
var lines = '';
|
||
|
||
for (var i = 0; i < oldLines.length; i++) {
|
||
var oldLine = oldLines[i];
|
||
var oldEscapedLine = utils.escape(oldLine.content);
|
||
lines += this.makeLineHtml(oldLine.type, oldLine.oldNumber, oldLine.newNumber, oldEscapedLine);
|
||
}
|
||
|
||
for (var j = 0; j < newLines.length; j++) {
|
||
var newLine = newLines[j];
|
||
var newEscapedLine = utils.escape(newLine.content);
|
||
lines += this.makeLineHtml(newLine.type, newLine.oldNumber, newLine.newNumber, newEscapedLine);
|
||
}
|
||
|
||
return lines;
|
||
};
|
||
|
||
LineByLinePrinter.prototype.makeLineHtml = function(type, oldNumber, newNumber, content, prefix) {
|
||
return nunjucksUtils.render(baseTemplatesPath, 'line.html',
|
||
{
|
||
type: type,
|
||
oldNumber: oldNumber,
|
||
newNumber: newNumber,
|
||
prefix: prefix,
|
||
content: content
|
||
});
|
||
};
|
||
|
||
LineByLinePrinter.prototype._generateEmptyDiff = function() {
|
||
return nunjucksUtils.render(baseTemplatesPath, 'empty-diff.html', {});
|
||
};
|
||
|
||
module.exports.LineByLinePrinter = LineByLinePrinter;
|
||
|
||
})();
|
||
|
||
|
||
/***/ },
|
||
/* 23 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
/* WEBPACK VAR INJECTION */(function(__dirname) {/*
|
||
*
|
||
* Utils (utils.js)
|
||
* Author: rtfpessoa
|
||
*
|
||
*/
|
||
|
||
(function() {
|
||
|
||
var path = __webpack_require__(24);
|
||
|
||
var nunjucks = __webpack_require__(26);
|
||
var templatesPath = path.resolve(__dirname, 'templates');
|
||
|
||
var diffParser = __webpack_require__(1).DiffParser;
|
||
var printerUtils = __webpack_require__(4).PrinterUtils;
|
||
var utils = __webpack_require__(2).Utils;
|
||
|
||
var nunjucksEnv = nunjucks.configure(templatesPath, {"autoescape": false})
|
||
.addGlobal('printerUtils', printerUtils)
|
||
.addGlobal('utils', utils)
|
||
.addGlobal('diffParser', diffParser);
|
||
|
||
function NunjucksUtils() {
|
||
}
|
||
|
||
NunjucksUtils.prototype.render = function(namespace, view, params) {
|
||
var viewPath = path.join(namespace, view);
|
||
return nunjucksEnv.render(viewPath, params);
|
||
};
|
||
|
||
module.exports.NunjucksUtils = new NunjucksUtils();
|
||
|
||
})();
|
||
|
||
/* WEBPACK VAR INJECTION */}.call(exports, "/"))
|
||
|
||
/***/ },
|
||
/* 24 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
/* WEBPACK VAR INJECTION */(function(process) {// Copyright Joyent, Inc. and other Node contributors.
|
||
//
|
||
// Permission is hereby granted, free of charge, to any person obtaining a
|
||
// copy of this software and associated documentation files (the
|
||
// "Software"), to deal in the Software without restriction, including
|
||
// without limitation the rights to use, copy, modify, merge, publish,
|
||
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
||
// persons to whom the Software is furnished to do so, subject to the
|
||
// following conditions:
|
||
//
|
||
// The above copyright notice and this permission notice shall be included
|
||
// in all copies or substantial portions of the Software.
|
||
//
|
||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
||
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||
|
||
// resolves . and .. elements in a path array with directory names there
|
||
// must be no slashes, empty elements, or device names (c:\) in the array
|
||
// (so also no leading and trailing slashes - it does not distinguish
|
||
// relative and absolute paths)
|
||
function normalizeArray(parts, allowAboveRoot) {
|
||
// if the path tries to go above the root, `up` ends up > 0
|
||
var up = 0;
|
||
for (var i = parts.length - 1; i >= 0; i--) {
|
||
var last = parts[i];
|
||
if (last === '.') {
|
||
parts.splice(i, 1);
|
||
} else if (last === '..') {
|
||
parts.splice(i, 1);
|
||
up++;
|
||
} else if (up) {
|
||
parts.splice(i, 1);
|
||
up--;
|
||
}
|
||
}
|
||
|
||
// if the path is allowed to go above the root, restore leading ..s
|
||
if (allowAboveRoot) {
|
||
for (; up--; up) {
|
||
parts.unshift('..');
|
||
}
|
||
}
|
||
|
||
return parts;
|
||
}
|
||
|
||
// Split a filename into [root, dir, basename, ext], unix version
|
||
// 'root' is just a slash, or nothing.
|
||
var splitPathRe =
|
||
/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
|
||
var splitPath = function(filename) {
|
||
return splitPathRe.exec(filename).slice(1);
|
||
};
|
||
|
||
// path.resolve([from ...], to)
|
||
// posix version
|
||
exports.resolve = function() {
|
||
var resolvedPath = '',
|
||
resolvedAbsolute = false;
|
||
|
||
for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
|
||
var path = (i >= 0) ? arguments[i] : process.cwd();
|
||
|
||
// Skip empty and invalid entries
|
||
if (typeof path !== 'string') {
|
||
throw new TypeError('Arguments to path.resolve must be strings');
|
||
} else if (!path) {
|
||
continue;
|
||
}
|
||
|
||
resolvedPath = path + '/' + resolvedPath;
|
||
resolvedAbsolute = path.charAt(0) === '/';
|
||
}
|
||
|
||
// At this point the path should be resolved to a full absolute path, but
|
||
// handle relative paths to be safe (might happen when process.cwd() fails)
|
||
|
||
// Normalize the path
|
||
resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
|
||
return !!p;
|
||
}), !resolvedAbsolute).join('/');
|
||
|
||
return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
|
||
};
|
||
|
||
// path.normalize(path)
|
||
// posix version
|
||
exports.normalize = function(path) {
|
||
var isAbsolute = exports.isAbsolute(path),
|
||
trailingSlash = substr(path, -1) === '/';
|
||
|
||
// Normalize the path
|
||
path = normalizeArray(filter(path.split('/'), function(p) {
|
||
return !!p;
|
||
}), !isAbsolute).join('/');
|
||
|
||
if (!path && !isAbsolute) {
|
||
path = '.';
|
||
}
|
||
if (path && trailingSlash) {
|
||
path += '/';
|
||
}
|
||
|
||
return (isAbsolute ? '/' : '') + path;
|
||
};
|
||
|
||
// posix version
|
||
exports.isAbsolute = function(path) {
|
||
return path.charAt(0) === '/';
|
||
};
|
||
|
||
// posix version
|
||
exports.join = function() {
|
||
var paths = Array.prototype.slice.call(arguments, 0);
|
||
return exports.normalize(filter(paths, function(p, index) {
|
||
if (typeof p !== 'string') {
|
||
throw new TypeError('Arguments to path.join must be strings');
|
||
}
|
||
return p;
|
||
}).join('/'));
|
||
};
|
||
|
||
|
||
// path.relative(from, to)
|
||
// posix version
|
||
exports.relative = function(from, to) {
|
||
from = exports.resolve(from).substr(1);
|
||
to = exports.resolve(to).substr(1);
|
||
|
||
function trim(arr) {
|
||
var start = 0;
|
||
for (; start < arr.length; start++) {
|
||
if (arr[start] !== '') break;
|
||
}
|
||
|
||
var end = arr.length - 1;
|
||
for (; end >= 0; end--) {
|
||
if (arr[end] !== '') break;
|
||
}
|
||
|
||
if (start > end) return [];
|
||
return arr.slice(start, end - start + 1);
|
||
}
|
||
|
||
var fromParts = trim(from.split('/'));
|
||
var toParts = trim(to.split('/'));
|
||
|
||
var length = Math.min(fromParts.length, toParts.length);
|
||
var samePartsLength = length;
|
||
for (var i = 0; i < length; i++) {
|
||
if (fromParts[i] !== toParts[i]) {
|
||
samePartsLength = i;
|
||
break;
|
||
}
|
||
}
|
||
|
||
var outputParts = [];
|
||
for (var i = samePartsLength; i < fromParts.length; i++) {
|
||
outputParts.push('..');
|
||
}
|
||
|
||
outputParts = outputParts.concat(toParts.slice(samePartsLength));
|
||
|
||
return outputParts.join('/');
|
||
};
|
||
|
||
exports.sep = '/';
|
||
exports.delimiter = ':';
|
||
|
||
exports.dirname = function(path) {
|
||
var result = splitPath(path),
|
||
root = result[0],
|
||
dir = result[1];
|
||
|
||
if (!root && !dir) {
|
||
// No dirname whatsoever
|
||
return '.';
|
||
}
|
||
|
||
if (dir) {
|
||
// It has a dirname, strip trailing slash
|
||
dir = dir.substr(0, dir.length - 1);
|
||
}
|
||
|
||
return root + dir;
|
||
};
|
||
|
||
|
||
exports.basename = function(path, ext) {
|
||
var f = splitPath(path)[2];
|
||
// TODO: make this comparison case-insensitive on windows?
|
||
if (ext && f.substr(-1 * ext.length) === ext) {
|
||
f = f.substr(0, f.length - ext.length);
|
||
}
|
||
return f;
|
||
};
|
||
|
||
|
||
exports.extname = function(path) {
|
||
return splitPath(path)[3];
|
||
};
|
||
|
||
function filter (xs, f) {
|
||
if (xs.filter) return xs.filter(f);
|
||
var res = [];
|
||
for (var i = 0; i < xs.length; i++) {
|
||
if (f(xs[i], i, xs)) res.push(xs[i]);
|
||
}
|
||
return res;
|
||
}
|
||
|
||
// String.prototype.substr - negative index don't work in IE8
|
||
var substr = 'ab'.substr(-1) === 'b'
|
||
? function (str, start, len) { return str.substr(start, len) }
|
||
: function (str, start, len) {
|
||
if (start < 0) start = str.length + start;
|
||
return str.substr(start, len);
|
||
}
|
||
;
|
||
|
||
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(25)))
|
||
|
||
/***/ },
|
||
/* 25 */
|
||
/***/ function(module, exports) {
|
||
|
||
// shim for using process in browser
|
||
|
||
var process = module.exports = {};
|
||
var queue = [];
|
||
var draining = false;
|
||
var currentQueue;
|
||
var queueIndex = -1;
|
||
|
||
function cleanUpNextTick() {
|
||
draining = false;
|
||
if (currentQueue.length) {
|
||
queue = currentQueue.concat(queue);
|
||
} else {
|
||
queueIndex = -1;
|
||
}
|
||
if (queue.length) {
|
||
drainQueue();
|
||
}
|
||
}
|
||
|
||
function drainQueue() {
|
||
if (draining) {
|
||
return;
|
||
}
|
||
var timeout = setTimeout(cleanUpNextTick);
|
||
draining = true;
|
||
|
||
var len = queue.length;
|
||
while(len) {
|
||
currentQueue = queue;
|
||
queue = [];
|
||
while (++queueIndex < len) {
|
||
if (currentQueue) {
|
||
currentQueue[queueIndex].run();
|
||
}
|
||
}
|
||
queueIndex = -1;
|
||
len = queue.length;
|
||
}
|
||
currentQueue = null;
|
||
draining = false;
|
||
clearTimeout(timeout);
|
||
}
|
||
|
||
process.nextTick = function (fun) {
|
||
var args = new Array(arguments.length - 1);
|
||
if (arguments.length > 1) {
|
||
for (var i = 1; i < arguments.length; i++) {
|
||
args[i - 1] = arguments[i];
|
||
}
|
||
}
|
||
queue.push(new Item(fun, args));
|
||
if (queue.length === 1 && !draining) {
|
||
setTimeout(drainQueue, 0);
|
||
}
|
||
};
|
||
|
||
// v8 likes predictible objects
|
||
function Item(fun, array) {
|
||
this.fun = fun;
|
||
this.array = array;
|
||
}
|
||
Item.prototype.run = function () {
|
||
this.fun.apply(null, this.array);
|
||
};
|
||
process.title = 'browser';
|
||
process.browser = true;
|
||
process.env = {};
|
||
process.argv = [];
|
||
process.version = ''; // empty string to avoid regexp issues
|
||
process.versions = {};
|
||
|
||
function noop() {}
|
||
|
||
process.on = noop;
|
||
process.addListener = noop;
|
||
process.once = noop;
|
||
process.off = noop;
|
||
process.removeListener = noop;
|
||
process.removeAllListeners = noop;
|
||
process.emit = noop;
|
||
|
||
process.binding = function (name) {
|
||
throw new Error('process.binding is not supported');
|
||
};
|
||
|
||
process.cwd = function () { return '/' };
|
||
process.chdir = function (dir) {
|
||
throw new Error('process.chdir is not supported');
|
||
};
|
||
process.umask = function() { return 0; };
|
||
|
||
|
||
/***/ },
|
||
/* 26 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
'use strict';
|
||
|
||
var lib = __webpack_require__(27);
|
||
var env = __webpack_require__(28);
|
||
var Loader = __webpack_require__(37);
|
||
var loaders = __webpack_require__(32);
|
||
var precompile = __webpack_require__(32);
|
||
|
||
module.exports = {};
|
||
module.exports.Environment = env.Environment;
|
||
module.exports.Template = env.Template;
|
||
|
||
module.exports.Loader = Loader;
|
||
module.exports.FileSystemLoader = loaders.FileSystemLoader;
|
||
module.exports.PrecompiledLoader = loaders.PrecompiledLoader;
|
||
module.exports.WebLoader = loaders.WebLoader;
|
||
|
||
module.exports.compiler = __webpack_require__(32);
|
||
module.exports.parser = __webpack_require__(32);
|
||
module.exports.lexer = __webpack_require__(32);
|
||
module.exports.runtime = __webpack_require__(34);
|
||
module.exports.lib = lib;
|
||
module.exports.nodes = __webpack_require__(32);
|
||
|
||
module.exports.installJinjaCompat = __webpack_require__(38);
|
||
|
||
// A single instance of an environment, since this is so commonly used
|
||
|
||
var e;
|
||
module.exports.configure = function(templatesPath, opts) {
|
||
opts = opts || {};
|
||
if(lib.isObject(templatesPath)) {
|
||
opts = templatesPath;
|
||
templatesPath = null;
|
||
}
|
||
|
||
var TemplateLoader;
|
||
if(loaders.FileSystemLoader) {
|
||
TemplateLoader = new loaders.FileSystemLoader(templatesPath, {
|
||
watch: opts.watch,
|
||
noCache: opts.noCache
|
||
});
|
||
}
|
||
else if(loaders.WebLoader) {
|
||
TemplateLoader = new loaders.WebLoader(templatesPath, {
|
||
useCache: opts.web && opts.web.useCache,
|
||
async: opts.web && opts.web.async
|
||
});
|
||
}
|
||
|
||
e = new env.Environment(TemplateLoader, opts);
|
||
|
||
if(opts && opts.express) {
|
||
e.express(opts.express);
|
||
}
|
||
|
||
return e;
|
||
};
|
||
|
||
module.exports.compile = function(src, env, path, eagerCompile) {
|
||
if(!e) {
|
||
module.exports.configure();
|
||
}
|
||
return new module.exports.Template(src, env, path, eagerCompile);
|
||
};
|
||
|
||
module.exports.render = function(name, ctx, cb) {
|
||
if(!e) {
|
||
module.exports.configure();
|
||
}
|
||
|
||
return e.render(name, ctx, cb);
|
||
};
|
||
|
||
module.exports.renderString = function(src, ctx, cb) {
|
||
if(!e) {
|
||
module.exports.configure();
|
||
}
|
||
|
||
return e.renderString(src, ctx, cb);
|
||
};
|
||
|
||
if(precompile) {
|
||
module.exports.precompile = precompile.precompile;
|
||
module.exports.precompileString = precompile.precompileString;
|
||
}
|
||
|
||
|
||
/***/ },
|
||
/* 27 */
|
||
/***/ function(module, exports) {
|
||
|
||
'use strict';
|
||
|
||
var ArrayProto = Array.prototype;
|
||
var ObjProto = Object.prototype;
|
||
|
||
var escapeMap = {
|
||
'&': '&',
|
||
'"': '"',
|
||
'\'': ''',
|
||
'<': '<',
|
||
'>': '>'
|
||
};
|
||
|
||
var escapeRegex = /[&"'<>]/g;
|
||
|
||
var lookupEscape = function(ch) {
|
||
return escapeMap[ch];
|
||
};
|
||
|
||
var exports = module.exports = {};
|
||
|
||
exports.prettifyError = function(path, withInternals, err) {
|
||
// jshint -W022
|
||
// http://jslinterrors.com/do-not-assign-to-the-exception-parameter
|
||
if (!err.Update) {
|
||
// not one of ours, cast it
|
||
err = new exports.TemplateError(err);
|
||
}
|
||
err.Update(path);
|
||
|
||
// Unless they marked the dev flag, show them a trace from here
|
||
if (!withInternals) {
|
||
var old = err;
|
||
err = new Error(old.message);
|
||
err.name = old.name;
|
||
}
|
||
|
||
return err;
|
||
};
|
||
|
||
exports.TemplateError = function(message, lineno, colno) {
|
||
var err = this;
|
||
|
||
if (message instanceof Error) { // for casting regular js errors
|
||
err = message;
|
||
message = message.name + ': ' + message.message;
|
||
|
||
try {
|
||
if(err.name = '') {}
|
||
}
|
||
catch(e) {
|
||
// If we can't set the name of the error object in this
|
||
// environment, don't use it
|
||
err = this;
|
||
}
|
||
} else {
|
||
if(Error.captureStackTrace) {
|
||
Error.captureStackTrace(err);
|
||
}
|
||
}
|
||
|
||
err.name = 'Template render error';
|
||
err.message = message;
|
||
err.lineno = lineno;
|
||
err.colno = colno;
|
||
err.firstUpdate = true;
|
||
|
||
err.Update = function(path) {
|
||
var message = '(' + (path || 'unknown path') + ')';
|
||
|
||
// only show lineno + colno next to path of template
|
||
// where error occurred
|
||
if (this.firstUpdate) {
|
||
if(this.lineno && this.colno) {
|
||
message += ' [Line ' + this.lineno + ', Column ' + this.colno + ']';
|
||
}
|
||
else if(this.lineno) {
|
||
message += ' [Line ' + this.lineno + ']';
|
||
}
|
||
}
|
||
|
||
message += '\n ';
|
||
if (this.firstUpdate) {
|
||
message += ' ';
|
||
}
|
||
|
||
this.message = message + (this.message || '');
|
||
this.firstUpdate = false;
|
||
return this;
|
||
};
|
||
|
||
return err;
|
||
};
|
||
|
||
exports.TemplateError.prototype = Error.prototype;
|
||
|
||
exports.escape = function(val) {
|
||
return val.replace(escapeRegex, lookupEscape);
|
||
};
|
||
|
||
exports.isFunction = function(obj) {
|
||
return ObjProto.toString.call(obj) === '[object Function]';
|
||
};
|
||
|
||
exports.isArray = Array.isArray || function(obj) {
|
||
return ObjProto.toString.call(obj) === '[object Array]';
|
||
};
|
||
|
||
exports.isString = function(obj) {
|
||
return ObjProto.toString.call(obj) === '[object String]';
|
||
};
|
||
|
||
exports.isObject = function(obj) {
|
||
return ObjProto.toString.call(obj) === '[object Object]';
|
||
};
|
||
|
||
exports.groupBy = function(obj, val) {
|
||
var result = {};
|
||
var iterator = exports.isFunction(val) ? val : function(obj) { return obj[val]; };
|
||
for(var i=0; i<obj.length; i++) {
|
||
var value = obj[i];
|
||
var key = iterator(value, i);
|
||
(result[key] || (result[key] = [])).push(value);
|
||
}
|
||
return result;
|
||
};
|
||
|
||
exports.toArray = function(obj) {
|
||
return Array.prototype.slice.call(obj);
|
||
};
|
||
|
||
exports.without = function(array) {
|
||
var result = [];
|
||
if (!array) {
|
||
return result;
|
||
}
|
||
var index = -1,
|
||
length = array.length,
|
||
contains = exports.toArray(arguments).slice(1);
|
||
|
||
while(++index < length) {
|
||
if(exports.indexOf(contains, array[index]) === -1) {
|
||
result.push(array[index]);
|
||
}
|
||
}
|
||
return result;
|
||
};
|
||
|
||
exports.extend = function(obj, obj2) {
|
||
for(var k in obj2) {
|
||
obj[k] = obj2[k];
|
||
}
|
||
return obj;
|
||
};
|
||
|
||
exports.repeat = function(char_, n) {
|
||
var str = '';
|
||
for(var i=0; i<n; i++) {
|
||
str += char_;
|
||
}
|
||
return str;
|
||
};
|
||
|
||
exports.each = function(obj, func, context) {
|
||
if(obj == null) {
|
||
return;
|
||
}
|
||
|
||
if(ArrayProto.each && obj.each === ArrayProto.each) {
|
||
obj.forEach(func, context);
|
||
}
|
||
else if(obj.length === +obj.length) {
|
||
for(var i=0, l=obj.length; i<l; i++) {
|
||
func.call(context, obj[i], i, obj);
|
||
}
|
||
}
|
||
};
|
||
|
||
exports.map = function(obj, func) {
|
||
var results = [];
|
||
if(obj == null) {
|
||
return results;
|
||
}
|
||
|
||
if(ArrayProto.map && obj.map === ArrayProto.map) {
|
||
return obj.map(func);
|
||
}
|
||
|
||
for(var i=0; i<obj.length; i++) {
|
||
results[results.length] = func(obj[i], i);
|
||
}
|
||
|
||
if(obj.length === +obj.length) {
|
||
results.length = obj.length;
|
||
}
|
||
|
||
return results;
|
||
};
|
||
|
||
exports.asyncIter = function(arr, iter, cb) {
|
||
var i = -1;
|
||
|
||
function next() {
|
||
i++;
|
||
|
||
if(i < arr.length) {
|
||
iter(arr[i], i, next, cb);
|
||
}
|
||
else {
|
||
cb();
|
||
}
|
||
}
|
||
|
||
next();
|
||
};
|
||
|
||
exports.asyncFor = function(obj, iter, cb) {
|
||
var keys = exports.keys(obj);
|
||
var len = keys.length;
|
||
var i = -1;
|
||
|
||
function next() {
|
||
i++;
|
||
var k = keys[i];
|
||
|
||
if(i < len) {
|
||
iter(k, obj[k], i, len, next);
|
||
}
|
||
else {
|
||
cb();
|
||
}
|
||
}
|
||
|
||
next();
|
||
};
|
||
|
||
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf#Polyfill
|
||
exports.indexOf = Array.prototype.indexOf ?
|
||
function (arr, searchElement, fromIndex) {
|
||
return Array.prototype.indexOf.call(arr, searchElement, fromIndex);
|
||
} :
|
||
function (arr, searchElement, fromIndex) {
|
||
var length = this.length >>> 0; // Hack to convert object.length to a UInt32
|
||
|
||
fromIndex = +fromIndex || 0;
|
||
|
||
if(Math.abs(fromIndex) === Infinity) {
|
||
fromIndex = 0;
|
||
}
|
||
|
||
if(fromIndex < 0) {
|
||
fromIndex += length;
|
||
if (fromIndex < 0) {
|
||
fromIndex = 0;
|
||
}
|
||
}
|
||
|
||
for(;fromIndex < length; fromIndex++) {
|
||
if (arr[fromIndex] === searchElement) {
|
||
return fromIndex;
|
||
}
|
||
}
|
||
|
||
return -1;
|
||
};
|
||
|
||
if(!Array.prototype.map) {
|
||
Array.prototype.map = function() {
|
||
throw new Error('map is unimplemented for this js engine');
|
||
};
|
||
}
|
||
|
||
exports.keys = function(obj) {
|
||
if(Object.prototype.keys) {
|
||
return obj.keys();
|
||
}
|
||
else {
|
||
var keys = [];
|
||
for(var k in obj) {
|
||
if(obj.hasOwnProperty(k)) {
|
||
keys.push(k);
|
||
}
|
||
}
|
||
return keys;
|
||
}
|
||
};
|
||
|
||
exports.inOperator = function (key, arrOrObj) {
|
||
if (exports.isArray(arrOrObj)) {
|
||
return exports.indexOf(arrOrObj, key) !== -1;
|
||
} else if (exports.isObject(arrOrObj)) {
|
||
return key in arrOrObj;
|
||
} else {
|
||
throw new Error('Cannot use "in" operator to search for "'
|
||
+ key + '" in unexpected types.');
|
||
}
|
||
};
|
||
|
||
|
||
/***/ },
|
||
/* 28 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
'use strict';
|
||
|
||
var path = __webpack_require__(24);
|
||
var asap = __webpack_require__(29);
|
||
var lib = __webpack_require__(27);
|
||
var Obj = __webpack_require__(31);
|
||
var compiler = __webpack_require__(32);
|
||
var builtin_filters = __webpack_require__(33);
|
||
var builtin_loaders = __webpack_require__(32);
|
||
var runtime = __webpack_require__(34);
|
||
var globals = __webpack_require__(35);
|
||
var Frame = runtime.Frame;
|
||
var Template;
|
||
|
||
// Unconditionally load in this loader, even if no other ones are
|
||
// included (possible in the slim browser build)
|
||
builtin_loaders.PrecompiledLoader = __webpack_require__(36);
|
||
|
||
// If the user is using the async API, *always* call it
|
||
// asynchronously even if the template was synchronous.
|
||
function callbackAsap(cb, err, res) {
|
||
asap(function() { cb(err, res); });
|
||
}
|
||
|
||
var Environment = Obj.extend({
|
||
init: function(loaders, opts) {
|
||
// The dev flag determines the trace that'll be shown on errors.
|
||
// If set to true, returns the full trace from the error point,
|
||
// otherwise will return trace starting from Template.render
|
||
// (the full trace from within nunjucks may confuse developers using
|
||
// the library)
|
||
// defaults to false
|
||
opts = this.opts = opts || {};
|
||
this.opts.dev = !!opts.dev;
|
||
|
||
// The autoescape flag sets global autoescaping. If true,
|
||
// every string variable will be escaped by default.
|
||
// If false, strings can be manually escaped using the `escape` filter.
|
||
// defaults to true
|
||
this.opts.autoescape = opts.autoescape != null ? opts.autoescape : true;
|
||
|
||
// If true, this will make the system throw errors if trying
|
||
// to output a null or undefined value
|
||
this.opts.throwOnUndefined = !!opts.throwOnUndefined;
|
||
this.opts.trimBlocks = !!opts.trimBlocks;
|
||
this.opts.lstripBlocks = !!opts.lstripBlocks;
|
||
|
||
this.loaders = [];
|
||
|
||
if(!loaders) {
|
||
// The filesystem loader is only available server-side
|
||
if(builtin_loaders.FileSystemLoader) {
|
||
this.loaders = [new builtin_loaders.FileSystemLoader('views')];
|
||
}
|
||
else if(builtin_loaders.WebLoader) {
|
||
this.loaders = [new builtin_loaders.WebLoader('/views')];
|
||
}
|
||
}
|
||
else {
|
||
this.loaders = lib.isArray(loaders) ? loaders : [loaders];
|
||
}
|
||
|
||
// It's easy to use precompiled templates: just include them
|
||
// before you configure nunjucks and this will automatically
|
||
// pick it up and use it
|
||
if((true) && window.nunjucksPrecompiled) {
|
||
this.loaders.unshift(
|
||
new builtin_loaders.PrecompiledLoader(window.nunjucksPrecompiled)
|
||
);
|
||
}
|
||
|
||
this.initCache();
|
||
|
||
this.globals = globals();
|
||
this.filters = {};
|
||
this.asyncFilters = [];
|
||
this.extensions = {};
|
||
this.extensionsList = [];
|
||
|
||
for(var name in builtin_filters) {
|
||
this.addFilter(name, builtin_filters[name]);
|
||
}
|
||
},
|
||
|
||
initCache: function() {
|
||
// Caching and cache busting
|
||
lib.each(this.loaders, function(loader) {
|
||
loader.cache = {};
|
||
|
||
if(typeof loader.on === 'function') {
|
||
loader.on('update', function(template) {
|
||
loader.cache[template] = null;
|
||
});
|
||
}
|
||
});
|
||
},
|
||
|
||
addExtension: function(name, extension) {
|
||
extension._name = name;
|
||
this.extensions[name] = extension;
|
||
this.extensionsList.push(extension);
|
||
return this;
|
||
},
|
||
|
||
removeExtension: function(name) {
|
||
var extension = this.getExtension(name);
|
||
if (!extension) return;
|
||
|
||
this.extensionsList = lib.without(this.extensionsList, extension);
|
||
delete this.extensions[name];
|
||
},
|
||
|
||
getExtension: function(name) {
|
||
return this.extensions[name];
|
||
},
|
||
|
||
hasExtension: function(name) {
|
||
return !!this.extensions[name];
|
||
},
|
||
|
||
addGlobal: function(name, value) {
|
||
this.globals[name] = value;
|
||
return this;
|
||
},
|
||
|
||
getGlobal: function(name) {
|
||
if(typeof this.globals[name] === 'undefined') {
|
||
throw new Error('global not found: ' + name);
|
||
}
|
||
return this.globals[name];
|
||
},
|
||
|
||
addFilter: function(name, func, async) {
|
||
var wrapped = func;
|
||
|
||
if(async) {
|
||
this.asyncFilters.push(name);
|
||
}
|
||
this.filters[name] = wrapped;
|
||
return this;
|
||
},
|
||
|
||
getFilter: function(name) {
|
||
if(!this.filters[name]) {
|
||
throw new Error('filter not found: ' + name);
|
||
}
|
||
return this.filters[name];
|
||
},
|
||
|
||
resolveTemplate: function(loader, parentName, filename) {
|
||
var isRelative = (loader.isRelative && parentName)? loader.isRelative(filename) : false;
|
||
return (isRelative && loader.resolve)? loader.resolve(parentName, filename) : filename;
|
||
},
|
||
|
||
getTemplate: function(name, eagerCompile, parentName, ignoreMissing, cb) {
|
||
var that = this;
|
||
var tmpl = null;
|
||
if(name && name.raw) {
|
||
// this fixes autoescape for templates referenced in symbols
|
||
name = name.raw;
|
||
}
|
||
|
||
if(lib.isFunction(parentName)) {
|
||
cb = parentName;
|
||
parentName = null;
|
||
eagerCompile = eagerCompile || false;
|
||
}
|
||
|
||
if(lib.isFunction(eagerCompile)) {
|
||
cb = eagerCompile;
|
||
eagerCompile = false;
|
||
}
|
||
|
||
if (name instanceof Template) {
|
||
tmpl = name;
|
||
}
|
||
else if(typeof name !== 'string') {
|
||
throw new Error('template names must be a string: ' + name);
|
||
}
|
||
else {
|
||
for (var i = 0; i < this.loaders.length; i++) {
|
||
var _name = this.resolveTemplate(this.loaders[i], parentName, name);
|
||
tmpl = this.loaders[i].cache[_name];
|
||
if (tmpl) break;
|
||
}
|
||
}
|
||
|
||
if(tmpl) {
|
||
if(eagerCompile) {
|
||
tmpl.compile();
|
||
}
|
||
|
||
if(cb) {
|
||
cb(null, tmpl);
|
||
}
|
||
else {
|
||
return tmpl;
|
||
}
|
||
} else {
|
||
var syncResult;
|
||
var _this = this;
|
||
|
||
var createTemplate = function(err, info) {
|
||
if(!info && !err) {
|
||
if(!ignoreMissing) {
|
||
err = new Error('template not found: ' + name);
|
||
}
|
||
}
|
||
|
||
if (err) {
|
||
if(cb) {
|
||
cb(err);
|
||
}
|
||
else {
|
||
throw err;
|
||
}
|
||
}
|
||
else {
|
||
var tmpl;
|
||
if(info) {
|
||
tmpl = new Template(info.src, _this,
|
||
info.path, eagerCompile);
|
||
|
||
if(!info.noCache) {
|
||
info.loader.cache[name] = tmpl;
|
||
}
|
||
}
|
||
else {
|
||
tmpl = new Template('', _this,
|
||
'', eagerCompile);
|
||
}
|
||
|
||
if(cb) {
|
||
cb(null, tmpl);
|
||
}
|
||
else {
|
||
syncResult = tmpl;
|
||
}
|
||
}
|
||
};
|
||
|
||
lib.asyncIter(this.loaders, function(loader, i, next, done) {
|
||
function handle(err, src) {
|
||
if(err) {
|
||
done(err);
|
||
}
|
||
else if(src) {
|
||
src.loader = loader;
|
||
done(null, src);
|
||
}
|
||
else {
|
||
next();
|
||
}
|
||
}
|
||
|
||
// Resolve name relative to parentName
|
||
name = that.resolveTemplate(loader, parentName, name);
|
||
|
||
if(loader.async) {
|
||
loader.getSource(name, handle);
|
||
}
|
||
else {
|
||
handle(null, loader.getSource(name));
|
||
}
|
||
}, createTemplate);
|
||
|
||
return syncResult;
|
||
}
|
||
},
|
||
|
||
express: function(app) {
|
||
var env = this;
|
||
|
||
function NunjucksView(name, opts) {
|
||
this.name = name;
|
||
this.path = name;
|
||
this.defaultEngine = opts.defaultEngine;
|
||
this.ext = path.extname(name);
|
||
if (!this.ext && !this.defaultEngine) throw new Error('No default engine was specified and no extension was provided.');
|
||
if (!this.ext) this.name += (this.ext = ('.' !== this.defaultEngine[0] ? '.' : '') + this.defaultEngine);
|
||
}
|
||
|
||
NunjucksView.prototype.render = function(opts, cb) {
|
||
env.render(this.name, opts, cb);
|
||
};
|
||
|
||
app.set('view', NunjucksView);
|
||
return this;
|
||
},
|
||
|
||
render: function(name, ctx, cb) {
|
||
if(lib.isFunction(ctx)) {
|
||
cb = ctx;
|
||
ctx = null;
|
||
}
|
||
|
||
// We support a synchronous API to make it easier to migrate
|
||
// existing code to async. This works because if you don't do
|
||
// anything async work, the whole thing is actually run
|
||
// synchronously.
|
||
var syncResult = null;
|
||
|
||
this.getTemplate(name, function(err, tmpl) {
|
||
if(err && cb) {
|
||
callbackAsap(cb, err);
|
||
}
|
||
else if(err) {
|
||
throw err;
|
||
}
|
||
else {
|
||
syncResult = tmpl.render(ctx, cb);
|
||
}
|
||
});
|
||
|
||
return syncResult;
|
||
},
|
||
|
||
renderString: function(src, ctx, opts, cb) {
|
||
if(lib.isFunction(opts)) {
|
||
cb = opts;
|
||
opts = {};
|
||
}
|
||
opts = opts || {};
|
||
|
||
var tmpl = new Template(src, this, opts.path);
|
||
return tmpl.render(ctx, cb);
|
||
}
|
||
});
|
||
|
||
var Context = Obj.extend({
|
||
init: function(ctx, blocks, env) {
|
||
// Has to be tied to an environment so we can tap into its globals.
|
||
this.env = env || new Environment();
|
||
|
||
// Make a duplicate of ctx
|
||
this.ctx = {};
|
||
for(var k in ctx) {
|
||
if(ctx.hasOwnProperty(k)) {
|
||
this.ctx[k] = ctx[k];
|
||
}
|
||
}
|
||
|
||
this.blocks = {};
|
||
this.exported = [];
|
||
|
||
for(var name in blocks) {
|
||
this.addBlock(name, blocks[name]);
|
||
}
|
||
},
|
||
|
||
lookup: function(name) {
|
||
// This is one of the most called functions, so optimize for
|
||
// the typical case where the name isn't in the globals
|
||
if(name in this.env.globals && !(name in this.ctx)) {
|
||
return this.env.globals[name];
|
||
}
|
||
else {
|
||
return this.ctx[name];
|
||
}
|
||
},
|
||
|
||
setVariable: function(name, val) {
|
||
this.ctx[name] = val;
|
||
},
|
||
|
||
getVariables: function() {
|
||
return this.ctx;
|
||
},
|
||
|
||
addBlock: function(name, block) {
|
||
this.blocks[name] = this.blocks[name] || [];
|
||
this.blocks[name].push(block);
|
||
return this;
|
||
},
|
||
|
||
getBlock: function(name) {
|
||
if(!this.blocks[name]) {
|
||
throw new Error('unknown block "' + name + '"');
|
||
}
|
||
|
||
return this.blocks[name][0];
|
||
},
|
||
|
||
getSuper: function(env, name, block, frame, runtime, cb) {
|
||
var idx = lib.indexOf(this.blocks[name] || [], block);
|
||
var blk = this.blocks[name][idx + 1];
|
||
var context = this;
|
||
|
||
if(idx === -1 || !blk) {
|
||
throw new Error('no super block available for "' + name + '"');
|
||
}
|
||
|
||
blk(env, context, frame, runtime, cb);
|
||
},
|
||
|
||
addExport: function(name) {
|
||
this.exported.push(name);
|
||
},
|
||
|
||
getExported: function() {
|
||
var exported = {};
|
||
for(var i=0; i<this.exported.length; i++) {
|
||
var name = this.exported[i];
|
||
exported[name] = this.ctx[name];
|
||
}
|
||
return exported;
|
||
}
|
||
});
|
||
|
||
Template = Obj.extend({
|
||
init: function (src, env, path, eagerCompile) {
|
||
this.env = env || new Environment();
|
||
|
||
if(lib.isObject(src)) {
|
||
switch(src.type) {
|
||
case 'code': this.tmplProps = src.obj; break;
|
||
case 'string': this.tmplStr = src.obj; break;
|
||
}
|
||
}
|
||
else if(lib.isString(src)) {
|
||
this.tmplStr = src;
|
||
}
|
||
else {
|
||
throw new Error('src must be a string or an object describing ' +
|
||
'the source');
|
||
}
|
||
|
||
this.path = path;
|
||
|
||
if(eagerCompile) {
|
||
var _this = this;
|
||
try {
|
||
_this._compile();
|
||
}
|
||
catch(err) {
|
||
throw lib.prettifyError(this.path, this.env.opts.dev, err);
|
||
}
|
||
}
|
||
else {
|
||
this.compiled = false;
|
||
}
|
||
},
|
||
|
||
render: function(ctx, parentFrame, cb) {
|
||
if (typeof ctx === 'function') {
|
||
cb = ctx;
|
||
ctx = {};
|
||
}
|
||
else if (typeof parentFrame === 'function') {
|
||
cb = parentFrame;
|
||
parentFrame = null;
|
||
}
|
||
|
||
var forceAsync = true;
|
||
if(parentFrame) {
|
||
// If there is a frame, we are being called from internal
|
||
// code of another template, and the internal system
|
||
// depends on the sync/async nature of the parent template
|
||
// to be inherited, so force an async callback
|
||
forceAsync = false;
|
||
}
|
||
|
||
var _this = this;
|
||
// Catch compile errors for async rendering
|
||
try {
|
||
_this.compile();
|
||
} catch (_err) {
|
||
var err = lib.prettifyError(this.path, this.env.opts.dev, _err);
|
||
if (cb) return callbackAsap(cb, err);
|
||
else throw err;
|
||
}
|
||
|
||
var context = new Context(ctx || {}, _this.blocks, _this.env);
|
||
var frame = parentFrame ? parentFrame.push(true) : new Frame();
|
||
frame.topLevel = true;
|
||
var syncResult = null;
|
||
|
||
_this.rootRenderFunc(
|
||
_this.env,
|
||
context,
|
||
frame || new Frame(),
|
||
runtime,
|
||
function(err, res) {
|
||
if(err) {
|
||
err = lib.prettifyError(_this.path, _this.env.opts.dev, err);
|
||
}
|
||
|
||
if(cb) {
|
||
if(forceAsync) {
|
||
callbackAsap(cb, err, res);
|
||
}
|
||
else {
|
||
cb(err, res);
|
||
}
|
||
}
|
||
else {
|
||
if(err) { throw err; }
|
||
syncResult = res;
|
||
}
|
||
}
|
||
);
|
||
|
||
return syncResult;
|
||
},
|
||
|
||
|
||
getExported: function(ctx, parentFrame, cb) {
|
||
if (typeof ctx === 'function') {
|
||
cb = ctx;
|
||
ctx = {};
|
||
}
|
||
|
||
if (typeof parentFrame === 'function') {
|
||
cb = parentFrame;
|
||
parentFrame = null;
|
||
}
|
||
|
||
// Catch compile errors for async rendering
|
||
try {
|
||
this.compile();
|
||
} catch (e) {
|
||
if (cb) return cb(e);
|
||
else throw e;
|
||
}
|
||
|
||
var frame = parentFrame ? parentFrame.push() : new Frame();
|
||
frame.topLevel = true;
|
||
|
||
// Run the rootRenderFunc to populate the context with exported vars
|
||
var context = new Context(ctx || {}, this.blocks, this.env);
|
||
this.rootRenderFunc(this.env,
|
||
context,
|
||
frame,
|
||
runtime,
|
||
function(err) {
|
||
if ( err ) {
|
||
cb(err, null);
|
||
} else {
|
||
cb(null, context.getExported());
|
||
}
|
||
});
|
||
},
|
||
|
||
compile: function() {
|
||
if(!this.compiled) {
|
||
this._compile();
|
||
}
|
||
},
|
||
|
||
_compile: function() {
|
||
var props;
|
||
|
||
if(this.tmplProps) {
|
||
props = this.tmplProps;
|
||
}
|
||
else {
|
||
var source = compiler.compile(this.tmplStr,
|
||
this.env.asyncFilters,
|
||
this.env.extensionsList,
|
||
this.path,
|
||
this.env.opts);
|
||
|
||
/* jslint evil: true */
|
||
var func = new Function(source);
|
||
props = func();
|
||
}
|
||
|
||
this.blocks = this._getBlocks(props);
|
||
this.rootRenderFunc = props.root;
|
||
this.compiled = true;
|
||
},
|
||
|
||
_getBlocks: function(props) {
|
||
var blocks = {};
|
||
|
||
for(var k in props) {
|
||
if(k.slice(0, 2) === 'b_') {
|
||
blocks[k.slice(2)] = props[k];
|
||
}
|
||
}
|
||
|
||
return blocks;
|
||
}
|
||
});
|
||
|
||
module.exports = {
|
||
Environment: Environment,
|
||
Template: Template
|
||
};
|
||
|
||
|
||
/***/ },
|
||
/* 29 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
// rawAsap provides everything we need except exception management.
|
||
var rawAsap = __webpack_require__(30);
|
||
// RawTasks are recycled to reduce GC churn.
|
||
var freeTasks = [];
|
||
// We queue errors to ensure they are thrown in right order (FIFO).
|
||
// Array-as-queue is good enough here, since we are just dealing with exceptions.
|
||
var pendingErrors = [];
|
||
var requestErrorThrow = rawAsap.makeRequestCallFromTimer(throwFirstError);
|
||
|
||
function throwFirstError() {
|
||
if (pendingErrors.length) {
|
||
throw pendingErrors.shift();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Calls a task as soon as possible after returning, in its own event, with priority
|
||
* over other events like animation, reflow, and repaint. An error thrown from an
|
||
* event will not interrupt, nor even substantially slow down the processing of
|
||
* other events, but will be rather postponed to a lower priority event.
|
||
* @param {{call}} task A callable object, typically a function that takes no
|
||
* arguments.
|
||
*/
|
||
module.exports = asap;
|
||
function asap(task) {
|
||
var rawTask;
|
||
if (freeTasks.length) {
|
||
rawTask = freeTasks.pop();
|
||
} else {
|
||
rawTask = new RawTask();
|
||
}
|
||
rawTask.task = task;
|
||
rawAsap(rawTask);
|
||
}
|
||
|
||
// We wrap tasks with recyclable task objects. A task object implements
|
||
// `call`, just like a function.
|
||
function RawTask() {
|
||
this.task = null;
|
||
}
|
||
|
||
// The sole purpose of wrapping the task is to catch the exception and recycle
|
||
// the task object after its single use.
|
||
RawTask.prototype.call = function () {
|
||
try {
|
||
this.task.call();
|
||
} catch (error) {
|
||
if (asap.onerror) {
|
||
// This hook exists purely for testing purposes.
|
||
// Its name will be periodically randomized to break any code that
|
||
// depends on its existence.
|
||
asap.onerror(error);
|
||
} else {
|
||
// In a web browser, exceptions are not fatal. However, to avoid
|
||
// slowing down the queue of pending tasks, we rethrow the error in a
|
||
// lower priority turn.
|
||
pendingErrors.push(error);
|
||
requestErrorThrow();
|
||
}
|
||
} finally {
|
||
this.task = null;
|
||
freeTasks[freeTasks.length] = this;
|
||
}
|
||
};
|
||
|
||
|
||
/***/ },
|
||
/* 30 */
|
||
/***/ function(module, exports) {
|
||
|
||
/* WEBPACK VAR INJECTION */(function(global) {"use strict";
|
||
|
||
// Use the fastest means possible to execute a task in its own turn, with
|
||
// priority over other events including IO, animation, reflow, and redraw
|
||
// events in browsers.
|
||
//
|
||
// An exception thrown by a task will permanently interrupt the processing of
|
||
// subsequent tasks. The higher level `asap` function ensures that if an
|
||
// exception is thrown by a task, that the task queue will continue flushing as
|
||
// soon as possible, but if you use `rawAsap` directly, you are responsible to
|
||
// either ensure that no exceptions are thrown from your task, or to manually
|
||
// call `rawAsap.requestFlush` if an exception is thrown.
|
||
module.exports = rawAsap;
|
||
function rawAsap(task) {
|
||
if (!queue.length) {
|
||
requestFlush();
|
||
flushing = true;
|
||
}
|
||
// Equivalent to push, but avoids a function call.
|
||
queue[queue.length] = task;
|
||
}
|
||
|
||
var queue = [];
|
||
// Once a flush has been requested, no further calls to `requestFlush` are
|
||
// necessary until the next `flush` completes.
|
||
var flushing = false;
|
||
// `requestFlush` is an implementation-specific method that attempts to kick
|
||
// off a `flush` event as quickly as possible. `flush` will attempt to exhaust
|
||
// the event queue before yielding to the browser's own event loop.
|
||
var requestFlush;
|
||
// The position of the next task to execute in the task queue. This is
|
||
// preserved between calls to `flush` so that it can be resumed if
|
||
// a task throws an exception.
|
||
var index = 0;
|
||
// If a task schedules additional tasks recursively, the task queue can grow
|
||
// unbounded. To prevent memory exhaustion, the task queue will periodically
|
||
// truncate already-completed tasks.
|
||
var capacity = 1024;
|
||
|
||
// The flush function processes all tasks that have been scheduled with
|
||
// `rawAsap` unless and until one of those tasks throws an exception.
|
||
// If a task throws an exception, `flush` ensures that its state will remain
|
||
// consistent and will resume where it left off when called again.
|
||
// However, `flush` does not make any arrangements to be called again if an
|
||
// exception is thrown.
|
||
function flush() {
|
||
while (index < queue.length) {
|
||
var currentIndex = index;
|
||
// Advance the index before calling the task. This ensures that we will
|
||
// begin flushing on the next task the task throws an error.
|
||
index = index + 1;
|
||
queue[currentIndex].call();
|
||
// Prevent leaking memory for long chains of recursive calls to `asap`.
|
||
// If we call `asap` within tasks scheduled by `asap`, the queue will
|
||
// grow, but to avoid an O(n) walk for every task we execute, we don't
|
||
// shift tasks off the queue after they have been executed.
|
||
// Instead, we periodically shift 1024 tasks off the queue.
|
||
if (index > capacity) {
|
||
// Manually shift all values starting at the index back to the
|
||
// beginning of the queue.
|
||
for (var scan = 0, newLength = queue.length - index; scan < newLength; scan++) {
|
||
queue[scan] = queue[scan + index];
|
||
}
|
||
queue.length -= index;
|
||
index = 0;
|
||
}
|
||
}
|
||
queue.length = 0;
|
||
index = 0;
|
||
flushing = false;
|
||
}
|
||
|
||
// `requestFlush` is implemented using a strategy based on data collected from
|
||
// every available SauceLabs Selenium web driver worker at time of writing.
|
||
// https://docs.google.com/spreadsheets/d/1mG-5UYGup5qxGdEMWkhP6BWCz053NUb2E1QoUTU16uA/edit#gid=783724593
|
||
|
||
// Safari 6 and 6.1 for desktop, iPad, and iPhone are the only browsers that
|
||
// have WebKitMutationObserver but not un-prefixed MutationObserver.
|
||
// Must use `global` instead of `window` to work in both frames and web
|
||
// workers. `global` is a provision of Browserify, Mr, Mrs, or Mop.
|
||
var BrowserMutationObserver = global.MutationObserver || global.WebKitMutationObserver;
|
||
|
||
// MutationObservers are desirable because they have high priority and work
|
||
// reliably everywhere they are implemented.
|
||
// They are implemented in all modern browsers.
|
||
//
|
||
// - Android 4-4.3
|
||
// - Chrome 26-34
|
||
// - Firefox 14-29
|
||
// - Internet Explorer 11
|
||
// - iPad Safari 6-7.1
|
||
// - iPhone Safari 7-7.1
|
||
// - Safari 6-7
|
||
if (typeof BrowserMutationObserver === "function") {
|
||
requestFlush = makeRequestCallFromMutationObserver(flush);
|
||
|
||
// MessageChannels are desirable because they give direct access to the HTML
|
||
// task queue, are implemented in Internet Explorer 10, Safari 5.0-1, and Opera
|
||
// 11-12, and in web workers in many engines.
|
||
// Although message channels yield to any queued rendering and IO tasks, they
|
||
// would be better than imposing the 4ms delay of timers.
|
||
// However, they do not work reliably in Internet Explorer or Safari.
|
||
|
||
// Internet Explorer 10 is the only browser that has setImmediate but does
|
||
// not have MutationObservers.
|
||
// Although setImmediate yields to the browser's renderer, it would be
|
||
// preferrable to falling back to setTimeout since it does not have
|
||
// the minimum 4ms penalty.
|
||
// Unfortunately there appears to be a bug in Internet Explorer 10 Mobile (and
|
||
// Desktop to a lesser extent) that renders both setImmediate and
|
||
// MessageChannel useless for the purposes of ASAP.
|
||
// https://github.com/kriskowal/q/issues/396
|
||
|
||
// Timers are implemented universally.
|
||
// We fall back to timers in workers in most engines, and in foreground
|
||
// contexts in the following browsers.
|
||
// However, note that even this simple case requires nuances to operate in a
|
||
// broad spectrum of browsers.
|
||
//
|
||
// - Firefox 3-13
|
||
// - Internet Explorer 6-9
|
||
// - iPad Safari 4.3
|
||
// - Lynx 2.8.7
|
||
} else {
|
||
requestFlush = makeRequestCallFromTimer(flush);
|
||
}
|
||
|
||
// `requestFlush` requests that the high priority event queue be flushed as
|
||
// soon as possible.
|
||
// This is useful to prevent an error thrown in a task from stalling the event
|
||
// queue if the exception handled by Node.js’s
|
||
// `process.on("uncaughtException")` or by a domain.
|
||
rawAsap.requestFlush = requestFlush;
|
||
|
||
// To request a high priority event, we induce a mutation observer by toggling
|
||
// the text of a text node between "1" and "-1".
|
||
function makeRequestCallFromMutationObserver(callback) {
|
||
var toggle = 1;
|
||
var observer = new BrowserMutationObserver(callback);
|
||
var node = document.createTextNode("");
|
||
observer.observe(node, {characterData: true});
|
||
return function requestCall() {
|
||
toggle = -toggle;
|
||
node.data = toggle;
|
||
};
|
||
}
|
||
|
||
// The message channel technique was discovered by Malte Ubl and was the
|
||
// original foundation for this library.
|
||
// http://www.nonblocking.io/2011/06/windownexttick.html
|
||
|
||
// Safari 6.0.5 (at least) intermittently fails to create message ports on a
|
||
// page's first load. Thankfully, this version of Safari supports
|
||
// MutationObservers, so we don't need to fall back in that case.
|
||
|
||
// function makeRequestCallFromMessageChannel(callback) {
|
||
// var channel = new MessageChannel();
|
||
// channel.port1.onmessage = callback;
|
||
// return function requestCall() {
|
||
// channel.port2.postMessage(0);
|
||
// };
|
||
// }
|
||
|
||
// For reasons explained above, we are also unable to use `setImmediate`
|
||
// under any circumstances.
|
||
// Even if we were, there is another bug in Internet Explorer 10.
|
||
// It is not sufficient to assign `setImmediate` to `requestFlush` because
|
||
// `setImmediate` must be called *by name* and therefore must be wrapped in a
|
||
// closure.
|
||
// Never forget.
|
||
|
||
// function makeRequestCallFromSetImmediate(callback) {
|
||
// return function requestCall() {
|
||
// setImmediate(callback);
|
||
// };
|
||
// }
|
||
|
||
// Safari 6.0 has a problem where timers will get lost while the user is
|
||
// scrolling. This problem does not impact ASAP because Safari 6.0 supports
|
||
// mutation observers, so that implementation is used instead.
|
||
// However, if we ever elect to use timers in Safari, the prevalent work-around
|
||
// is to add a scroll event listener that calls for a flush.
|
||
|
||
// `setTimeout` does not call the passed callback if the delay is less than
|
||
// approximately 7 in web workers in Firefox 8 through 18, and sometimes not
|
||
// even then.
|
||
|
||
function makeRequestCallFromTimer(callback) {
|
||
return function requestCall() {
|
||
// We dispatch a timeout with a specified delay of 0 for engines that
|
||
// can reliably accommodate that request. This will usually be snapped
|
||
// to a 4 milisecond delay, but once we're flushing, there's no delay
|
||
// between events.
|
||
var timeoutHandle = setTimeout(handleTimer, 0);
|
||
// However, since this timer gets frequently dropped in Firefox
|
||
// workers, we enlist an interval handle that will try to fire
|
||
// an event 20 times per second until it succeeds.
|
||
var intervalHandle = setInterval(handleTimer, 50);
|
||
|
||
function handleTimer() {
|
||
// Whichever timer succeeds will cancel both timers and
|
||
// execute the callback.
|
||
clearTimeout(timeoutHandle);
|
||
clearInterval(intervalHandle);
|
||
callback();
|
||
}
|
||
};
|
||
}
|
||
|
||
// This is for `asap.js` only.
|
||
// Its name will be periodically randomized to break any code that depends on
|
||
// its existence.
|
||
rawAsap.makeRequestCallFromTimer = makeRequestCallFromTimer;
|
||
|
||
// ASAP was originally a nextTick shim included in Q. This was factored out
|
||
// into this ASAP package. It was later adapted to RSVP which made further
|
||
// amendments. These decisions, particularly to marginalize MessageChannel and
|
||
// to capture the MutationObserver implementation in a closure, were integrated
|
||
// back into ASAP proper.
|
||
// https://github.com/tildeio/rsvp.js/blob/cddf7232546a9cf858524b75cde6f9edf72620a7/lib/rsvp/asap.js
|
||
|
||
/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
|
||
|
||
/***/ },
|
||
/* 31 */
|
||
/***/ function(module, exports) {
|
||
|
||
'use strict';
|
||
|
||
// A simple class system, more documentation to come
|
||
|
||
function extend(cls, name, props) {
|
||
// This does that same thing as Object.create, but with support for IE8
|
||
var F = function() {};
|
||
F.prototype = cls.prototype;
|
||
var prototype = new F();
|
||
|
||
// jshint undef: false
|
||
var fnTest = /xyz/.test(function(){ xyz; }) ? /\bparent\b/ : /.*/;
|
||
props = props || {};
|
||
|
||
for(var k in props) {
|
||
var src = props[k];
|
||
var parent = prototype[k];
|
||
|
||
if(typeof parent === 'function' &&
|
||
typeof src === 'function' &&
|
||
fnTest.test(src)) {
|
||
/*jshint -W083 */
|
||
prototype[k] = (function (src, parent) {
|
||
return function() {
|
||
// Save the current parent method
|
||
var tmp = this.parent;
|
||
|
||
// Set parent to the previous method, call, and restore
|
||
this.parent = parent;
|
||
var res = src.apply(this, arguments);
|
||
this.parent = tmp;
|
||
|
||
return res;
|
||
};
|
||
})(src, parent);
|
||
}
|
||
else {
|
||
prototype[k] = src;
|
||
}
|
||
}
|
||
|
||
prototype.typename = name;
|
||
|
||
var new_cls = function() {
|
||
if(prototype.init) {
|
||
prototype.init.apply(this, arguments);
|
||
}
|
||
};
|
||
|
||
new_cls.prototype = prototype;
|
||
new_cls.prototype.constructor = new_cls;
|
||
|
||
new_cls.extend = function(name, props) {
|
||
if(typeof name === 'object') {
|
||
props = name;
|
||
name = 'anonymous';
|
||
}
|
||
return extend(new_cls, name, props);
|
||
};
|
||
|
||
return new_cls;
|
||
}
|
||
|
||
module.exports = extend(Object, 'Object', {});
|
||
|
||
|
||
/***/ },
|
||
/* 32 */
|
||
/***/ function(module, exports) {
|
||
|
||
|
||
|
||
/***/ },
|
||
/* 33 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
'use strict';
|
||
|
||
var lib = __webpack_require__(27);
|
||
var r = __webpack_require__(34);
|
||
|
||
function normalize(value, defaultValue) {
|
||
if(value === null || value === undefined || value === false) {
|
||
return defaultValue;
|
||
}
|
||
return value;
|
||
}
|
||
|
||
var filters = {
|
||
abs: function(n) {
|
||
return Math.abs(n);
|
||
},
|
||
|
||
batch: function(arr, linecount, fill_with) {
|
||
var i;
|
||
var res = [];
|
||
var tmp = [];
|
||
|
||
for(i = 0; i < arr.length; i++) {
|
||
if(i % linecount === 0 && tmp.length) {
|
||
res.push(tmp);
|
||
tmp = [];
|
||
}
|
||
|
||
tmp.push(arr[i]);
|
||
}
|
||
|
||
if(tmp.length) {
|
||
if(fill_with) {
|
||
for(i = tmp.length; i < linecount; i++) {
|
||
tmp.push(fill_with);
|
||
}
|
||
}
|
||
|
||
res.push(tmp);
|
||
}
|
||
|
||
return res;
|
||
},
|
||
|
||
capitalize: function(str) {
|
||
str = normalize(str, '');
|
||
var ret = str.toLowerCase();
|
||
return r.copySafeness(str, ret.charAt(0).toUpperCase() + ret.slice(1));
|
||
},
|
||
|
||
center: function(str, width) {
|
||
str = normalize(str, '');
|
||
width = width || 80;
|
||
|
||
if(str.length >= width) {
|
||
return str;
|
||
}
|
||
|
||
var spaces = width - str.length;
|
||
var pre = lib.repeat(' ', spaces/2 - spaces % 2);
|
||
var post = lib.repeat(' ', spaces/2);
|
||
return r.copySafeness(str, pre + str + post);
|
||
},
|
||
|
||
'default': function(val, def, bool) {
|
||
if(bool) {
|
||
return val ? val : def;
|
||
}
|
||
else {
|
||
return (val !== undefined) ? val : def;
|
||
}
|
||
},
|
||
|
||
dictsort: function(val, case_sensitive, by) {
|
||
if (!lib.isObject(val)) {
|
||
throw new lib.TemplateError('dictsort filter: val must be an object');
|
||
}
|
||
|
||
var array = [];
|
||
for (var k in val) {
|
||
// deliberately include properties from the object's prototype
|
||
array.push([k,val[k]]);
|
||
}
|
||
|
||
var si;
|
||
if (by === undefined || by === 'key') {
|
||
si = 0;
|
||
} else if (by === 'value') {
|
||
si = 1;
|
||
} else {
|
||
throw new lib.TemplateError(
|
||
'dictsort filter: You can only sort by either key or value');
|
||
}
|
||
|
||
array.sort(function(t1, t2) {
|
||
var a = t1[si];
|
||
var b = t2[si];
|
||
|
||
if (!case_sensitive) {
|
||
if (lib.isString(a)) {
|
||
a = a.toUpperCase();
|
||
}
|
||
if (lib.isString(b)) {
|
||
b = b.toUpperCase();
|
||
}
|
||
}
|
||
|
||
return a > b ? 1 : (a === b ? 0 : -1);
|
||
});
|
||
|
||
return array;
|
||
},
|
||
|
||
dump: function(obj) {
|
||
return JSON.stringify(obj);
|
||
},
|
||
|
||
escape: function(str) {
|
||
if(typeof str === 'string') {
|
||
return r.markSafe(lib.escape(str));
|
||
}
|
||
return str;
|
||
},
|
||
|
||
safe: function(str) {
|
||
return r.markSafe(str);
|
||
},
|
||
|
||
first: function(arr) {
|
||
return arr[0];
|
||
},
|
||
|
||
groupby: function(arr, attr) {
|
||
return lib.groupBy(arr, attr);
|
||
},
|
||
|
||
indent: function(str, width, indentfirst) {
|
||
str = normalize(str, '');
|
||
|
||
if (str === '') return '';
|
||
|
||
width = width || 4;
|
||
var res = '';
|
||
var lines = str.split('\n');
|
||
var sp = lib.repeat(' ', width);
|
||
|
||
for(var i=0; i<lines.length; i++) {
|
||
if(i === 0 && !indentfirst) {
|
||
res += lines[i] + '\n';
|
||
}
|
||
else {
|
||
res += sp + lines[i] + '\n';
|
||
}
|
||
}
|
||
|
||
return r.copySafeness(str, res);
|
||
},
|
||
|
||
join: function(arr, del, attr) {
|
||
del = del || '';
|
||
|
||
if(attr) {
|
||
arr = lib.map(arr, function(v) {
|
||
return v[attr];
|
||
});
|
||
}
|
||
|
||
return arr.join(del);
|
||
},
|
||
|
||
last: function(arr) {
|
||
return arr[arr.length-1];
|
||
},
|
||
|
||
length: function(val) {
|
||
var value = normalize(val, '');
|
||
|
||
return value !== undefined ? value.length : 0;
|
||
},
|
||
|
||
list: function(val) {
|
||
if(lib.isString(val)) {
|
||
return val.split('');
|
||
}
|
||
else if(lib.isObject(val)) {
|
||
var keys = [];
|
||
|
||
if(Object.keys) {
|
||
keys = Object.keys(val);
|
||
}
|
||
else {
|
||
for(var k in val) {
|
||
keys.push(k);
|
||
}
|
||
}
|
||
|
||
return lib.map(keys, function(k) {
|
||
return { key: k,
|
||
value: val[k] };
|
||
});
|
||
}
|
||
else if(lib.isArray(val)) {
|
||
return val;
|
||
}
|
||
else {
|
||
throw new lib.TemplateError('list filter: type not iterable');
|
||
}
|
||
},
|
||
|
||
lower: function(str) {
|
||
str = normalize(str, '');
|
||
return str.toLowerCase();
|
||
},
|
||
|
||
random: function(arr) {
|
||
return arr[Math.floor(Math.random() * arr.length)];
|
||
},
|
||
|
||
rejectattr: function(arr, attr) {
|
||
return arr.filter(function (item) {
|
||
return !item[attr];
|
||
});
|
||
},
|
||
|
||
selectattr: function(arr, attr) {
|
||
return arr.filter(function (item) {
|
||
return !!item[attr];
|
||
});
|
||
},
|
||
|
||
replace: function(str, old, new_, maxCount) {
|
||
var originalStr = str;
|
||
|
||
if (old instanceof RegExp) {
|
||
return str.replace(old, new_);
|
||
}
|
||
|
||
if(typeof maxCount === 'undefined'){
|
||
maxCount = -1;
|
||
}
|
||
|
||
var res = ''; // Output
|
||
|
||
// Cast Numbers in the search term to string
|
||
if(typeof old === 'number'){
|
||
old = old + '';
|
||
}
|
||
else if(typeof old !== 'string') {
|
||
// If it is something other than number or string,
|
||
// return the original string
|
||
return str;
|
||
}
|
||
|
||
// Cast numbers in the replacement to string
|
||
if(typeof str === 'number'){
|
||
str = str + '';
|
||
}
|
||
|
||
// If by now, we don't have a string, throw it back
|
||
if(typeof str !== 'string' && !(str instanceof r.SafeString)){
|
||
return str;
|
||
}
|
||
|
||
// ShortCircuits
|
||
if(old === ''){
|
||
// Mimic the python behaviour: empty string is replaced
|
||
// by replacement e.g. "abc"|replace("", ".") -> .a.b.c.
|
||
res = new_ + str.split('').join(new_) + new_;
|
||
return r.copySafeness(str, res);
|
||
}
|
||
|
||
var nextIndex = str.indexOf(old);
|
||
// if # of replacements to perform is 0, or the string to does
|
||
// not contain the old value, return the string
|
||
if(maxCount === 0 || nextIndex === -1){
|
||
return str;
|
||
}
|
||
|
||
var pos = 0;
|
||
var count = 0; // # of replacements made
|
||
|
||
while(nextIndex > -1 && (maxCount === -1 || count < maxCount)){
|
||
// Grab the next chunk of src string and add it with the
|
||
// replacement, to the result
|
||
res += str.substring(pos, nextIndex) + new_;
|
||
// Increment our pointer in the src string
|
||
pos = nextIndex + old.length;
|
||
count++;
|
||
// See if there are any more replacements to be made
|
||
nextIndex = str.indexOf(old, pos);
|
||
}
|
||
|
||
// We've either reached the end, or done the max # of
|
||
// replacements, tack on any remaining string
|
||
if(pos < str.length) {
|
||
res += str.substring(pos);
|
||
}
|
||
|
||
return r.copySafeness(originalStr, res);
|
||
},
|
||
|
||
reverse: function(val) {
|
||
var arr;
|
||
if(lib.isString(val)) {
|
||
arr = filters.list(val);
|
||
}
|
||
else {
|
||
// Copy it
|
||
arr = lib.map(val, function(v) { return v; });
|
||
}
|
||
|
||
arr.reverse();
|
||
|
||
if(lib.isString(val)) {
|
||
return r.copySafeness(val, arr.join(''));
|
||
}
|
||
return arr;
|
||
},
|
||
|
||
round: function(val, precision, method) {
|
||
precision = precision || 0;
|
||
var factor = Math.pow(10, precision);
|
||
var rounder;
|
||
|
||
if(method === 'ceil') {
|
||
rounder = Math.ceil;
|
||
}
|
||
else if(method === 'floor') {
|
||
rounder = Math.floor;
|
||
}
|
||
else {
|
||
rounder = Math.round;
|
||
}
|
||
|
||
return rounder(val * factor) / factor;
|
||
},
|
||
|
||
slice: function(arr, slices, fillWith) {
|
||
var sliceLength = Math.floor(arr.length / slices);
|
||
var extra = arr.length % slices;
|
||
var offset = 0;
|
||
var res = [];
|
||
|
||
for(var i=0; i<slices; i++) {
|
||
var start = offset + i * sliceLength;
|
||
if(i < extra) {
|
||
offset++;
|
||
}
|
||
var end = offset + (i + 1) * sliceLength;
|
||
|
||
var slice = arr.slice(start, end);
|
||
if(fillWith && i >= extra) {
|
||
slice.push(fillWith);
|
||
}
|
||
res.push(slice);
|
||
}
|
||
|
||
return res;
|
||
},
|
||
|
||
sum: function(arr, attr, start) {
|
||
var sum = 0;
|
||
|
||
if(typeof start === 'number'){
|
||
sum += start;
|
||
}
|
||
|
||
if(attr) {
|
||
arr = lib.map(arr, function(v) {
|
||
return v[attr];
|
||
});
|
||
}
|
||
|
||
for(var i = 0; i < arr.length; i++) {
|
||
sum += arr[i];
|
||
}
|
||
|
||
return sum;
|
||
},
|
||
|
||
sort: r.makeMacro(['value', 'reverse', 'case_sensitive', 'attribute'], [], function(arr, reverse, caseSens, attr) {
|
||
// Copy it
|
||
arr = lib.map(arr, function(v) { return v; });
|
||
|
||
arr.sort(function(a, b) {
|
||
var x, y;
|
||
|
||
if(attr) {
|
||
x = a[attr];
|
||
y = b[attr];
|
||
}
|
||
else {
|
||
x = a;
|
||
y = b;
|
||
}
|
||
|
||
if(!caseSens && lib.isString(x) && lib.isString(y)) {
|
||
x = x.toLowerCase();
|
||
y = y.toLowerCase();
|
||
}
|
||
|
||
if(x < y) {
|
||
return reverse ? 1 : -1;
|
||
}
|
||
else if(x > y) {
|
||
return reverse ? -1: 1;
|
||
}
|
||
else {
|
||
return 0;
|
||
}
|
||
});
|
||
|
||
return arr;
|
||
}),
|
||
|
||
string: function(obj) {
|
||
return r.copySafeness(obj, obj);
|
||
},
|
||
|
||
striptags: function(input, preserve_linebreaks) {
|
||
input = normalize(input, '');
|
||
preserve_linebreaks = preserve_linebreaks || false;
|
||
var tags = /<\/?([a-z][a-z0-9]*)\b[^>]*>|<!--[\s\S]*?-->/gi;
|
||
var trimmedInput = filters.trim(input.replace(tags, ''));
|
||
var res = '';
|
||
if (preserve_linebreaks) {
|
||
res = trimmedInput
|
||
.replace(/^ +| +$/gm, '') // remove leading and trailing spaces
|
||
.replace(/ +/g, ' ') // squash adjacent spaces
|
||
.replace(/(\r\n)/g, '\n') // normalize linebreaks (CRLF -> LF)
|
||
.replace(/\n\n\n+/g, '\n\n'); // squash abnormal adjacent linebreaks
|
||
} else {
|
||
res = trimmedInput.replace(/\s+/gi, ' ');
|
||
}
|
||
return r.copySafeness(input, res);
|
||
},
|
||
|
||
title: function(str) {
|
||
str = normalize(str, '');
|
||
var words = str.split(' ');
|
||
for(var i = 0; i < words.length; i++) {
|
||
words[i] = filters.capitalize(words[i]);
|
||
}
|
||
return r.copySafeness(str, words.join(' '));
|
||
},
|
||
|
||
trim: function(str) {
|
||
return r.copySafeness(str, str.replace(/^\s*|\s*$/g, ''));
|
||
},
|
||
|
||
truncate: function(input, length, killwords, end) {
|
||
var orig = input;
|
||
input = normalize(input, '');
|
||
length = length || 255;
|
||
|
||
if (input.length <= length)
|
||
return input;
|
||
|
||
if (killwords) {
|
||
input = input.substring(0, length);
|
||
} else {
|
||
var idx = input.lastIndexOf(' ', length);
|
||
if(idx === -1) {
|
||
idx = length;
|
||
}
|
||
|
||
input = input.substring(0, idx);
|
||
}
|
||
|
||
input += (end !== undefined && end !== null) ? end : '...';
|
||
return r.copySafeness(orig, input);
|
||
},
|
||
|
||
upper: function(str) {
|
||
str = normalize(str, '');
|
||
return str.toUpperCase();
|
||
},
|
||
|
||
urlencode: function(obj) {
|
||
var enc = encodeURIComponent;
|
||
if (lib.isString(obj)) {
|
||
return enc(obj);
|
||
} else {
|
||
var parts;
|
||
if (lib.isArray(obj)) {
|
||
parts = obj.map(function(item) {
|
||
return enc(item[0]) + '=' + enc(item[1]);
|
||
});
|
||
} else {
|
||
parts = [];
|
||
for (var k in obj) {
|
||
if (obj.hasOwnProperty(k)) {
|
||
parts.push(enc(k) + '=' + enc(obj[k]));
|
||
}
|
||
}
|
||
}
|
||
return parts.join('&');
|
||
}
|
||
},
|
||
|
||
urlize: function(str, length, nofollow) {
|
||
if (isNaN(length)) length = Infinity;
|
||
|
||
var noFollowAttr = (nofollow === true ? ' rel="nofollow"' : '');
|
||
|
||
// For the jinja regexp, see
|
||
// https://github.com/mitsuhiko/jinja2/blob/f15b814dcba6aa12bc74d1f7d0c881d55f7126be/jinja2/utils.py#L20-L23
|
||
var puncRE = /^(?:\(|<|<)?(.*?)(?:\.|,|\)|\n|>)?$/;
|
||
// from http://blog.gerv.net/2011/05/html5_email_address_regexp/
|
||
var emailRE = /^[\w.!#$%&'*+\-\/=?\^`{|}~]+@[a-z\d\-]+(\.[a-z\d\-]+)+$/i;
|
||
var httpHttpsRE = /^https?:\/\/.*$/;
|
||
var wwwRE = /^www\./;
|
||
var tldRE = /\.(?:org|net|com)(?:\:|\/|$)/;
|
||
|
||
var words = str.split(/(\s+)/).filter(function(word) {
|
||
// If the word has no length, bail. This can happen for str with
|
||
// trailing whitespace.
|
||
return word && word.length;
|
||
}).map(function(word) {
|
||
var matches = word.match(puncRE);
|
||
var possibleUrl = matches && matches[1] || word;
|
||
|
||
// url that starts with http or https
|
||
if (httpHttpsRE.test(possibleUrl))
|
||
return '<a href="' + possibleUrl + '"' + noFollowAttr + '>' + possibleUrl.substr(0, length) + '</a>';
|
||
|
||
// url that starts with www.
|
||
if (wwwRE.test(possibleUrl))
|
||
return '<a href="http://' + possibleUrl + '"' + noFollowAttr + '>' + possibleUrl.substr(0, length) + '</a>';
|
||
|
||
// an email address of the form username@domain.tld
|
||
if (emailRE.test(possibleUrl))
|
||
return '<a href="mailto:' + possibleUrl + '">' + possibleUrl + '</a>';
|
||
|
||
// url that ends in .com, .org or .net that is not an email address
|
||
if (tldRE.test(possibleUrl))
|
||
return '<a href="http://' + possibleUrl + '"' + noFollowAttr + '>' + possibleUrl.substr(0, length) + '</a>';
|
||
|
||
return word;
|
||
|
||
});
|
||
|
||
return words.join('');
|
||
},
|
||
|
||
wordcount: function(str) {
|
||
str = normalize(str, '');
|
||
var words = (str) ? str.match(/\w+/g) : null;
|
||
return (words) ? words.length : null;
|
||
},
|
||
|
||
'float': function(val, def) {
|
||
var res = parseFloat(val);
|
||
return isNaN(res) ? def : res;
|
||
},
|
||
|
||
'int': function(val, def) {
|
||
var res = parseInt(val, 10);
|
||
return isNaN(res) ? def : res;
|
||
}
|
||
};
|
||
|
||
// Aliases
|
||
filters.d = filters['default'];
|
||
filters.e = filters.escape;
|
||
|
||
module.exports = filters;
|
||
|
||
|
||
/***/ },
|
||
/* 34 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
'use strict';
|
||
|
||
var lib = __webpack_require__(27);
|
||
var Obj = __webpack_require__(31);
|
||
|
||
// Frames keep track of scoping both at compile-time and run-time so
|
||
// we know how to access variables. Block tags can introduce special
|
||
// variables, for example.
|
||
var Frame = Obj.extend({
|
||
init: function(parent, isolateWrites) {
|
||
this.variables = {};
|
||
this.parent = parent;
|
||
this.topLevel = false;
|
||
// if this is true, writes (set) should never propagate upwards past
|
||
// this frame to its parent (though reads may).
|
||
this.isolateWrites = isolateWrites;
|
||
},
|
||
|
||
set: function(name, val, resolveUp) {
|
||
// Allow variables with dots by automatically creating the
|
||
// nested structure
|
||
var parts = name.split('.');
|
||
var obj = this.variables;
|
||
var frame = this;
|
||
|
||
if(resolveUp) {
|
||
if((frame = this.resolve(parts[0], true))) {
|
||
frame.set(name, val);
|
||
return;
|
||
}
|
||
}
|
||
|
||
for(var i=0; i<parts.length - 1; i++) {
|
||
var id = parts[i];
|
||
|
||
if(!obj[id]) {
|
||
obj[id] = {};
|
||
}
|
||
obj = obj[id];
|
||
}
|
||
|
||
obj[parts[parts.length - 1]] = val;
|
||
},
|
||
|
||
get: function(name) {
|
||
var val = this.variables[name];
|
||
if(val !== undefined && val !== null) {
|
||
return val;
|
||
}
|
||
return null;
|
||
},
|
||
|
||
lookup: function(name) {
|
||
var p = this.parent;
|
||
var val = this.variables[name];
|
||
if(val !== undefined && val !== null) {
|
||
return val;
|
||
}
|
||
return p && p.lookup(name);
|
||
},
|
||
|
||
resolve: function(name, forWrite) {
|
||
var p = (forWrite && this.isolateWrites) ? undefined : this.parent;
|
||
var val = this.variables[name];
|
||
if(val !== undefined && val !== null) {
|
||
return this;
|
||
}
|
||
return p && p.resolve(name);
|
||
},
|
||
|
||
push: function(isolateWrites) {
|
||
return new Frame(this, isolateWrites);
|
||
},
|
||
|
||
pop: function() {
|
||
return this.parent;
|
||
}
|
||
});
|
||
|
||
function makeMacro(argNames, kwargNames, func) {
|
||
return function() {
|
||
var argCount = numArgs(arguments);
|
||
var args;
|
||
var kwargs = getKeywordArgs(arguments);
|
||
var i;
|
||
|
||
if(argCount > argNames.length) {
|
||
args = Array.prototype.slice.call(arguments, 0, argNames.length);
|
||
|
||
// Positional arguments that should be passed in as
|
||
// keyword arguments (essentially default values)
|
||
var vals = Array.prototype.slice.call(arguments, args.length, argCount);
|
||
for(i = 0; i < vals.length; i++) {
|
||
if(i < kwargNames.length) {
|
||
kwargs[kwargNames[i]] = vals[i];
|
||
}
|
||
}
|
||
|
||
args.push(kwargs);
|
||
}
|
||
else if(argCount < argNames.length) {
|
||
args = Array.prototype.slice.call(arguments, 0, argCount);
|
||
|
||
for(i = argCount; i < argNames.length; i++) {
|
||
var arg = argNames[i];
|
||
|
||
// Keyword arguments that should be passed as
|
||
// positional arguments, i.e. the caller explicitly
|
||
// used the name of a positional arg
|
||
args.push(kwargs[arg]);
|
||
delete kwargs[arg];
|
||
}
|
||
|
||
args.push(kwargs);
|
||
}
|
||
else {
|
||
args = arguments;
|
||
}
|
||
|
||
return func.apply(this, args);
|
||
};
|
||
}
|
||
|
||
function makeKeywordArgs(obj) {
|
||
obj.__keywords = true;
|
||
return obj;
|
||
}
|
||
|
||
function getKeywordArgs(args) {
|
||
var len = args.length;
|
||
if(len) {
|
||
var lastArg = args[len - 1];
|
||
if(lastArg && lastArg.hasOwnProperty('__keywords')) {
|
||
return lastArg;
|
||
}
|
||
}
|
||
return {};
|
||
}
|
||
|
||
function numArgs(args) {
|
||
var len = args.length;
|
||
if(len === 0) {
|
||
return 0;
|
||
}
|
||
|
||
var lastArg = args[len - 1];
|
||
if(lastArg && lastArg.hasOwnProperty('__keywords')) {
|
||
return len - 1;
|
||
}
|
||
else {
|
||
return len;
|
||
}
|
||
}
|
||
|
||
// A SafeString object indicates that the string should not be
|
||
// autoescaped. This happens magically because autoescaping only
|
||
// occurs on primitive string objects.
|
||
function SafeString(val) {
|
||
if(typeof val !== 'string') {
|
||
return val;
|
||
}
|
||
|
||
this.val = val;
|
||
this.length = val.length;
|
||
}
|
||
|
||
SafeString.prototype = Object.create(String.prototype, {
|
||
length: { writable: true, configurable: true, value: 0 }
|
||
});
|
||
SafeString.prototype.valueOf = function() {
|
||
return this.val;
|
||
};
|
||
SafeString.prototype.toString = function() {
|
||
return this.val;
|
||
};
|
||
|
||
function copySafeness(dest, target) {
|
||
if(dest instanceof SafeString) {
|
||
return new SafeString(target);
|
||
}
|
||
return target.toString();
|
||
}
|
||
|
||
function markSafe(val) {
|
||
var type = typeof val;
|
||
|
||
if(type === 'string') {
|
||
return new SafeString(val);
|
||
}
|
||
else if(type !== 'function') {
|
||
return val;
|
||
}
|
||
else {
|
||
return function() {
|
||
var ret = val.apply(this, arguments);
|
||
|
||
if(typeof ret === 'string') {
|
||
return new SafeString(ret);
|
||
}
|
||
|
||
return ret;
|
||
};
|
||
}
|
||
}
|
||
|
||
function suppressValue(val, autoescape) {
|
||
val = (val !== undefined && val !== null) ? val : '';
|
||
|
||
if(autoescape && typeof val === 'string') {
|
||
val = lib.escape(val);
|
||
}
|
||
|
||
return val;
|
||
}
|
||
|
||
function ensureDefined(val, lineno, colno) {
|
||
if(val === null || val === undefined) {
|
||
throw new lib.TemplateError(
|
||
'attempted to output null or undefined value',
|
||
lineno + 1,
|
||
colno + 1
|
||
);
|
||
}
|
||
return val;
|
||
}
|
||
|
||
function memberLookup(obj, val) {
|
||
obj = obj || {};
|
||
|
||
if(typeof obj[val] === 'function') {
|
||
return function() {
|
||
return obj[val].apply(obj, arguments);
|
||
};
|
||
}
|
||
|
||
return obj[val];
|
||
}
|
||
|
||
function callWrap(obj, name, context, args) {
|
||
if(!obj) {
|
||
throw new Error('Unable to call `' + name + '`, which is undefined or falsey');
|
||
}
|
||
else if(typeof obj !== 'function') {
|
||
throw new Error('Unable to call `' + name + '`, which is not a function');
|
||
}
|
||
|
||
// jshint validthis: true
|
||
return obj.apply(context, args);
|
||
}
|
||
|
||
function contextOrFrameLookup(context, frame, name) {
|
||
var val = frame.lookup(name);
|
||
return (val !== undefined && val !== null) ?
|
||
val :
|
||
context.lookup(name);
|
||
}
|
||
|
||
function handleError(error, lineno, colno) {
|
||
if(error.lineno) {
|
||
return error;
|
||
}
|
||
else {
|
||
return new lib.TemplateError(error, lineno, colno);
|
||
}
|
||
}
|
||
|
||
function asyncEach(arr, dimen, iter, cb) {
|
||
if(lib.isArray(arr)) {
|
||
var len = arr.length;
|
||
|
||
lib.asyncIter(arr, function(item, i, next) {
|
||
switch(dimen) {
|
||
case 1: iter(item, i, len, next); break;
|
||
case 2: iter(item[0], item[1], i, len, next); break;
|
||
case 3: iter(item[0], item[1], item[2], i, len, next); break;
|
||
default:
|
||
item.push(i, next);
|
||
iter.apply(this, item);
|
||
}
|
||
}, cb);
|
||
}
|
||
else {
|
||
lib.asyncFor(arr, function(key, val, i, len, next) {
|
||
iter(key, val, i, len, next);
|
||
}, cb);
|
||
}
|
||
}
|
||
|
||
function asyncAll(arr, dimen, func, cb) {
|
||
var finished = 0;
|
||
var len, i;
|
||
var outputArr;
|
||
|
||
function done(i, output) {
|
||
finished++;
|
||
outputArr[i] = output;
|
||
|
||
if(finished === len) {
|
||
cb(null, outputArr.join(''));
|
||
}
|
||
}
|
||
|
||
if(lib.isArray(arr)) {
|
||
len = arr.length;
|
||
outputArr = new Array(len);
|
||
|
||
if(len === 0) {
|
||
cb(null, '');
|
||
}
|
||
else {
|
||
for(i = 0; i < arr.length; i++) {
|
||
var item = arr[i];
|
||
|
||
switch(dimen) {
|
||
case 1: func(item, i, len, done); break;
|
||
case 2: func(item[0], item[1], i, len, done); break;
|
||
case 3: func(item[0], item[1], item[2], i, len, done); break;
|
||
default:
|
||
item.push(i, done);
|
||
// jshint validthis: true
|
||
func.apply(this, item);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
var keys = lib.keys(arr);
|
||
len = keys.length;
|
||
outputArr = new Array(len);
|
||
|
||
if(len === 0) {
|
||
cb(null, '');
|
||
}
|
||
else {
|
||
for(i = 0; i < keys.length; i++) {
|
||
var k = keys[i];
|
||
func(k, arr[k], i, len, done);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
module.exports = {
|
||
Frame: Frame,
|
||
makeMacro: makeMacro,
|
||
makeKeywordArgs: makeKeywordArgs,
|
||
numArgs: numArgs,
|
||
suppressValue: suppressValue,
|
||
ensureDefined: ensureDefined,
|
||
memberLookup: memberLookup,
|
||
contextOrFrameLookup: contextOrFrameLookup,
|
||
callWrap: callWrap,
|
||
handleError: handleError,
|
||
isArray: lib.isArray,
|
||
keys: lib.keys,
|
||
SafeString: SafeString,
|
||
copySafeness: copySafeness,
|
||
markSafe: markSafe,
|
||
asyncEach: asyncEach,
|
||
asyncAll: asyncAll,
|
||
inOperator: lib.inOperator
|
||
};
|
||
|
||
|
||
/***/ },
|
||
/* 35 */
|
||
/***/ function(module, exports) {
|
||
|
||
'use strict';
|
||
|
||
function cycler(items) {
|
||
var index = -1;
|
||
|
||
return {
|
||
current: null,
|
||
reset: function() {
|
||
index = -1;
|
||
this.current = null;
|
||
},
|
||
|
||
next: function() {
|
||
index++;
|
||
if(index >= items.length) {
|
||
index = 0;
|
||
}
|
||
|
||
this.current = items[index];
|
||
return this.current;
|
||
},
|
||
};
|
||
|
||
}
|
||
|
||
function joiner(sep) {
|
||
sep = sep || ',';
|
||
var first = true;
|
||
|
||
return function() {
|
||
var val = first ? '' : sep;
|
||
first = false;
|
||
return val;
|
||
};
|
||
}
|
||
|
||
// Making this a function instead so it returns a new object
|
||
// each time it's called. That way, if something like an environment
|
||
// uses it, they will each have their own copy.
|
||
function globals() {
|
||
return {
|
||
range: function(start, stop, step) {
|
||
if(typeof stop === 'undefined') {
|
||
stop = start;
|
||
start = 0;
|
||
step = 1;
|
||
}
|
||
else if(!step) {
|
||
step = 1;
|
||
}
|
||
|
||
var arr = [];
|
||
var i;
|
||
if (step > 0) {
|
||
for (i=start; i<stop; i+=step) {
|
||
arr.push(i);
|
||
}
|
||
} else {
|
||
for (i=start; i>stop; i+=step) {
|
||
arr.push(i);
|
||
}
|
||
}
|
||
return arr;
|
||
},
|
||
|
||
// lipsum: function(n, html, min, max) {
|
||
// },
|
||
|
||
cycler: function() {
|
||
return cycler(Array.prototype.slice.call(arguments));
|
||
},
|
||
|
||
joiner: function(sep) {
|
||
return joiner(sep);
|
||
}
|
||
};
|
||
}
|
||
|
||
module.exports = globals;
|
||
|
||
|
||
/***/ },
|
||
/* 36 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
'use strict';
|
||
|
||
var Loader = __webpack_require__(37);
|
||
|
||
var PrecompiledLoader = Loader.extend({
|
||
init: function(compiledTemplates) {
|
||
this.precompiled = compiledTemplates || {};
|
||
},
|
||
|
||
getSource: function(name) {
|
||
if (this.precompiled[name]) {
|
||
return {
|
||
src: { type: 'code',
|
||
obj: this.precompiled[name] },
|
||
path: name
|
||
};
|
||
}
|
||
return null;
|
||
}
|
||
});
|
||
|
||
module.exports = PrecompiledLoader;
|
||
|
||
|
||
/***/ },
|
||
/* 37 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
'use strict';
|
||
|
||
var path = __webpack_require__(24);
|
||
var Obj = __webpack_require__(31);
|
||
var lib = __webpack_require__(27);
|
||
|
||
var Loader = Obj.extend({
|
||
on: function(name, func) {
|
||
this.listeners = this.listeners || {};
|
||
this.listeners[name] = this.listeners[name] || [];
|
||
this.listeners[name].push(func);
|
||
},
|
||
|
||
emit: function(name /*, arg1, arg2, ...*/) {
|
||
var args = Array.prototype.slice.call(arguments, 1);
|
||
|
||
if(this.listeners && this.listeners[name]) {
|
||
lib.each(this.listeners[name], function(listener) {
|
||
listener.apply(null, args);
|
||
});
|
||
}
|
||
},
|
||
|
||
resolve: function(from, to) {
|
||
return path.resolve(path.dirname(from), to);
|
||
},
|
||
|
||
isRelative: function(filename) {
|
||
return (filename.indexOf('./') === 0 || filename.indexOf('../') === 0);
|
||
}
|
||
});
|
||
|
||
module.exports = Loader;
|
||
|
||
|
||
/***/ },
|
||
/* 38 */
|
||
/***/ function(module, exports) {
|
||
|
||
function installCompat() {
|
||
'use strict';
|
||
|
||
// This must be called like `nunjucks.installCompat` so that `this`
|
||
// references the nunjucks instance
|
||
var runtime = this.runtime; // jshint ignore:line
|
||
var lib = this.lib; // jshint ignore:line
|
||
|
||
var orig_contextOrFrameLookup = runtime.contextOrFrameLookup;
|
||
runtime.contextOrFrameLookup = function(context, frame, key) {
|
||
var val = orig_contextOrFrameLookup.apply(this, arguments);
|
||
if (val === undefined) {
|
||
switch (key) {
|
||
case 'True':
|
||
return true;
|
||
case 'False':
|
||
return false;
|
||
case 'None':
|
||
return null;
|
||
}
|
||
}
|
||
|
||
return val;
|
||
};
|
||
|
||
var orig_memberLookup = runtime.memberLookup;
|
||
var ARRAY_MEMBERS = {
|
||
pop: function(index) {
|
||
if (index === undefined) {
|
||
return this.pop();
|
||
}
|
||
if (index >= this.length || index < 0) {
|
||
throw new Error('KeyError');
|
||
}
|
||
return this.splice(index, 1);
|
||
},
|
||
remove: function(element) {
|
||
for (var i = 0; i < this.length; i++) {
|
||
if (this[i] === element) {
|
||
return this.splice(i, 1);
|
||
}
|
||
}
|
||
throw new Error('ValueError');
|
||
},
|
||
count: function(element) {
|
||
var count = 0;
|
||
for (var i = 0; i < this.length; i++) {
|
||
if (this[i] === element) {
|
||
count++;
|
||
}
|
||
}
|
||
return count;
|
||
},
|
||
index: function(element) {
|
||
var i;
|
||
if ((i = this.indexOf(element)) === -1) {
|
||
throw new Error('ValueError');
|
||
}
|
||
return i;
|
||
},
|
||
find: function(element) {
|
||
return this.indexOf(element);
|
||
},
|
||
insert: function(index, elem) {
|
||
return this.splice(index, 0, elem);
|
||
}
|
||
};
|
||
var OBJECT_MEMBERS = {
|
||
items: function() {
|
||
var ret = [];
|
||
for(var k in this) {
|
||
ret.push([k, this[k]]);
|
||
}
|
||
return ret;
|
||
},
|
||
values: function() {
|
||
var ret = [];
|
||
for(var k in this) {
|
||
ret.push(this[k]);
|
||
}
|
||
return ret;
|
||
},
|
||
keys: function() {
|
||
var ret = [];
|
||
for(var k in this) {
|
||
ret.push(k);
|
||
}
|
||
return ret;
|
||
},
|
||
get: function(key, def) {
|
||
var output = this[key];
|
||
if (output === undefined) {
|
||
output = def;
|
||
}
|
||
return output;
|
||
},
|
||
has_key: function(key) {
|
||
return this.hasOwnProperty(key);
|
||
},
|
||
pop: function(key, def) {
|
||
var output = this[key];
|
||
if (output === undefined && def !== undefined) {
|
||
output = def;
|
||
} else if (output === undefined) {
|
||
throw new Error('KeyError');
|
||
} else {
|
||
delete this[key];
|
||
}
|
||
return output;
|
||
},
|
||
popitem: function() {
|
||
for (var k in this) {
|
||
// Return the first object pair.
|
||
var val = this[k];
|
||
delete this[k];
|
||
return [k, val];
|
||
}
|
||
throw new Error('KeyError');
|
||
},
|
||
setdefault: function(key, def) {
|
||
if (key in this) {
|
||
return this[key];
|
||
}
|
||
if (def === undefined) {
|
||
def = null;
|
||
}
|
||
return this[key] = def;
|
||
},
|
||
update: function(kwargs) {
|
||
for (var k in kwargs) {
|
||
this[k] = kwargs[k];
|
||
}
|
||
return null; // Always returns None
|
||
}
|
||
};
|
||
OBJECT_MEMBERS.iteritems = OBJECT_MEMBERS.items;
|
||
OBJECT_MEMBERS.itervalues = OBJECT_MEMBERS.values;
|
||
OBJECT_MEMBERS.iterkeys = OBJECT_MEMBERS.keys;
|
||
runtime.memberLookup = function(obj, val, autoescape) { // jshint ignore:line
|
||
obj = obj || {};
|
||
|
||
// If the object is an object, return any of the methods that Python would
|
||
// otherwise provide.
|
||
if (lib.isArray(obj) && ARRAY_MEMBERS.hasOwnProperty(val)) {
|
||
return function() {return ARRAY_MEMBERS[val].apply(obj, arguments);};
|
||
}
|
||
|
||
if (lib.isObject(obj) && OBJECT_MEMBERS.hasOwnProperty(val)) {
|
||
return function() {return OBJECT_MEMBERS[val].apply(obj, arguments);};
|
||
}
|
||
|
||
return orig_memberLookup.apply(this, arguments);
|
||
};
|
||
}
|
||
|
||
module.exports = installCompat;
|
||
|
||
|
||
/***/ },
|
||
/* 39 */
|
||
/***/ function(module, exports, __webpack_require__) {
|
||
|
||
/*
|
||
*
|
||
* HtmlPrinter (html-printer.js)
|
||
* Author: rtfpessoa
|
||
*
|
||
*/
|
||
|
||
(function() {
|
||
|
||
var diffParser = __webpack_require__(1).DiffParser;
|
||
var printerUtils = __webpack_require__(4).PrinterUtils;
|
||
var utils = __webpack_require__(2).Utils;
|
||
var Rematch = __webpack_require__(20).Rematch;
|
||
|
||
var matcher = Rematch.rematch(function(a, b) {
|
||
var amod = a.content.substr(1);
|
||
var bmod = b.content.substr(1);
|
||
|
||
return Rematch.distance(amod, bmod);
|
||
});
|
||
|
||
function SideBySidePrinter(config) {
|
||
this.config = config;
|
||
}
|
||
|
||
SideBySidePrinter.prototype.makeDiffHtml = function(file, diffs) {
|
||
return '<div id="' + printerUtils.getHtmlId(file) + '" class="d2h-file-wrapper" data-lang="' + file.language + '">\n' +
|
||
' <div class="d2h-file-header">\n' +
|
||
' <span class="d2h-file-stats">\n' +
|
||
' <span class="d2h-lines-added">\n' +
|
||
' <span>+' + file.addedLines + '</span>\n' +
|
||
' </span>\n' +
|
||
' <span class="d2h-lines-deleted">\n' +
|
||
' <span>-' + file.deletedLines + '</span>\n' +
|
||
' </span>\n' +
|
||
' </span>\n' +
|
||
' <span class="d2h-file-name-wrapper">\n' +
|
||
' <span class="d2h-file-name">' + printerUtils.getDiffName(file) + '</span>\n' +
|
||
' </span>\n' +
|
||
' </div>\n' +
|
||
' <div class="d2h-files-diff">\n' +
|
||
' <div class="d2h-file-side-diff">\n' +
|
||
' <div class="d2h-code-wrapper">\n' +
|
||
' <table class="d2h-diff-table">\n' +
|
||
' <tbody class="d2h-diff-tbody">\n' +
|
||
' ' + diffs.left +
|
||
' </tbody>\n' +
|
||
' </table>\n' +
|
||
' </div>\n' +
|
||
' </div>\n' +
|
||
' <div class="d2h-file-side-diff">\n' +
|
||
' <div class="d2h-code-wrapper">\n' +
|
||
' <table class="d2h-diff-table">\n' +
|
||
' <tbody class="d2h-diff-tbody">\n' +
|
||
' ' + diffs.right +
|
||
' </tbody>\n' +
|
||
' </table>\n' +
|
||
' </div>\n' +
|
||
' </div>\n' +
|
||
' </div>\n' +
|
||
' </div>\n';
|
||
};
|
||
|
||
SideBySidePrinter.prototype.generateSideBySideJsonHtml = function(diffFiles) {
|
||
var that = this;
|
||
return '<div class="d2h-wrapper">\n' +
|
||
diffFiles.map(function(file) {
|
||
|
||
var diffs;
|
||
if (file.blocks.length) {
|
||
diffs = that.generateSideBySideFileHtml(file);
|
||
} else {
|
||
diffs = that.generateEmptyDiff();
|
||
}
|
||
|
||
return that.makeDiffHtml(file, diffs);
|
||
}).join('\n') +
|
||
'</div>\n';
|
||
};
|
||
|
||
SideBySidePrinter.prototype.makeSideHtml = function(blockHeader) {
|
||
return '<tr>\n' +
|
||
' <td class="d2h-code-side-linenumber ' + diffParser.LINE_TYPE.INFO + '"></td>\n' +
|
||
' <td class="' + diffParser.LINE_TYPE.INFO + '">\n' +
|
||
' <div class="d2h-code-side-line ' + diffParser.LINE_TYPE.INFO + '">' + blockHeader + '</div>\n' +
|
||
' </td>\n' +
|
||
'</tr>\n';
|
||
};
|
||
|
||
SideBySidePrinter.prototype.generateSideBySideFileHtml = function(file) {
|
||
var that = this;
|
||
var fileHtml = {};
|
||
fileHtml.left = '';
|
||
fileHtml.right = '';
|
||
|
||
file.blocks.forEach(function(block) {
|
||
|
||
fileHtml.left += that.makeSideHtml(utils.escape(block.header));
|
||
fileHtml.right += that.makeSideHtml('');
|
||
|
||
var oldLines = [];
|
||
var newLines = [];
|
||
|
||
function processChangeBlock() {
|
||
var matches;
|
||
var insertType;
|
||
var deleteType;
|
||
|
||
var comparisons = oldLines.length * newLines.length;
|
||
var maxComparisons = that.config.matchingMaxComparisons || 2500;
|
||
var doMatching = comparisons < maxComparisons && (that.config.matching === 'lines' ||
|
||
that.config.matching === 'words');
|
||
|
||
if (doMatching) {
|
||
matches = matcher(oldLines, newLines);
|
||
insertType = diffParser.LINE_TYPE.INSERT_CHANGES;
|
||
deleteType = diffParser.LINE_TYPE.DELETE_CHANGES;
|
||
} else {
|
||
matches = [[oldLines, newLines]];
|
||
insertType = diffParser.LINE_TYPE.INSERTS;
|
||
deleteType = diffParser.LINE_TYPE.DELETES;
|
||
}
|
||
|
||
matches.forEach(function(match) {
|
||
oldLines = match[0];
|
||
newLines = match[1];
|
||
|
||
var common = Math.min(oldLines.length, newLines.length);
|
||
var max = Math.max(oldLines.length, newLines.length);
|
||
|
||
for (var j = 0; j < common; j++) {
|
||
var oldLine = oldLines[j];
|
||
var newLine = newLines[j];
|
||
|
||
that.config.isCombined = file.isCombined;
|
||
|
||
var diff = printerUtils.diffHighlight(oldLine.content, newLine.content, that.config);
|
||
|
||
fileHtml.left +=
|
||
that.generateSingleLineHtml(deleteType, oldLine.oldNumber,
|
||
diff.first.line, diff.first.prefix);
|
||
fileHtml.right +=
|
||
that.generateSingleLineHtml(insertType, newLine.newNumber,
|
||
diff.second.line, diff.second.prefix);
|
||
}
|
||
|
||
if (max > common) {
|
||
var oldSlice = oldLines.slice(common);
|
||
var newSlice = newLines.slice(common);
|
||
|
||
var tmpHtml = that.processLines(oldSlice, newSlice);
|
||
fileHtml.left += tmpHtml.left;
|
||
fileHtml.right += tmpHtml.right;
|
||
}
|
||
});
|
||
|
||
oldLines = [];
|
||
newLines = [];
|
||
}
|
||
|
||
for (var i = 0; i < block.lines.length; i++) {
|
||
var line = block.lines[i];
|
||
var prefix = line.content[0];
|
||
var escapedLine = utils.escape(line.content.substr(1));
|
||
|
||
if (line.type !== diffParser.LINE_TYPE.INSERTS &&
|
||
(newLines.length > 0 || (line.type !== diffParser.LINE_TYPE.DELETES && oldLines.length > 0))) {
|
||
processChangeBlock();
|
||
}
|
||
|
||
if (line.type === diffParser.LINE_TYPE.CONTEXT) {
|
||
fileHtml.left += that.generateSingleLineHtml(line.type, line.oldNumber, escapedLine, prefix);
|
||
fileHtml.right += that.generateSingleLineHtml(line.type, line.newNumber, escapedLine, prefix);
|
||
} else if (line.type === diffParser.LINE_TYPE.INSERTS && !oldLines.length) {
|
||
fileHtml.left += that.generateSingleLineHtml(diffParser.LINE_TYPE.CONTEXT, '', '', '');
|
||
fileHtml.right += that.generateSingleLineHtml(line.type, line.newNumber, escapedLine, prefix);
|
||
} else if (line.type === diffParser.LINE_TYPE.DELETES) {
|
||
oldLines.push(line);
|
||
} else if (line.type === diffParser.LINE_TYPE.INSERTS && Boolean(oldLines.length)) {
|
||
newLines.push(line);
|
||
} else {
|
||
console.error('unknown state in html side-by-side generator');
|
||
processChangeBlock();
|
||
}
|
||
}
|
||
|
||
processChangeBlock();
|
||
});
|
||
|
||
return fileHtml;
|
||
};
|
||
|
||
SideBySidePrinter.prototype.processLines = function(oldLines, newLines) {
|
||
var that = this;
|
||
var fileHtml = {};
|
||
fileHtml.left = '';
|
||
fileHtml.right = '';
|
||
|
||
var maxLinesNumber = Math.max(oldLines.length, newLines.length);
|
||
for (var i = 0; i < maxLinesNumber; i++) {
|
||
var oldLine = oldLines[i];
|
||
var newLine = newLines[i];
|
||
var oldContent;
|
||
var newContent;
|
||
var oldPrefix;
|
||
var newPrefix;
|
||
|
||
if (oldLine) {
|
||
oldContent = utils.escape(oldLine.content.substr(1));
|
||
oldPrefix = oldLine.content[0];
|
||
}
|
||
|
||
if (newLine) {
|
||
newContent = utils.escape(newLine.content.substr(1));
|
||
newPrefix = newLine.content[0];
|
||
}
|
||
|
||
if (oldLine && newLine) {
|
||
fileHtml.left += that.generateSingleLineHtml(oldLine.type, oldLine.oldNumber, oldContent, oldPrefix);
|
||
fileHtml.right += that.generateSingleLineHtml(newLine.type, newLine.newNumber, newContent, newPrefix);
|
||
} else if (oldLine) {
|
||
fileHtml.left += that.generateSingleLineHtml(oldLine.type, oldLine.oldNumber, oldContent, oldPrefix);
|
||
fileHtml.right += that.generateSingleLineHtml(diffParser.LINE_TYPE.CONTEXT, '', '', '');
|
||
} else if (newLine) {
|
||
fileHtml.left += that.generateSingleLineHtml(diffParser.LINE_TYPE.CONTEXT, '', '', '');
|
||
fileHtml.right += that.generateSingleLineHtml(newLine.type, newLine.newNumber, newContent, newPrefix);
|
||
} else {
|
||
console.error('How did it get here?');
|
||
}
|
||
}
|
||
|
||
return fileHtml;
|
||
};
|
||
|
||
SideBySidePrinter.prototype.makeSingleLineHtml = function(type, number, htmlContent, htmlPrefix) {
|
||
return '<tr>\n' +
|
||
' <td class="d2h-code-side-linenumber ' + type + '">' + number + '</td>\n' +
|
||
' <td class="' + type + '">' +
|
||
' <div class="d2h-code-side-line ' + type + '">' + htmlPrefix + htmlContent + '</div>' +
|
||
' </td>\n' +
|
||
' </tr>\n';
|
||
};
|
||
|
||
SideBySidePrinter.prototype.generateSingleLineHtml = function(type, number, content, prefix) {
|
||
var htmlPrefix = '';
|
||
if (prefix) {
|
||
htmlPrefix = '<span class="d2h-code-line-prefix">' + prefix + '</span>';
|
||
}
|
||
|
||
var htmlContent = '';
|
||
if (content) {
|
||
htmlContent = '<span class="d2h-code-line-ctn">' + content + '</span>';
|
||
}
|
||
|
||
return this.makeSingleLineHtml(type, number, htmlContent, htmlPrefix);
|
||
};
|
||
|
||
SideBySidePrinter.prototype.generateEmptyDiff = function() {
|
||
var fileHtml = {};
|
||
fileHtml.right = '';
|
||
|
||
fileHtml.left = '<tr>\n' +
|
||
' <td class="' + diffParser.LINE_TYPE.INFO + '">' +
|
||
' <div class="d2h-code-side-line ' + diffParser.LINE_TYPE.INFO + '">' +
|
||
'File without changes' +
|
||
' </div>' +
|
||
' </td>\n' +
|
||
'</tr>\n';
|
||
|
||
return fileHtml;
|
||
};
|
||
|
||
module.exports.SideBySidePrinter = SideBySidePrinter;
|
||
|
||
})();
|
||
|
||
|
||
/***/ }
|
||
/******/ ]); |