☰

bgm-wiki-rev-diff

show diff between bgm.tv wiki versions

目前为 2020-04-24 提交的版本。查看 最新版本。

  1. // ==UserScript==
  2. // @name        bgm-wiki-rev-diff
  3. // @namespace   https://trim21.me/
  4. // @version     0.0.1
  5. // @author      Trim21 <i@trim21.me>
  6. // @source      https://github.com/Trim21/bgm-wiki-rev-diff
  7. // @license     MIT
  8. // @match       https://bgm.tv/subject/*/edit*
  9. // @require     https://cdn.jsdelivr.net/npm/jquery@^3.5.0/dist/jquery.min.js
  10. // @grant       GM_xmlhttpRequest
  11. // @connect     bgm.tv
  12. // @run-at      document-end
  13. // @description show diff between bgm.tv wiki versions
  14. // ==/UserScript==
  15.  
  16. /******/ (function(modules) { // webpackBootstrap
  17. /******/ 	// The module cache
  18. /******/ 	var installedModules = {};
  19. /******/
  20. /******/ 	// The require function
  21. /******/ 	function __webpack_require__(moduleId) {
  22. /******/
  23. /******/ 		// Check if module is in cache
  24. /******/ 		if(installedModules[moduleId]) {
  25. /******/ 			return installedModules[moduleId].exports;
  26. /******/ 		}
  27. /******/ 		// Create a new module (and put it into the cache)
  28. /******/ 		var module = installedModules[moduleId] = {
  29. /******/ 			i: moduleId,
  30. /******/ 			l: false,
  31. /******/ 			exports: {}
  32. /******/ 		};
  33. /******/
  34. /******/ 		// Execute the module function
  35. /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  36. /******/
  37. /******/ 		// Flag the module as loaded
  38. /******/ 		module.l = true;
  39. /******/
  40. /******/ 		// Return the exports of the module
  41. /******/ 		return module.exports;
  42. /******/ 	}
  43. /******/
  44. /******/
  45. /******/ 	// expose the modules object (__webpack_modules__)
  46. /******/ 	__webpack_require__.m = modules;
  47. /******/
  48. /******/ 	// expose the module cache
  49. /******/ 	__webpack_require__.c = installedModules;
  50. /******/
  51. /******/ 	// define getter function for harmony exports
  52. /******/ 	__webpack_require__.d = function(exports, name, getter) {
  53. /******/ 		if(!__webpack_require__.o(exports, name)) {
  54. /******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
  55. /******/ 		}
  56. /******/ 	};
  57. /******/
  58. /******/ 	// define __esModule on exports
  59. /******/ 	__webpack_require__.r = function(exports) {
  60. /******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  61. /******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  62. /******/ 		}
  63. /******/ 		Object.defineProperty(exports, '__esModule', { value: true });
  64. /******/ 	};
  65. /******/
  66. /******/ 	// create a fake namespace object
  67. /******/ 	// mode & 1: value is a module id, require it
  68. /******/ 	// mode & 2: merge all properties of value into the ns
  69. /******/ 	// mode & 4: return value when already ns object
  70. /******/ 	// mode & 8|1: behave like require
  71. /******/ 	__webpack_require__.t = function(value, mode) {
  72. /******/ 		if(mode & 1) value = __webpack_require__(value);
  73. /******/ 		if(mode & 8) return value;
  74. /******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  75. /******/ 		var ns = Object.create(null);
  76. /******/ 		__webpack_require__.r(ns);
  77. /******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  78. /******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  79. /******/ 		return ns;
  80. /******/ 	};
  81. /******/
  82. /******/ 	// getDefaultExport function for compatibility with non-harmony modules
  83. /******/ 	__webpack_require__.n = function(module) {
  84. /******/ 		var getter = module && module.__esModule ?
  85. /******/ 			function getDefault() { return module['default']; } :
  86. /******/ 			function getModuleExports() { return module; };
  87. /******/ 		__webpack_require__.d(getter, 'a', getter);
  88. /******/ 		return getter;
  89. /******/ 	};
  90. /******/
  91. /******/ 	// Object.prototype.hasOwnProperty.call
  92. /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  93. /******/
  94. /******/ 	// __webpack_public_path__
  95. /******/ 	__webpack_require__.p = "";
  96. /******/
  97. /******/
  98. /******/ 	// Load entry module and return exports
  99. /******/ 	return __webpack_require__(__webpack_require__.s = "e6Wu");
  100. /******/ })
  101. /************************************************************************/
  102. /******/ ({
  103.  
  104. /***/ "1gqn":
  105. /***/ (function(module, exports) {
  106.  
  107. module.exports = function isBuffer(arg) {
  108.   return arg && typeof arg === 'object'
  109.     && typeof arg.copy === 'function'
  110.     && typeof arg.fill === 'function'
  111.     && typeof arg.readUInt8 === 'function';
  112. }
  113.  
  114. /***/ }),
  115.  
  116. /***/ "7Mwc":
  117. /***/ (function(module, exports, __webpack_require__) {
  118.  
  119. module.exports = __webpack_require__("qVjC");
  120.  
  121.  
  122. /***/ }),
  123.  
  124. /***/ "8oxB":
  125. /***/ (function(module, exports) {
  126.  
  127. // shim for using process in browser
  128. var process = module.exports = {};
  129.  
  130. // cached from whatever global is present so that test runners that stub it
  131. // don't break things.  But we need to wrap it in a try catch in case it is
  132. // wrapped in strict mode code which doesn't define any globals.  It's inside a
  133. // function because try/catches deoptimize in certain engines.
  134.  
  135. var cachedSetTimeout;
  136. var cachedClearTimeout;
  137.  
  138. function defaultSetTimout() {
  139.     throw new Error('setTimeout has not been defined');
  140. }
  141. function defaultClearTimeout () {
  142.     throw new Error('clearTimeout has not been defined');
  143. }
  144. (function () {
  145.     try {
  146.         if (typeof setTimeout === 'function') {
  147.             cachedSetTimeout = setTimeout;
  148.         } else {
  149.             cachedSetTimeout = defaultSetTimout;
  150.         }
  151.     } catch (e) {
  152.         cachedSetTimeout = defaultSetTimout;
  153.     }
  154.     try {
  155.         if (typeof clearTimeout === 'function') {
  156.             cachedClearTimeout = clearTimeout;
  157.         } else {
  158.             cachedClearTimeout = defaultClearTimeout;
  159.         }
  160.     } catch (e) {
  161.         cachedClearTimeout = defaultClearTimeout;
  162.     }
  163. } ())
  164. function runTimeout(fun) {
  165.     if (cachedSetTimeout === setTimeout) {
  166.         //normal enviroments in sane situations
  167.         return setTimeout(fun, 0);
  168.     }
  169.     // if setTimeout wasn't available but was latter defined
  170.     if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
  171.         cachedSetTimeout = setTimeout;
  172.         return setTimeout(fun, 0);
  173.     }
  174.     try {
  175.         // when when somebody has screwed with setTimeout but no I.E. maddness
  176.         return cachedSetTimeout(fun, 0);
  177.     } catch(e){
  178.         try {
  179.             // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
  180.             return cachedSetTimeout.call(null, fun, 0);
  181.         } catch(e){
  182.             // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
  183.             return cachedSetTimeout.call(this, fun, 0);
  184.         }
  185.     }
  186.  
  187.  
  188. }
  189. function runClearTimeout(marker) {
  190.     if (cachedClearTimeout === clearTimeout) {
  191.         //normal enviroments in sane situations
  192.         return clearTimeout(marker);
  193.     }
  194.     // if clearTimeout wasn't available but was latter defined
  195.     if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
  196.         cachedClearTimeout = clearTimeout;
  197.         return clearTimeout(marker);
  198.     }
  199.     try {
  200.         // when when somebody has screwed with setTimeout but no I.E. maddness
  201.         return cachedClearTimeout(marker);
  202.     } catch (e){
  203.         try {
  204.             // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
  205.             return cachedClearTimeout.call(null, marker);
  206.         } catch (e){
  207.             // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
  208.             // Some versions of I.E. have different rules for clearTimeout vs setTimeout
  209.             return cachedClearTimeout.call(this, marker);
  210.         }
  211.     }
  212.  
  213.  
  214.  
  215. }
  216. var queue = [];
  217. var draining = false;
  218. var currentQueue;
  219. var queueIndex = -1;
  220.  
  221. function cleanUpNextTick() {
  222.     if (!draining || !currentQueue) {
  223.         return;
  224.     }
  225.     draining = false;
  226.     if (currentQueue.length) {
  227.         queue = currentQueue.concat(queue);
  228.     } else {
  229.         queueIndex = -1;
  230.     }
  231.     if (queue.length) {
  232.         drainQueue();
  233.     }
  234. }
  235.  
  236. function drainQueue() {
  237.     if (draining) {
  238.         return;
  239.     }
  240.     var timeout = runTimeout(cleanUpNextTick);
  241.     draining = true;
  242.  
  243.     var len = queue.length;
  244.     while(len) {
  245.         currentQueue = queue;
  246.         queue = [];
  247.         while (++queueIndex < len) {
  248.             if (currentQueue) {
  249.                 currentQueue[queueIndex].run();
  250.             }
  251.         }
  252.         queueIndex = -1;
  253.         len = queue.length;
  254.     }
  255.     currentQueue = null;
  256.     draining = false;
  257.     runClearTimeout(timeout);
  258. }
  259.  
  260. process.nextTick = function (fun) {
  261.     var args = new Array(arguments.length - 1);
  262.     if (arguments.length > 1) {
  263.         for (var i = 1; i < arguments.length; i++) {
  264.             args[i - 1] = arguments[i];
  265.         }
  266.     }
  267.     queue.push(new Item(fun, args));
  268.     if (queue.length === 1 && !draining) {
  269.         runTimeout(drainQueue);
  270.     }
  271. };
  272.  
  273. // v8 likes predictible objects
  274. function Item(fun, array) {
  275.     this.fun = fun;
  276.     this.array = array;
  277. }
  278. Item.prototype.run = function () {
  279.     this.fun.apply(null, this.array);
  280. };
  281. process.title = 'browser';
  282. process.browser = true;
  283. process.env = {};
  284. process.argv = [];
  285. process.version = ''; // empty string to avoid regexp issues
  286. process.versions = {};
  287.  
  288. function noop() {}
  289.  
  290. process.on = noop;
  291. process.addListener = noop;
  292. process.once = noop;
  293. process.off = noop;
  294. process.removeListener = noop;
  295. process.removeAllListeners = noop;
  296. process.emit = noop;
  297. process.prependListener = noop;
  298. process.prependOnceListener = noop;
  299.  
  300. process.listeners = function (name) { return [] }
  301.  
  302. process.binding = function (name) {
  303.     throw new Error('process.binding is not supported');
  304. };
  305.  
  306. process.cwd = function () { return '/' };
  307. process.chdir = function (dir) {
  308.     throw new Error('process.chdir is not supported');
  309. };
  310. process.umask = function() { return 0; };
  311.  
  312.  
  313. /***/ }),
  314.  
  315. /***/ "9lTW":
  316. /***/ (function(module, exports, __webpack_require__) {
  317.  
  318. "use strict";
  319. /* WEBPACK VAR INJECTION */(function(global) {
  320.  
  321. var objectAssign = __webpack_require__("MgzW");
  322.  
  323. // compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js
  324. // original notice:
  325.  
  326. /*!
  327.  * The buffer module from node.js, for the browser.
  328.  *
  329.  * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
  330.  * @license  MIT
  331.  */
  332. function compare(a, b) {
  333.   if (a === b) {
  334.     return 0;
  335.   }
  336.  
  337.   var x = a.length;
  338.   var y = b.length;
  339.  
  340.   for (var i = 0, len = Math.min(x, y); i < len; ++i) {
  341.     if (a[i] !== b[i]) {
  342.       x = a[i];
  343.       y = b[i];
  344.       break;
  345.     }
  346.   }
  347.  
  348.   if (x < y) {
  349.     return -1;
  350.   }
  351.   if (y < x) {
  352.     return 1;
  353.   }
  354.   return 0;
  355. }
  356. function isBuffer(b) {
  357.   if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {
  358.     return global.Buffer.isBuffer(b);
  359.   }
  360.   return !!(b != null && b._isBuffer);
  361. }
  362.  
  363. // based on node assert, original notice:
  364. // NB: The URL to the CommonJS spec is kept just for tradition.
  365. //     node-assert has evolved a lot since then, both in API and behavior.
  366.  
  367. // http://wiki.commonjs.org/wiki/Unit_Testing/1.0
  368. //
  369. // THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
  370. //
  371. // Originally from narwhal.js (http://narwhaljs.org)
  372. // Copyright (c) 2009 Thomas Robinson <280north.com>
  373. //
  374. // Permission is hereby granted, free of charge, to any person obtaining a copy
  375. // of this software and associated documentation files (the 'Software'), to
  376. // deal in the Software without restriction, including without limitation the
  377. // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  378. // sell copies of the Software, and to permit persons to whom the Software is
  379. // furnished to do so, subject to the following conditions:
  380. //
  381. // The above copyright notice and this permission notice shall be included in
  382. // all copies or substantial portions of the Software.
  383. //
  384. // THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  385. // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  386. // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  387. // AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  388. // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  389. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  390.  
  391. var util = __webpack_require__("MCLT");
  392. var hasOwn = Object.prototype.hasOwnProperty;
  393. var pSlice = Array.prototype.slice;
  394. var functionsHaveNames = (function () {
  395.   return function foo() {}.name === 'foo';
  396. }());
  397. function pToString (obj) {
  398.   return Object.prototype.toString.call(obj);
  399. }
  400. function isView(arrbuf) {
  401.   if (isBuffer(arrbuf)) {
  402.     return false;
  403.   }
  404.   if (typeof global.ArrayBuffer !== 'function') {
  405.     return false;
  406.   }
  407.   if (typeof ArrayBuffer.isView === 'function') {
  408.     return ArrayBuffer.isView(arrbuf);
  409.   }
  410.   if (!arrbuf) {
  411.     return false;
  412.   }
  413.   if (arrbuf instanceof DataView) {
  414.     return true;
  415.   }
  416.   if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {
  417.     return true;
  418.   }
  419.   return false;
  420. }
  421. // 1. The assert module provides functions that throw
  422. // AssertionError's when particular conditions are not met. The
  423. // assert module must conform to the following interface.
  424.  
  425. var assert = module.exports = ok;
  426.  
  427. // 2. The AssertionError is defined in assert.
  428. // new assert.AssertionError({ message: message,
  429. //                             actual: actual,
  430. //                             expected: expected })
  431.  
  432. var regex = /\s*function\s+([^\(\s]*)\s*/;
  433. // based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js
  434. function getName(func) {
  435.   if (!util.isFunction(func)) {
  436.     return;
  437.   }
  438.   if (functionsHaveNames) {
  439.     return func.name;
  440.   }
  441.   var str = func.toString();
  442.   var match = str.match(regex);
  443.   return match && match[1];
  444. }
  445. assert.AssertionError = function AssertionError(options) {
  446.   this.name = 'AssertionError';
  447.   this.actual = options.actual;
  448.   this.expected = options.expected;
  449.   this.operator = options.operator;
  450.   if (options.message) {
  451.     this.message = options.message;
  452.     this.generatedMessage = false;
  453.   } else {
  454.     this.message = getMessage(this);
  455.     this.generatedMessage = true;
  456.   }
  457.   var stackStartFunction = options.stackStartFunction || fail;
  458.   if (Error.captureStackTrace) {
  459.     Error.captureStackTrace(this, stackStartFunction);
  460.   } else {
  461.     // non v8 browsers so we can have a stacktrace
  462.     var err = new Error();
  463.     if (err.stack) {
  464.       var out = err.stack;
  465.  
  466.       // try to strip useless frames
  467.       var fn_name = getName(stackStartFunction);
  468.       var idx = out.indexOf('\n' + fn_name);
  469.       if (idx >= 0) {
  470.         // once we have located the function frame
  471.         // we need to strip out everything before it (and its line)
  472.         var next_line = out.indexOf('\n', idx + 1);
  473.         out = out.substring(next_line + 1);
  474.       }
  475.  
  476.       this.stack = out;
  477.     }
  478.   }
  479. };
  480.  
  481. // assert.AssertionError instanceof Error
  482. util.inherits(assert.AssertionError, Error);
  483.  
  484. function truncate(s, n) {
  485.   if (typeof s === 'string') {
  486.     return s.length < n ? s : s.slice(0, n);
  487.   } else {
  488.     return s;
  489.   }
  490. }
  491. function inspect(something) {
  492.   if (functionsHaveNames || !util.isFunction(something)) {
  493.     return util.inspect(something);
  494.   }
  495.   var rawname = getName(something);
  496.   var name = rawname ? ': ' + rawname : '';
  497.   return '[Function' +  name + ']';
  498. }
  499. function getMessage(self) {
  500.   return truncate(inspect(self.actual), 128) + ' ' +
  501.          self.operator + ' ' +
  502.          truncate(inspect(self.expected), 128);
  503. }
  504.  
  505. // At present only the three keys mentioned above are used and
  506. // understood by the spec. Implementations or sub modules can pass
  507. // other keys to the AssertionError's constructor - they will be
  508. // ignored.
  509.  
  510. // 3. All of the following functions must throw an AssertionError
  511. // when a corresponding condition is not met, with a message that
  512. // may be undefined if not provided.  All assertion methods provide
  513. // both the actual and expected values to the assertion error for
  514. // display purposes.
  515.  
  516. function fail(actual, expected, message, operator, stackStartFunction) {
  517.   throw new assert.AssertionError({
  518.     message: message,
  519.     actual: actual,
  520.     expected: expected,
  521.     operator: operator,
  522.     stackStartFunction: stackStartFunction
  523.   });
  524. }
  525.  
  526. // EXTENSION! allows for well behaved errors defined elsewhere.
  527. assert.fail = fail;
  528.  
  529. // 4. Pure assertion tests whether a value is truthy, as determined
  530. // by !!guard.
  531. // assert.ok(guard, message_opt);
  532. // This statement is equivalent to assert.equal(true, !!guard,
  533. // message_opt);. To test strictly for the value true, use
  534. // assert.strictEqual(true, guard, message_opt);.
  535.  
  536. function ok(value, message) {
  537.   if (!value) fail(value, true, message, '==', assert.ok);
  538. }
  539. assert.ok = ok;
  540.  
  541. // 5. The equality assertion tests shallow, coercive equality with
  542. // ==.
  543. // assert.equal(actual, expected, message_opt);
  544.  
  545. assert.equal = function equal(actual, expected, message) {
  546.   if (actual != expected) fail(actual, expected, message, '==', assert.equal);
  547. };
  548.  
  549. // 6. The non-equality assertion tests for whether two objects are not equal
  550. // with != assert.notEqual(actual, expected, message_opt);
  551.  
  552. assert.notEqual = function notEqual(actual, expected, message) {
  553.   if (actual == expected) {
  554.     fail(actual, expected, message, '!=', assert.notEqual);
  555.   }
  556. };
  557.  
  558. // 7. The equivalence assertion tests a deep equality relation.
  559. // assert.deepEqual(actual, expected, message_opt);
  560.  
  561. assert.deepEqual = function deepEqual(actual, expected, message) {
  562.   if (!_deepEqual(actual, expected, false)) {
  563.     fail(actual, expected, message, 'deepEqual', assert.deepEqual);
  564.   }
  565. };
  566.  
  567. assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
  568.   if (!_deepEqual(actual, expected, true)) {
  569.     fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);
  570.   }
  571. };
  572.  
  573. function _deepEqual(actual, expected, strict, memos) {
  574.   // 7.1. All identical values are equivalent, as determined by ===.
  575.   if (actual === expected) {
  576.     return true;
  577.   } else if (isBuffer(actual) && isBuffer(expected)) {
  578.     return compare(actual, expected) === 0;
  579.  
  580.   // 7.2. If the expected value is a Date object, the actual value is
  581.   // equivalent if it is also a Date object that refers to the same time.
  582.   } else if (util.isDate(actual) && util.isDate(expected)) {
  583.     return actual.getTime() === expected.getTime();
  584.  
  585.   // 7.3 If the expected value is a RegExp object, the actual value is
  586.   // equivalent if it is also a RegExp object with the same source and
  587.   // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
  588.   } else if (util.isRegExp(actual) && util.isRegExp(expected)) {
  589.     return actual.source === expected.source &&
  590.            actual.global === expected.global &&
  591.            actual.multiline === expected.multiline &&
  592.            actual.lastIndex === expected.lastIndex &&
  593.            actual.ignoreCase === expected.ignoreCase;
  594.  
  595.   // 7.4. Other pairs that do not both pass typeof value == 'object',
  596.   // equivalence is determined by ==.
  597.   } else if ((actual === null || typeof actual !== 'object') &&
  598.              (expected === null || typeof expected !== 'object')) {
  599.     return strict ? actual === expected : actual == expected;
  600.  
  601.   // If both values are instances of typed arrays, wrap their underlying
  602.   // ArrayBuffers in a Buffer each to increase performance
  603.   // This optimization requires the arrays to have the same type as checked by
  604.   // Object.prototype.toString (aka pToString). Never perform binary
  605.   // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their
  606.   // bit patterns are not identical.
  607.   } else if (isView(actual) && isView(expected) &&
  608.              pToString(actual) === pToString(expected) &&
  609.              !(actual instanceof Float32Array ||
  610.                actual instanceof Float64Array)) {
  611.     return compare(new Uint8Array(actual.buffer),
  612.                    new Uint8Array(expected.buffer)) === 0;
  613.  
  614.   // 7.5 For all other Object pairs, including Array objects, equivalence is
  615.   // determined by having the same number of owned properties (as verified
  616.   // with Object.prototype.hasOwnProperty.call), the same set of keys
  617.   // (although not necessarily the same order), equivalent values for every
  618.   // corresponding key, and an identical 'prototype' property. Note: this
  619.   // accounts for both named and indexed properties on Arrays.
  620.   } else if (isBuffer(actual) !== isBuffer(expected)) {
  621.     return false;
  622.   } else {
  623.     memos = memos || {actual: [], expected: []};
  624.  
  625.     var actualIndex = memos.actual.indexOf(actual);
  626.     if (actualIndex !== -1) {
  627.       if (actualIndex === memos.expected.indexOf(expected)) {
  628.         return true;
  629.       }
  630.     }
  631.  
  632.     memos.actual.push(actual);
  633.     memos.expected.push(expected);
  634.  
  635.     return objEquiv(actual, expected, strict, memos);
  636.   }
  637. }
  638.  
  639. function isArguments(object) {
  640.   return Object.prototype.toString.call(object) == '[object Arguments]';
  641. }
  642.  
  643. function objEquiv(a, b, strict, actualVisitedObjects) {
  644.   if (a === null || a === undefined || b === null || b === undefined)
  645.     return false;
  646.   // if one is a primitive, the other must be same
  647.   if (util.isPrimitive(a) || util.isPrimitive(b))
  648.     return a === b;
  649.   if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))
  650.     return false;
  651.   var aIsArgs = isArguments(a);
  652.   var bIsArgs = isArguments(b);
  653.   if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))
  654.     return false;
  655.   if (aIsArgs) {
  656.     a = pSlice.call(a);
  657.     b = pSlice.call(b);
  658.     return _deepEqual(a, b, strict);
  659.   }
  660.   var ka = objectKeys(a);
  661.   var kb = objectKeys(b);
  662.   var key, i;
  663.   // having the same number of owned properties (keys incorporates
  664.   // hasOwnProperty)
  665.   if (ka.length !== kb.length)
  666.     return false;
  667.   //the same set of keys (although not necessarily the same order),
  668.   ka.sort();
  669.   kb.sort();
  670.   //~~~cheap key test
  671.   for (i = ka.length - 1; i >= 0; i--) {
  672.     if (ka[i] !== kb[i])
  673.       return false;
  674.   }
  675.   //equivalent values for every corresponding key, and
  676.   //~~~possibly expensive deep test
  677.   for (i = ka.length - 1; i >= 0; i--) {
  678.     key = ka[i];
  679.     if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))
  680.       return false;
  681.   }
  682.   return true;
  683. }
  684.  
  685. // 8. The non-equivalence assertion tests for any deep inequality.
  686. // assert.notDeepEqual(actual, expected, message_opt);
  687.  
  688. assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
  689.   if (_deepEqual(actual, expected, false)) {
  690.     fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
  691.   }
  692. };
  693.  
  694. assert.notDeepStrictEqual = notDeepStrictEqual;
  695. function notDeepStrictEqual(actual, expected, message) {
  696.   if (_deepEqual(actual, expected, true)) {
  697.     fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);
  698.   }
  699. }
  700.  
  701.  
  702. // 9. The strict equality assertion tests strict equality, as determined by ===.
  703. // assert.strictEqual(actual, expected, message_opt);
  704.  
  705. assert.strictEqual = function strictEqual(actual, expected, message) {
  706.   if (actual !== expected) {
  707.     fail(actual, expected, message, '===', assert.strictEqual);
  708.   }
  709. };
  710.  
  711. // 10. The strict non-equality assertion tests for strict inequality, as
  712. // determined by !==.  assert.notStrictEqual(actual, expected, message_opt);
  713.  
  714. assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
  715.   if (actual === expected) {
  716.     fail(actual, expected, message, '!==', assert.notStrictEqual);
  717.   }
  718. };
  719.  
  720. function expectedException(actual, expected) {
  721.   if (!actual || !expected) {
  722.     return false;
  723.   }
  724.  
  725.   if (Object.prototype.toString.call(expected) == '[object RegExp]') {
  726.     return expected.test(actual);
  727.   }
  728.  
  729.   try {
  730.     if (actual instanceof expected) {
  731.       return true;
  732.     }
  733.   } catch (e) {
  734.     // Ignore.  The instanceof check doesn't work for arrow functions.
  735.   }
  736.  
  737.   if (Error.isPrototypeOf(expected)) {
  738.     return false;
  739.   }
  740.  
  741.   return expected.call({}, actual) === true;
  742. }
  743.  
  744. function _tryBlock(block) {
  745.   var error;
  746.   try {
  747.     block();
  748.   } catch (e) {
  749.     error = e;
  750.   }
  751.   return error;
  752. }
  753.  
  754. function _throws(shouldThrow, block, expected, message) {
  755.   var actual;
  756.  
  757.   if (typeof block !== 'function') {
  758.     throw new TypeError('"block" argument must be a function');
  759.   }
  760.  
  761.   if (typeof expected === 'string') {
  762.     message = expected;
  763.     expected = null;
  764.   }
  765.  
  766.   actual = _tryBlock(block);
  767.  
  768.   message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
  769.             (message ? ' ' + message : '.');
  770.  
  771.   if (shouldThrow && !actual) {
  772.     fail(actual, expected, 'Missing expected exception' + message);
  773.   }
  774.  
  775.   var userProvidedMessage = typeof message === 'string';
  776.   var isUnwantedException = !shouldThrow && util.isError(actual);
  777.   var isUnexpectedException = !shouldThrow && actual && !expected;
  778.  
  779.   if ((isUnwantedException &&
  780.       userProvidedMessage &&
  781.       expectedException(actual, expected)) ||
  782.       isUnexpectedException) {
  783.     fail(actual, expected, 'Got unwanted exception' + message);
  784.   }
  785.  
  786.   if ((shouldThrow && actual && expected &&
  787.       !expectedException(actual, expected)) || (!shouldThrow && actual)) {
  788.     throw actual;
  789.   }
  790. }
  791.  
  792. // 11. Expected to throw an error:
  793. // assert.throws(block, Error_opt, message_opt);
  794.  
  795. assert.throws = function(block, /*optional*/error, /*optional*/message) {
  796.   _throws(true, block, error, message);
  797. };
  798.  
  799. // EXTENSION! This is annoying to write outside this module.
  800. assert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {
  801.   _throws(false, block, error, message);
  802. };
  803.  
  804. assert.ifError = function(err) { if (err) throw err; };
  805.  
  806. // Expose a strict only variant of assert
  807. function strict(value, message) {
  808.   if (!value) fail(value, true, message, '==', strict);
  809. }
  810. assert.strict = objectAssign(strict, assert, {
  811.   equal: assert.strictEqual,
  812.   deepEqual: assert.deepStrictEqual,
  813.   notEqual: assert.notStrictEqual,
  814.   notDeepEqual: assert.notDeepStrictEqual
  815. });
  816. assert.strict.strict = assert.strict;
  817.  
  818. var objectKeys = Object.keys || function (obj) {
  819.   var keys = [];
  820.   for (var key in obj) {
  821.     if (hasOwn.call(obj, key)) keys.push(key);
  822.   }
  823.   return keys;
  824. };
  825.  
  826. /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__("yLpj")))
  827.  
  828. /***/ }),
  829.  
  830. /***/ "Ekho":
  831. /***/ (function(module, exports, __webpack_require__) {
  832.  
  833. var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// Generated by CoffeeScript 1.8.0
  834. (function() {
  835.   var Heap, defaultCmp, floor, heapify, heappop, heappush, heappushpop, heapreplace, insort, min, nlargest, nsmallest, updateItem, _siftdown, _siftup;
  836.  
  837.   floor = Math.floor, min = Math.min;
  838.  
  839.  
  840.   /*
  841.   Default comparison function to be used
  842.    */
  843.  
  844.   defaultCmp = function(x, y) {
  845.     if (x < y) {
  846.       return -1;
  847.     }
  848.     if (x > y) {
  849.       return 1;
  850.     }
  851.     return 0;
  852.   };
  853.  
  854.  
  855.   /*
  856.   Insert item x in list a, and keep it sorted assuming a is sorted.
  857.   
  858.   If x is already in a, insert it to the right of the rightmost x.
  859.   
  860.   Optional args lo (default 0) and hi (default a.length) bound the slice
  861.   of a to be searched.
  862.    */
  863.  
  864.   insort = function(a, x, lo, hi, cmp) {
  865.     var mid;
  866.     if (lo == null) {
  867.       lo = 0;
  868.     }
  869.     if (cmp == null) {
  870.       cmp = defaultCmp;
  871.     }
  872.     if (lo < 0) {
  873.       throw new Error('lo must be non-negative');
  874.     }
  875.     if (hi == null) {
  876.       hi = a.length;
  877.     }
  878.     while (lo < hi) {
  879.       mid = floor((lo + hi) / 2);
  880.       if (cmp(x, a[mid]) < 0) {
  881.         hi = mid;
  882.       } else {
  883.         lo = mid + 1;
  884.       }
  885.     }
  886.     return ([].splice.apply(a, [lo, lo - lo].concat(x)), x);
  887.   };
  888.  
  889.  
  890.   /*
  891.   Push item onto heap, maintaining the heap invariant.
  892.    */
  893.  
  894.   heappush = function(array, item, cmp) {
  895.     if (cmp == null) {
  896.       cmp = defaultCmp;
  897.     }
  898.     array.push(item);
  899.     return _siftdown(array, 0, array.length - 1, cmp);
  900.   };
  901.  
  902.  
  903.   /*
  904.   Pop the smallest item off the heap, maintaining the heap invariant.
  905.    */
  906.  
  907.   heappop = function(array, cmp) {
  908.     var lastelt, returnitem;
  909.     if (cmp == null) {
  910.       cmp = defaultCmp;
  911.     }
  912.     lastelt = array.pop();
  913.     if (array.length) {
  914.       returnitem = array[0];
  915.       array[0] = lastelt;
  916.       _siftup(array, 0, cmp);
  917.     } else {
  918.       returnitem = lastelt;
  919.     }
  920.     return returnitem;
  921.   };
  922.  
  923.  
  924.   /*
  925.   Pop and return the current smallest value, and add the new item.
  926.   
  927.   This is more efficient than heappop() followed by heappush(), and can be
  928.   more appropriate when using a fixed size heap. Note that the value
  929.   returned may be larger than item! That constrains reasonable use of
  930.   this routine unless written as part of a conditional replacement:
  931.       if item > array[0]
  932.         item = heapreplace(array, item)
  933.    */
  934.  
  935.   heapreplace = function(array, item, cmp) {
  936.     var returnitem;
  937.     if (cmp == null) {
  938.       cmp = defaultCmp;
  939.     }
  940.     returnitem = array[0];
  941.     array[0] = item;
  942.     _siftup(array, 0, cmp);
  943.     return returnitem;
  944.   };
  945.  
  946.  
  947.   /*
  948.   Fast version of a heappush followed by a heappop.
  949.    */
  950.  
  951.   heappushpop = function(array, item, cmp) {
  952.     var _ref;
  953.     if (cmp == null) {
  954.       cmp = defaultCmp;
  955.     }
  956.     if (array.length && cmp(array[0], item) < 0) {
  957.       _ref = [array[0], item], item = _ref[0], array[0] = _ref[1];
  958.       _siftup(array, 0, cmp);
  959.     }
  960.     return item;
  961.   };
  962.  
  963.  
  964.   /*
  965.   Transform list into a heap, in-place, in O(array.length) time.
  966.    */
  967.  
  968.   heapify = function(array, cmp) {
  969.     var i, _i, _j, _len, _ref, _ref1, _results, _results1;
  970.     if (cmp == null) {
  971.       cmp = defaultCmp;
  972.     }
  973.     _ref1 = (function() {
  974.       _results1 = [];
  975.       for (var _j = 0, _ref = floor(array.length / 2); 0 <= _ref ? _j < _ref : _j > _ref; 0 <= _ref ? _j++ : _j--){ _results1.push(_j); }
  976.       return _results1;
  977.     }).apply(this).reverse();
  978.     _results = [];
  979.     for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
  980.       i = _ref1[_i];
  981.       _results.push(_siftup(array, i, cmp));
  982.     }
  983.     return _results;
  984.   };
  985.  
  986.  
  987.   /*
  988.   Update the position of the given item in the heap.
  989.   This function should be called every time the item is being modified.
  990.    */
  991.  
  992.   updateItem = function(array, item, cmp) {
  993.     var pos;
  994.     if (cmp == null) {
  995.       cmp = defaultCmp;
  996.     }
  997.     pos = array.indexOf(item);
  998.     if (pos === -1) {
  999.       return;
  1000.     }
  1001.     _siftdown(array, 0, pos, cmp);
  1002.     return _siftup(array, pos, cmp);
  1003.   };
  1004.  
  1005.  
  1006.   /*
  1007.   Find the n largest elements in a dataset.
  1008.    */
  1009.  
  1010.   nlargest = function(array, n, cmp) {
  1011.     var elem, result, _i, _len, _ref;
  1012.     if (cmp == null) {
  1013.       cmp = defaultCmp;
  1014.     }
  1015.     result = array.slice(0, n);
  1016.     if (!result.length) {
  1017.       return result;
  1018.     }
  1019.     heapify(result, cmp);
  1020.     _ref = array.slice(n);
  1021.     for (_i = 0, _len = _ref.length; _i < _len; _i++) {
  1022.       elem = _ref[_i];
  1023.       heappushpop(result, elem, cmp);
  1024.     }
  1025.     return result.sort(cmp).reverse();
  1026.   };
  1027.  
  1028.  
  1029.   /*
  1030.   Find the n smallest elements in a dataset.
  1031.    */
  1032.  
  1033.   nsmallest = function(array, n, cmp) {
  1034.     var elem, i, los, result, _i, _j, _len, _ref, _ref1, _results;
  1035.     if (cmp == null) {
  1036.       cmp = defaultCmp;
  1037.     }
  1038.     if (n * 10 <= array.length) {
  1039.       result = array.slice(0, n).sort(cmp);
  1040.       if (!result.length) {
  1041.         return result;
  1042.       }
  1043.       los = result[result.length - 1];
  1044.       _ref = array.slice(n);
  1045.       for (_i = 0, _len = _ref.length; _i < _len; _i++) {
  1046.         elem = _ref[_i];
  1047.         if (cmp(elem, los) < 0) {
  1048.           insort(result, elem, 0, null, cmp);
  1049.           result.pop();
  1050.           los = result[result.length - 1];
  1051.         }
  1052.       }
  1053.       return result;
  1054.     }
  1055.     heapify(array, cmp);
  1056.     _results = [];
  1057.     for (i = _j = 0, _ref1 = min(n, array.length); 0 <= _ref1 ? _j < _ref1 : _j > _ref1; i = 0 <= _ref1 ? ++_j : --_j) {
  1058.       _results.push(heappop(array, cmp));
  1059.     }
  1060.     return _results;
  1061.   };
  1062.  
  1063.   _siftdown = function(array, startpos, pos, cmp) {
  1064.     var newitem, parent, parentpos;
  1065.     if (cmp == null) {
  1066.       cmp = defaultCmp;
  1067.     }
  1068.     newitem = array[pos];
  1069.     while (pos > startpos) {
  1070.       parentpos = (pos - 1) >> 1;
  1071.       parent = array[parentpos];
  1072.       if (cmp(newitem, parent) < 0) {
  1073.         array[pos] = parent;
  1074.         pos = parentpos;
  1075.         continue;
  1076.       }
  1077.       break;
  1078.     }
  1079.     return array[pos] = newitem;
  1080.   };
  1081.  
  1082.   _siftup = function(array, pos, cmp) {
  1083.     var childpos, endpos, newitem, rightpos, startpos;
  1084.     if (cmp == null) {
  1085.       cmp = defaultCmp;
  1086.     }
  1087.     endpos = array.length;
  1088.     startpos = pos;
  1089.     newitem = array[pos];
  1090.     childpos = 2 * pos + 1;
  1091.     while (childpos < endpos) {
  1092.       rightpos = childpos + 1;
  1093.       if (rightpos < endpos && !(cmp(array[childpos], array[rightpos]) < 0)) {
  1094.         childpos = rightpos;
  1095.       }
  1096.       array[pos] = array[childpos];
  1097.       pos = childpos;
  1098.       childpos = 2 * pos + 1;
  1099.     }
  1100.     array[pos] = newitem;
  1101.     return _siftdown(array, startpos, pos, cmp);
  1102.   };
  1103.  
  1104.   Heap = (function() {
  1105.     Heap.push = heappush;
  1106.  
  1107.     Heap.pop = heappop;
  1108.  
  1109.     Heap.replace = heapreplace;
  1110.  
  1111.     Heap.pushpop = heappushpop;
  1112.  
  1113.     Heap.heapify = heapify;
  1114.  
  1115.     Heap.updateItem = updateItem;
  1116.  
  1117.     Heap.nlargest = nlargest;
  1118.  
  1119.     Heap.nsmallest = nsmallest;
  1120.  
  1121.     function Heap(cmp) {
  1122.       this.cmp = cmp != null ? cmp : defaultCmp;
  1123.       this.nodes = [];
  1124.     }
  1125.  
  1126.     Heap.prototype.push = function(x) {
  1127.       return heappush(this.nodes, x, this.cmp);
  1128.     };
  1129.  
  1130.     Heap.prototype.pop = function() {
  1131.       return heappop(this.nodes, this.cmp);
  1132.     };
  1133.  
  1134.     Heap.prototype.peek = function() {
  1135.       return this.nodes[0];
  1136.     };
  1137.  
  1138.     Heap.prototype.contains = function(x) {
  1139.       return this.nodes.indexOf(x) !== -1;
  1140.     };
  1141.  
  1142.     Heap.prototype.replace = function(x) {
  1143.       return heapreplace(this.nodes, x, this.cmp);
  1144.     };
  1145.  
  1146.     Heap.prototype.pushpop = function(x) {
  1147.       return heappushpop(this.nodes, x, this.cmp);
  1148.     };
  1149.  
  1150.     Heap.prototype.heapify = function() {
  1151.       return heapify(this.nodes, this.cmp);
  1152.     };
  1153.  
  1154.     Heap.prototype.updateItem = function(x) {
  1155.       return updateItem(this.nodes, x, this.cmp);
  1156.     };
  1157.  
  1158.     Heap.prototype.clear = function() {
  1159.       return this.nodes = [];
  1160.     };
  1161.  
  1162.     Heap.prototype.empty = function() {
  1163.       return this.nodes.length === 0;
  1164.     };
  1165.  
  1166.     Heap.prototype.size = function() {
  1167.       return this.nodes.length;
  1168.     };
  1169.  
  1170.     Heap.prototype.clone = function() {
  1171.       var heap;
  1172.       heap = new Heap();
  1173.       heap.nodes = this.nodes.slice(0);
  1174.       return heap;
  1175.     };
  1176.  
  1177.     Heap.prototype.toArray = function() {
  1178.       return this.nodes.slice(0);
  1179.     };
  1180.  
  1181.     Heap.prototype.insert = Heap.prototype.push;
  1182.  
  1183.     Heap.prototype.top = Heap.prototype.peek;
  1184.  
  1185.     Heap.prototype.front = Heap.prototype.peek;
  1186.  
  1187.     Heap.prototype.has = Heap.prototype.contains;
  1188.  
  1189.     Heap.prototype.copy = Heap.prototype.clone;
  1190.  
  1191.     return Heap;
  1192.  
  1193.   })();
  1194.  
  1195.   (function(root, factory) {
  1196.     if (true) {
  1197.       return !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
  1198. 				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
  1199. 				(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
  1200. 				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  1201.     } else {}
  1202.   })(this, function() {
  1203.     return Heap;
  1204.   });
  1205.  
  1206. }).call(this);
  1207.  
  1208.  
  1209. /***/ }),
  1210.  
  1211. /***/ "F1pL":
  1212. /***/ (function(module, exports, __webpack_require__) {
  1213.  
  1214. module.exports = __webpack_require__("Ekho");
  1215.  
  1216.  
  1217. /***/ }),
  1218.  
  1219. /***/ "KKCa":
  1220. /***/ (function(module, exports) {
  1221.  
  1222. if (typeof Object.create === 'function') {
  1223.   // implementation from standard node.js 'util' module
  1224.   module.exports = function inherits(ctor, superCtor) {
  1225.     ctor.super_ = superCtor
  1226.     ctor.prototype = Object.create(superCtor.prototype, {
  1227.       constructor: {
  1228.         value: ctor,
  1229.         enumerable: false,
  1230.         writable: true,
  1231.         configurable: true
  1232.       }
  1233.     });
  1234.   };
  1235. } else {
  1236.   // old school shim for old browsers
  1237.   module.exports = function inherits(ctor, superCtor) {
  1238.     ctor.super_ = superCtor
  1239.     var TempCtor = function () {}
  1240.     TempCtor.prototype = superCtor.prototype
  1241.     ctor.prototype = new TempCtor()
  1242.     ctor.prototype.constructor = ctor
  1243.   }
  1244. }
  1245.  
  1246.  
  1247. /***/ }),
  1248.  
  1249. /***/ "MCLT":
  1250. /***/ (function(module, exports, __webpack_require__) {
  1251.  
  1252. /* WEBPACK VAR INJECTION */(function(process) {// Copyright Joyent, Inc. and other Node contributors.
  1253. //
  1254. // Permission is hereby granted, free of charge, to any person obtaining a
  1255. // copy of this software and associated documentation files (the
  1256. // "Software"), to deal in the Software without restriction, including
  1257. // without limitation the rights to use, copy, modify, merge, publish,
  1258. // distribute, sublicense, and/or sell copies of the Software, and to permit
  1259. // persons to whom the Software is furnished to do so, subject to the
  1260. // following conditions:
  1261. //
  1262. // The above copyright notice and this permission notice shall be included
  1263. // in all copies or substantial portions of the Software.
  1264. //
  1265. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  1266. // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  1267. // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  1268. // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  1269. // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  1270. // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  1271. // USE OR OTHER DEALINGS IN THE SOFTWARE.
  1272.  
  1273. var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors ||
  1274.   function getOwnPropertyDescriptors(obj) {
  1275.     var keys = Object.keys(obj);
  1276.     var descriptors = {};
  1277.     for (var i = 0; i < keys.length; i++) {
  1278.       descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);
  1279.     }
  1280.     return descriptors;
  1281.   };
  1282.  
  1283. var formatRegExp = /%[sdj%]/g;
  1284. exports.format = function(f) {
  1285.   if (!isString(f)) {
  1286.     var objects = [];
  1287.     for (var i = 0; i < arguments.length; i++) {
  1288.       objects.push(inspect(arguments[i]));
  1289.     }
  1290.     return objects.join(' ');
  1291.   }
  1292.  
  1293.   var i = 1;
  1294.   var args = arguments;
  1295.   var len = args.length;
  1296.   var str = String(f).replace(formatRegExp, function(x) {
  1297.     if (x === '%%') return '%';
  1298.     if (i >= len) return x;
  1299.     switch (x) {
  1300.       case '%s': return String(args[i++]);
  1301.       case '%d': return Number(args[i++]);
  1302.       case '%j':
  1303.         try {
  1304.           return JSON.stringify(args[i++]);
  1305.         } catch (_) {
  1306.           return '[Circular]';
  1307.         }
  1308.       default:
  1309.         return x;
  1310.     }
  1311.   });
  1312.   for (var x = args[i]; i < len; x = args[++i]) {
  1313.     if (isNull(x) || !isObject(x)) {
  1314.       str += ' ' + x;
  1315.     } else {
  1316.       str += ' ' + inspect(x);
  1317.     }
  1318.   }
  1319.   return str;
  1320. };
  1321.  
  1322.  
  1323. // Mark that a method should not be used.
  1324. // Returns a modified function which warns once by default.
  1325. // If --no-deprecation is set, then it is a no-op.
  1326. exports.deprecate = function(fn, msg) {
  1327.   if (typeof process !== 'undefined' && process.noDeprecation === true) {
  1328.     return fn;
  1329.   }
  1330.  
  1331.   // Allow for deprecating things in the process of starting up.
  1332.   if (typeof process === 'undefined') {
  1333.     return function() {
  1334.       return exports.deprecate(fn, msg).apply(this, arguments);
  1335.     };
  1336.   }
  1337.  
  1338.   var warned = false;
  1339.   function deprecated() {
  1340.     if (!warned) {
  1341.       if (process.throwDeprecation) {
  1342.         throw new Error(msg);
  1343.       } else if (process.traceDeprecation) {
  1344.         console.trace(msg);
  1345.       } else {
  1346.         console.error(msg);
  1347.       }
  1348.       warned = true;
  1349.     }
  1350.     return fn.apply(this, arguments);
  1351.   }
  1352.  
  1353.   return deprecated;
  1354. };
  1355.  
  1356.  
  1357. var debugs = {};
  1358. var debugEnviron;
  1359. exports.debuglog = function(set) {
  1360.   if (isUndefined(debugEnviron))
  1361.     debugEnviron = process.env.NODE_DEBUG || '';
  1362.   set = set.toUpperCase();
  1363.   if (!debugs[set]) {
  1364.     if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
  1365.       var pid = process.pid;
  1366.       debugs[set] = function() {
  1367.         var msg = exports.format.apply(exports, arguments);
  1368.         console.error('%s %d: %s', set, pid, msg);
  1369.       };
  1370.     } else {
  1371.       debugs[set] = function() {};
  1372.     }
  1373.   }
  1374.   return debugs[set];
  1375. };
  1376.  
  1377.  
  1378. /**
  1379.  * Echos the value of a value. Trys to print the value out
  1380.  * in the best way possible given the different types.
  1381.  *
  1382.  * @param {Object} obj The object to print out.
  1383.  * @param {Object} opts Optional options object that alters the output.
  1384.  */
  1385. /* legacy: obj, showHidden, depth, colors*/
  1386. function inspect(obj, opts) {
  1387.   // default options
  1388.   var ctx = {
  1389.     seen: [],
  1390.     stylize: stylizeNoColor
  1391.   };
  1392.   // legacy...
  1393.   if (arguments.length >= 3) ctx.depth = arguments[2];
  1394.   if (arguments.length >= 4) ctx.colors = arguments[3];
  1395.   if (isBoolean(opts)) {
  1396.     // legacy...
  1397.     ctx.showHidden = opts;
  1398.   } else if (opts) {
  1399.     // got an "options" object
  1400.     exports._extend(ctx, opts);
  1401.   }
  1402.   // set default options
  1403.   if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
  1404.   if (isUndefined(ctx.depth)) ctx.depth = 2;
  1405.   if (isUndefined(ctx.colors)) ctx.colors = false;
  1406.   if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
  1407.   if (ctx.colors) ctx.stylize = stylizeWithColor;
  1408.   return formatValue(ctx, obj, ctx.depth);
  1409. }
  1410. exports.inspect = inspect;
  1411.  
  1412.  
  1413. // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
  1414. inspect.colors = {
  1415.   'bold' : [1, 22],
  1416.   'italic' : [3, 23],
  1417.   'underline' : [4, 24],
  1418.   'inverse' : [7, 27],
  1419.   'white' : [37, 39],
  1420.   'grey' : [90, 39],
  1421.   'black' : [30, 39],
  1422.   'blue' : [34, 39],
  1423.   'cyan' : [36, 39],
  1424.   'green' : [32, 39],
  1425.   'magenta' : [35, 39],
  1426.   'red' : [31, 39],
  1427.   'yellow' : [33, 39]
  1428. };
  1429.  
  1430. // Don't use 'blue' not visible on cmd.exe
  1431. inspect.styles = {
  1432.   'special': 'cyan',
  1433.   'number': 'yellow',
  1434.   'boolean': 'yellow',
  1435.   'undefined': 'grey',
  1436.   'null': 'bold',
  1437.   'string': 'green',
  1438.   'date': 'magenta',
  1439.   // "name": intentionally not styling
  1440.   'regexp': 'red'
  1441. };
  1442.  
  1443.  
  1444. function stylizeWithColor(str, styleType) {
  1445.   var style = inspect.styles[styleType];
  1446.  
  1447.   if (style) {
  1448.     return '\u001b[' + inspect.colors[style][0] + 'm' + str +
  1449.            '\u001b[' + inspect.colors[style][1] + 'm';
  1450.   } else {
  1451.     return str;
  1452.   }
  1453. }
  1454.  
  1455.  
  1456. function stylizeNoColor(str, styleType) {
  1457.   return str;
  1458. }
  1459.  
  1460.  
  1461. function arrayToHash(array) {
  1462.   var hash = {};
  1463.  
  1464.   array.forEach(function(val, idx) {
  1465.     hash[val] = true;
  1466.   });
  1467.  
  1468.   return hash;
  1469. }
  1470.  
  1471.  
  1472. function formatValue(ctx, value, recurseTimes) {
  1473.   // Provide a hook for user-specified inspect functions.
  1474.   // Check that value is an object with an inspect function on it
  1475.   if (ctx.customInspect &&
  1476.       value &&
  1477.       isFunction(value.inspect) &&
  1478.       // Filter out the util module, it's inspect function is special
  1479.       value.inspect !== exports.inspect &&
  1480.       // Also filter out any prototype objects using the circular check.
  1481.       !(value.constructor && value.constructor.prototype === value)) {
  1482.     var ret = value.inspect(recurseTimes, ctx);
  1483.     if (!isString(ret)) {
  1484.       ret = formatValue(ctx, ret, recurseTimes);
  1485.     }
  1486.     return ret;
  1487.   }
  1488.  
  1489.   // Primitive types cannot have properties
  1490.   var primitive = formatPrimitive(ctx, value);
  1491.   if (primitive) {
  1492.     return primitive;
  1493.   }
  1494.  
  1495.   // Look up the keys of the object.
  1496.   var keys = Object.keys(value);
  1497.   var visibleKeys = arrayToHash(keys);
  1498.  
  1499.   if (ctx.showHidden) {
  1500.     keys = Object.getOwnPropertyNames(value);
  1501.   }
  1502.  
  1503.   // IE doesn't make error fields non-enumerable
  1504.   // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
  1505.   if (isError(value)
  1506.       && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
  1507.     return formatError(value);
  1508.   }
  1509.  
  1510.   // Some type of object without properties can be shortcutted.
  1511.   if (keys.length === 0) {
  1512.     if (isFunction(value)) {
  1513.       var name = value.name ? ': ' + value.name : '';
  1514.       return ctx.stylize('[Function' + name + ']', 'special');
  1515.     }
  1516.     if (isRegExp(value)) {
  1517.       return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
  1518.     }
  1519.     if (isDate(value)) {
  1520.       return ctx.stylize(Date.prototype.toString.call(value), 'date');
  1521.     }
  1522.     if (isError(value)) {
  1523.       return formatError(value);
  1524.     }
  1525.   }
  1526.  
  1527.   var base = '', array = false, braces = ['{', '}'];
  1528.  
  1529.   // Make Array say that they are Array
  1530.   if (isArray(value)) {
  1531.     array = true;
  1532.     braces = ['[', ']'];
  1533.   }
  1534.  
  1535.   // Make functions say that they are functions
  1536.   if (isFunction(value)) {
  1537.     var n = value.name ? ': ' + value.name : '';
  1538.     base = ' [Function' + n + ']';
  1539.   }
  1540.  
  1541.   // Make RegExps say that they are RegExps
  1542.   if (isRegExp(value)) {
  1543.     base = ' ' + RegExp.prototype.toString.call(value);
  1544.   }
  1545.  
  1546.   // Make dates with properties first say the date
  1547.   if (isDate(value)) {
  1548.     base = ' ' + Date.prototype.toUTCString.call(value);
  1549.   }
  1550.  
  1551.   // Make error with message first say the error
  1552.   if (isError(value)) {
  1553.     base = ' ' + formatError(value);
  1554.   }
  1555.  
  1556.   if (keys.length === 0 && (!array || value.length == 0)) {
  1557.     return braces[0] + base + braces[1];
  1558.   }
  1559.  
  1560.   if (recurseTimes < 0) {
  1561.     if (isRegExp(value)) {
  1562.       return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
  1563.     } else {
  1564.       return ctx.stylize('[Object]', 'special');
  1565.     }
  1566.   }
  1567.  
  1568.   ctx.seen.push(value);
  1569.  
  1570.   var output;
  1571.   if (array) {
  1572.     output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
  1573.   } else {
  1574.     output = keys.map(function(key) {
  1575.       return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
  1576.     });
  1577.   }
  1578.  
  1579.   ctx.seen.pop();
  1580.  
  1581.   return reduceToSingleString(output, base, braces);
  1582. }
  1583.  
  1584.  
  1585. function formatPrimitive(ctx, value) {
  1586.   if (isUndefined(value))
  1587.     return ctx.stylize('undefined', 'undefined');
  1588.   if (isString(value)) {
  1589.     var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
  1590.                                              .replace(/'/g, "\\'")
  1591.                                              .replace(/\\"/g, '"') + '\'';
  1592.     return ctx.stylize(simple, 'string');
  1593.   }
  1594.   if (isNumber(value))
  1595.     return ctx.stylize('' + value, 'number');
  1596.   if (isBoolean(value))
  1597.     return ctx.stylize('' + value, 'boolean');
  1598.   // For some reason typeof null is "object", so special case here.
  1599.   if (isNull(value))
  1600.     return ctx.stylize('null', 'null');
  1601. }
  1602.  
  1603.  
  1604. function formatError(value) {
  1605.   return '[' + Error.prototype.toString.call(value) + ']';
  1606. }
  1607.  
  1608.  
  1609. function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
  1610.   var output = [];
  1611.   for (var i = 0, l = value.length; i < l; ++i) {
  1612.     if (hasOwnProperty(value, String(i))) {
  1613.       output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
  1614.           String(i), true));
  1615.     } else {
  1616.       output.push('');
  1617.     }
  1618.   }
  1619.   keys.forEach(function(key) {
  1620.     if (!key.match(/^\d+$/)) {
  1621.       output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
  1622.           key, true));
  1623.     }
  1624.   });
  1625.   return output;
  1626. }
  1627.  
  1628.  
  1629. function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
  1630.   var name, str, desc;
  1631.   desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
  1632.   if (desc.get) {
  1633.     if (desc.set) {
  1634.       str = ctx.stylize('[Getter/Setter]', 'special');
  1635.     } else {
  1636.       str = ctx.stylize('[Getter]', 'special');
  1637.     }
  1638.   } else {
  1639.     if (desc.set) {
  1640.       str = ctx.stylize('[Setter]', 'special');
  1641.     }
  1642.   }
  1643.   if (!hasOwnProperty(visibleKeys, key)) {
  1644.     name = '[' + key + ']';
  1645.   }
  1646.   if (!str) {
  1647.     if (ctx.seen.indexOf(desc.value) < 0) {
  1648.       if (isNull(recurseTimes)) {
  1649.         str = formatValue(ctx, desc.value, null);
  1650.       } else {
  1651.         str = formatValue(ctx, desc.value, recurseTimes - 1);
  1652.       }
  1653.       if (str.indexOf('\n') > -1) {
  1654.         if (array) {
  1655.           str = str.split('\n').map(function(line) {
  1656.             return '  ' + line;
  1657.           }).join('\n').substr(2);
  1658.         } else {
  1659.           str = '\n' + str.split('\n').map(function(line) {
  1660.             return '   ' + line;
  1661.           }).join('\n');
  1662.         }
  1663.       }
  1664.     } else {
  1665.       str = ctx.stylize('[Circular]', 'special');
  1666.     }
  1667.   }
  1668.   if (isUndefined(name)) {
  1669.     if (array && key.match(/^\d+$/)) {
  1670.       return str;
  1671.     }
  1672.     name = JSON.stringify('' + key);
  1673.     if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
  1674.       name = name.substr(1, name.length - 2);
  1675.       name = ctx.stylize(name, 'name');
  1676.     } else {
  1677.       name = name.replace(/'/g, "\\'")
  1678.                  .replace(/\\"/g, '"')
  1679.                  .replace(/(^"|"$)/g, "'");
  1680.       name = ctx.stylize(name, 'string');
  1681.     }
  1682.   }
  1683.  
  1684.   return name + ': ' + str;
  1685. }
  1686.  
  1687.  
  1688. function reduceToSingleString(output, base, braces) {
  1689.   var numLinesEst = 0;
  1690.   var length = output.reduce(function(prev, cur) {
  1691.     numLinesEst++;
  1692.     if (cur.indexOf('\n') >= 0) numLinesEst++;
  1693.     return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
  1694.   }, 0);
  1695.  
  1696.   if (length > 60) {
  1697.     return braces[0] +
  1698.            (base === '' ? '' : base + '\n ') +
  1699.            ' ' +
  1700.            output.join(',\n  ') +
  1701.            ' ' +
  1702.            braces[1];
  1703.   }
  1704.  
  1705.   return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
  1706. }
  1707.  
  1708.  
  1709. // NOTE: These type checking functions intentionally don't use `instanceof`
  1710. // because it is fragile and can be easily faked with `Object.create()`.
  1711. function isArray(ar) {
  1712.   return Array.isArray(ar);
  1713. }
  1714. exports.isArray = isArray;
  1715.  
  1716. function isBoolean(arg) {
  1717.   return typeof arg === 'boolean';
  1718. }
  1719. exports.isBoolean = isBoolean;
  1720.  
  1721. function isNull(arg) {
  1722.   return arg === null;
  1723. }
  1724. exports.isNull = isNull;
  1725.  
  1726. function isNullOrUndefined(arg) {
  1727.   return arg == null;
  1728. }
  1729. exports.isNullOrUndefined = isNullOrUndefined;
  1730.  
  1731. function isNumber(arg) {
  1732.   return typeof arg === 'number';
  1733. }
  1734. exports.isNumber = isNumber;
  1735.  
  1736. function isString(arg) {
  1737.   return typeof arg === 'string';
  1738. }
  1739. exports.isString = isString;
  1740.  
  1741. function isSymbol(arg) {
  1742.   return typeof arg === 'symbol';
  1743. }
  1744. exports.isSymbol = isSymbol;
  1745.  
  1746. function isUndefined(arg) {
  1747.   return arg === void 0;
  1748. }
  1749. exports.isUndefined = isUndefined;
  1750.  
  1751. function isRegExp(re) {
  1752.   return isObject(re) && objectToString(re) === '[object RegExp]';
  1753. }
  1754. exports.isRegExp = isRegExp;
  1755.  
  1756. function isObject(arg) {
  1757.   return typeof arg === 'object' && arg !== null;
  1758. }
  1759. exports.isObject = isObject;
  1760.  
  1761. function isDate(d) {
  1762.   return isObject(d) && objectToString(d) === '[object Date]';
  1763. }
  1764. exports.isDate = isDate;
  1765.  
  1766. function isError(e) {
  1767.   return isObject(e) &&
  1768.       (objectToString(e) === '[object Error]' || e instanceof Error);
  1769. }
  1770. exports.isError = isError;
  1771.  
  1772. function isFunction(arg) {
  1773.   return typeof arg === 'function';
  1774. }
  1775. exports.isFunction = isFunction;
  1776.  
  1777. function isPrimitive(arg) {
  1778.   return arg === null ||
  1779.          typeof arg === 'boolean' ||
  1780.          typeof arg === 'number' ||
  1781.          typeof arg === 'string' ||
  1782.          typeof arg === 'symbol' ||  // ES6 symbol
  1783.          typeof arg === 'undefined';
  1784. }
  1785. exports.isPrimitive = isPrimitive;
  1786.  
  1787. exports.isBuffer = __webpack_require__("1gqn");
  1788.  
  1789. function objectToString(o) {
  1790.   return Object.prototype.toString.call(o);
  1791. }
  1792.  
  1793.  
  1794. function pad(n) {
  1795.   return n < 10 ? '0' + n.toString(10) : n.toString(10);
  1796. }
  1797.  
  1798.  
  1799. var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
  1800.               'Oct', 'Nov', 'Dec'];
  1801.  
  1802. // 26 Feb 16:19:34
  1803. function timestamp() {
  1804.   var d = new Date();
  1805.   var time = [pad(d.getHours()),
  1806.               pad(d.getMinutes()),
  1807.               pad(d.getSeconds())].join(':');
  1808.   return [d.getDate(), months[d.getMonth()], time].join(' ');
  1809. }
  1810.  
  1811.  
  1812. // log is just a thin wrapper to console.log that prepends a timestamp
  1813. exports.log = function() {
  1814.   console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
  1815. };
  1816.  
  1817.  
  1818. /**
  1819.  * Inherit the prototype methods from one constructor into another.
  1820.  *
  1821.  * The Function.prototype.inherits from lang.js rewritten as a standalone
  1822.  * function (not on Function.prototype). NOTE: If this file is to be loaded
  1823.  * during bootstrapping this function needs to be rewritten using some native
  1824.  * functions as prototype setup using normal JavaScript does not work as
  1825.  * expected during bootstrapping (see mirror.js in r114903).
  1826.  *
  1827.  * @param {function} ctor Constructor function which needs to inherit the
  1828.  *     prototype.
  1829.  * @param {function} superCtor Constructor function to inherit prototype from.
  1830.  */
  1831. exports.inherits = __webpack_require__("KKCa");
  1832.  
  1833. exports._extend = function(origin, add) {
  1834.   // Don't do anything if add isn't an object
  1835.   if (!add || !isObject(add)) return origin;
  1836.  
  1837.   var keys = Object.keys(add);
  1838.   var i = keys.length;
  1839.   while (i--) {
  1840.     origin[keys[i]] = add[keys[i]];
  1841.   }
  1842.   return origin;
  1843. };
  1844.  
  1845. function hasOwnProperty(obj, prop) {
  1846.   return Object.prototype.hasOwnProperty.call(obj, prop);
  1847. }
  1848.  
  1849. var kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined;
  1850.  
  1851. exports.promisify = function promisify(original) {
  1852.   if (typeof original !== 'function')
  1853.     throw new TypeError('The "original" argument must be of type Function');
  1854.  
  1855.   if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {
  1856.     var fn = original[kCustomPromisifiedSymbol];
  1857.     if (typeof fn !== 'function') {
  1858.       throw new TypeError('The "util.promisify.custom" argument must be of type Function');
  1859.     }
  1860.     Object.defineProperty(fn, kCustomPromisifiedSymbol, {
  1861.       value: fn, enumerable: false, writable: false, configurable: true
  1862.     });
  1863.     return fn;
  1864.   }
  1865.  
  1866.   function fn() {
  1867.     var promiseResolve, promiseReject;
  1868.     var promise = new Promise(function (resolve, reject) {
  1869.       promiseResolve = resolve;
  1870.       promiseReject = reject;
  1871.     });
  1872.  
  1873.     var args = [];
  1874.     for (var i = 0; i < arguments.length; i++) {
  1875.       args.push(arguments[i]);
  1876.     }
  1877.     args.push(function (err, value) {
  1878.       if (err) {
  1879.         promiseReject(err);
  1880.       } else {
  1881.         promiseResolve(value);
  1882.       }
  1883.     });
  1884.  
  1885.     try {
  1886.       original.apply(this, args);
  1887.     } catch (err) {
  1888.       promiseReject(err);
  1889.     }
  1890.  
  1891.     return promise;
  1892.   }
  1893.  
  1894.   Object.setPrototypeOf(fn, Object.getPrototypeOf(original));
  1895.  
  1896.   if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {
  1897.     value: fn, enumerable: false, writable: false, configurable: true
  1898.   });
  1899.   return Object.defineProperties(
  1900.     fn,
  1901.     getOwnPropertyDescriptors(original)
  1902.   );
  1903. }
  1904.  
  1905. exports.promisify.custom = kCustomPromisifiedSymbol
  1906.  
  1907. function callbackifyOnRejected(reason, cb) {
  1908.   // `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).
  1909.   // Because `null` is a special error value in callbacks which means "no error
  1910.   // occurred", we error-wrap so the callback consumer can distinguish between
  1911.   // "the promise rejected with null" or "the promise fulfilled with undefined".
  1912.   if (!reason) {
  1913.     var newReason = new Error('Promise was rejected with a falsy value');
  1914.     newReason.reason = reason;
  1915.     reason = newReason;
  1916.   }
  1917.   return cb(reason);
  1918. }
  1919.  
  1920. function callbackify(original) {
  1921.   if (typeof original !== 'function') {
  1922.     throw new TypeError('The "original" argument must be of type Function');
  1923.   }
  1924.  
  1925.   // We DO NOT return the promise as it gives the user a false sense that
  1926.   // the promise is actually somehow related to the callback's execution
  1927.   // and that the callback throwing will reject the promise.
  1928.   function callbackified() {
  1929.     var args = [];
  1930.     for (var i = 0; i < arguments.length; i++) {
  1931.       args.push(arguments[i]);
  1932.     }
  1933.  
  1934.     var maybeCb = args.pop();
  1935.     if (typeof maybeCb !== 'function') {
  1936.       throw new TypeError('The last argument must be of type Function');
  1937.     }
  1938.     var self = this;
  1939.     var cb = function() {
  1940.       return maybeCb.apply(self, arguments);
  1941.     };
  1942.     // In true node style we process the callback on `nextTick` with all the
  1943.     // implications (stack, `uncaughtException`, `async_hooks`)
  1944.     original.apply(this, args)
  1945.       .then(function(ret) { process.nextTick(cb, null, ret) },
  1946.             function(rej) { process.nextTick(callbackifyOnRejected, rej, cb) });
  1947.   }
  1948.  
  1949.   Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));
  1950.   Object.defineProperties(callbackified,
  1951.                           getOwnPropertyDescriptors(original));
  1952.   return callbackified;
  1953. }
  1954. exports.callbackify = callbackify;
  1955.  
  1956. /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__("8oxB")))
  1957.  
  1958. /***/ }),
  1959.  
  1960. /***/ "MgzW":
  1961. /***/ (function(module, exports, __webpack_require__) {
  1962.  
  1963. "use strict";
  1964. /*
  1965. object-assign
  1966. (c) Sindre Sorhus
  1967. @license MIT
  1968. */
  1969.  
  1970.  
  1971. /* eslint-disable no-unused-vars */
  1972. var getOwnPropertySymbols = Object.getOwnPropertySymbols;
  1973. var hasOwnProperty = Object.prototype.hasOwnProperty;
  1974. var propIsEnumerable = Object.prototype.propertyIsEnumerable;
  1975.  
  1976. function toObject(val) {
  1977. 	if (val === null || val === undefined) {
  1978. 		throw new TypeError('Object.assign cannot be called with null or undefined');
  1979. 	}
  1980.  
  1981. 	return Object(val);
  1982. }
  1983.  
  1984. function shouldUseNative() {
  1985. 	try {
  1986. 		if (!Object.assign) {
  1987. 			return false;
  1988. 		}
  1989.  
  1990. 		// Detect buggy property enumeration order in older V8 versions.
  1991.  
  1992. 		// https://bugs.chromium.org/p/v8/issues/detail?id=4118
  1993. 		var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
  1994. 		test1[5] = 'de';
  1995. 		if (Object.getOwnPropertyNames(test1)[0] === '5') {
  1996. 			return false;
  1997. 		}
  1998.  
  1999. 		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
  2000. 		var test2 = {};
  2001. 		for (var i = 0; i < 10; i++) {
  2002. 			test2['_' + String.fromCharCode(i)] = i;
  2003. 		}
  2004. 		var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
  2005. 			return test2[n];
  2006. 		});
  2007. 		if (order2.join('') !== '0123456789') {
  2008. 			return false;
  2009. 		}
  2010.  
  2011. 		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
  2012. 		var test3 = {};
  2013. 		'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
  2014. 			test3[letter] = letter;
  2015. 		});
  2016. 		if (Object.keys(Object.assign({}, test3)).join('') !==
  2017. 				'abcdefghijklmnopqrst') {
  2018. 			return false;
  2019. 		}
  2020.  
  2021. 		return true;
  2022. 	} catch (err) {
  2023. 		// We don't expect any of the above to throw, but better to be safe.
  2024. 		return false;
  2025. 	}
  2026. }
  2027.  
  2028. module.exports = shouldUseNative() ? Object.assign : function (target, source) {
  2029. 	var from;
  2030. 	var to = toObject(target);
  2031. 	var symbols;
  2032.  
  2033. 	for (var s = 1; s < arguments.length; s++) {
  2034. 		from = Object(arguments[s]);
  2035.  
  2036. 		for (var key in from) {
  2037. 			if (hasOwnProperty.call(from, key)) {
  2038. 				to[key] = from[key];
  2039. 			}
  2040. 		}
  2041.  
  2042. 		if (getOwnPropertySymbols) {
  2043. 			symbols = getOwnPropertySymbols(from);
  2044. 			for (var i = 0; i < symbols.length; i++) {
  2045. 				if (propIsEnumerable.call(from, symbols[i])) {
  2046. 					to[symbols[i]] = from[symbols[i]];
  2047. 				}
  2048. 			}
  2049. 		}
  2050. 	}
  2051.  
  2052. 	return to;
  2053. };
  2054.  
  2055.  
  2056. /***/ }),
  2057.  
  2058. /***/ "PKsF":
  2059. /***/ (function(module, exports, __webpack_require__) {
  2060.  
  2061. /*
  2062.  *  Copyright 2011 Twitter, Inc.
  2063.  *  Licensed under the Apache License, Version 2.0 (the "License");
  2064.  *  you may not use this file except in compliance with the License.
  2065.  *  You may obtain a copy of the License at
  2066.  *
  2067.  *  http://www.apache.org/licenses/LICENSE-2.0
  2068.  *
  2069.  *  Unless required by applicable law or agreed to in writing, software
  2070.  *  distributed under the License is distributed on an "AS IS" BASIS,
  2071.  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  2072.  *  See the License for the specific language governing permissions and
  2073.  *  limitations under the License.
  2074.  */
  2075.  
  2076. (function (Hogan) {
  2077.   // Setup regex  assignments
  2078.   // remove whitespace according to Mustache spec
  2079.   var rIsWhitespace = /\S/,
  2080.       rQuot = /\"/g,
  2081.       rNewline =  /\n/g,
  2082.       rCr = /\r/g,
  2083.       rSlash = /\\/g,
  2084.       rLineSep = /\u2028/,
  2085.       rParagraphSep = /\u2029/;
  2086.  
  2087.   Hogan.tags = {
  2088.     '#': 1, '^': 2, '<': 3, '$': 4,
  2089.     '/': 5, '!': 6, '>': 7, '=': 8, '_v': 9,
  2090.     '{': 10, '&': 11, '_t': 12
  2091.   };
  2092.  
  2093.   Hogan.scan = function scan(text, delimiters) {
  2094.     var len = text.length,
  2095.         IN_TEXT = 0,
  2096.         IN_TAG_TYPE = 1,
  2097.         IN_TAG = 2,
  2098.         state = IN_TEXT,
  2099.         tagType = null,
  2100.         tag = null,
  2101.         buf = '',
  2102.         tokens = [],
  2103.         seenTag = false,
  2104.         i = 0,
  2105.         lineStart = 0,
  2106.         otag = '{{',
  2107.         ctag = '}}';
  2108.  
  2109.     function addBuf() {
  2110.       if (buf.length > 0) {
  2111.         tokens.push({tag: '_t', text: new String(buf)});
  2112.         buf = '';
  2113.       }
  2114.     }
  2115.  
  2116.     function lineIsWhitespace() {
  2117.       var isAllWhitespace = true;
  2118.       for (var j = lineStart; j < tokens.length; j++) {
  2119.         isAllWhitespace =
  2120.           (Hogan.tags[tokens[j].tag] < Hogan.tags['_v']) ||
  2121.           (tokens[j].tag == '_t' && tokens[j].text.match(rIsWhitespace) === null);
  2122.         if (!isAllWhitespace) {
  2123.           return false;
  2124.         }
  2125.       }
  2126.  
  2127.       return isAllWhitespace;
  2128.     }
  2129.  
  2130.     function filterLine(haveSeenTag, noNewLine) {
  2131.       addBuf();
  2132.  
  2133.       if (haveSeenTag && lineIsWhitespace()) {
  2134.         for (var j = lineStart, next; j < tokens.length; j++) {
  2135.           if (tokens[j].text) {
  2136.             if ((next = tokens[j+1]) && next.tag == '>') {
  2137.               // set indent to token value
  2138.               next.indent = tokens[j].text.toString()
  2139.             }
  2140.             tokens.splice(j, 1);
  2141.           }
  2142.         }
  2143.       } else if (!noNewLine) {
  2144.         tokens.push({tag:'\n'});
  2145.       }
  2146.  
  2147.       seenTag = false;
  2148.       lineStart = tokens.length;
  2149.     }
  2150.  
  2151.     function changeDelimiters(text, index) {
  2152.       var close = '=' + ctag,
  2153.           closeIndex = text.indexOf(close, index),
  2154.           delimiters = trim(
  2155.             text.substring(text.indexOf('=', index) + 1, closeIndex)
  2156.           ).split(' ');
  2157.  
  2158.       otag = delimiters[0];
  2159.       ctag = delimiters[delimiters.length - 1];
  2160.  
  2161.       return closeIndex + close.length - 1;
  2162.     }
  2163.  
  2164.     if (delimiters) {
  2165.       delimiters = delimiters.split(' ');
  2166.       otag = delimiters[0];
  2167.       ctag = delimiters[1];
  2168.     }
  2169.  
  2170.     for (i = 0; i < len; i++) {
  2171.       if (state == IN_TEXT) {
  2172.         if (tagChange(otag, text, i)) {
  2173.           --i;
  2174.           addBuf();
  2175.           state = IN_TAG_TYPE;
  2176.         } else {
  2177.           if (text.charAt(i) == '\n') {
  2178.             filterLine(seenTag);
  2179.           } else {
  2180.             buf += text.charAt(i);
  2181.           }
  2182.         }
  2183.       } else if (state == IN_TAG_TYPE) {
  2184.         i += otag.length - 1;
  2185.         tag = Hogan.tags[text.charAt(i + 1)];
  2186.         tagType = tag ? text.charAt(i + 1) : '_v';
  2187.         if (tagType == '=') {
  2188.           i = changeDelimiters(text, i);
  2189.           state = IN_TEXT;
  2190.         } else {
  2191.           if (tag) {
  2192.             i++;
  2193.           }
  2194.           state = IN_TAG;
  2195.         }
  2196.         seenTag = i;
  2197.       } else {
  2198.         if (tagChange(ctag, text, i)) {
  2199.           tokens.push({tag: tagType, n: trim(buf), otag: otag, ctag: ctag,
  2200.                        i: (tagType == '/') ? seenTag - otag.length : i + ctag.length});
  2201.           buf = '';
  2202.           i += ctag.length - 1;
  2203.           state = IN_TEXT;
  2204.           if (tagType == '{') {
  2205.             if (ctag == '}}') {
  2206.               i++;
  2207.             } else {
  2208.               cleanTripleStache(tokens[tokens.length - 1]);
  2209.             }
  2210.           }
  2211.         } else {
  2212.           buf += text.charAt(i);
  2213.         }
  2214.       }
  2215.     }
  2216.  
  2217.     filterLine(seenTag, true);
  2218.  
  2219.     return tokens;
  2220.   }
  2221.  
  2222.   function cleanTripleStache(token) {
  2223.     if (token.n.substr(token.n.length - 1) === '}') {
  2224.       token.n = token.n.substring(0, token.n.length - 1);
  2225.     }
  2226.   }
  2227.  
  2228.   function trim(s) {
  2229.     if (s.trim) {
  2230.       return s.trim();
  2231.     }
  2232.  
  2233.     return s.replace(/^\s*|\s*$/g, '');
  2234.   }
  2235.  
  2236.   function tagChange(tag, text, index) {
  2237.     if (text.charAt(index) != tag.charAt(0)) {
  2238.       return false;
  2239.     }
  2240.  
  2241.     for (var i = 1, l = tag.length; i < l; i++) {
  2242.       if (text.charAt(index + i) != tag.charAt(i)) {
  2243.         return false;
  2244.       }
  2245.     }
  2246.  
  2247.     return true;
  2248.   }
  2249.  
  2250.   // the tags allowed inside super templates
  2251.   var allowedInSuper = {'_t': true, '\n': true, '$': true, '/': true};
  2252.  
  2253.   function buildTree(tokens, kind, stack, customTags) {
  2254.     var instructions = [],
  2255.         opener = null,
  2256.         tail = null,
  2257.         token = null;
  2258.  
  2259.     tail = stack[stack.length - 1];
  2260.  
  2261.     while (tokens.length > 0) {
  2262.       token = tokens.shift();
  2263.  
  2264.       if (tail && tail.tag == '<' && !(token.tag in allowedInSuper)) {
  2265.         throw new Error('Illegal content in < super tag.');
  2266.       }
  2267.  
  2268.       if (Hogan.tags[token.tag] <= Hogan.tags['$'] || isOpener(token, customTags)) {
  2269.         stack.push(token);
  2270.         token.nodes = buildTree(tokens, token.tag, stack, customTags);
  2271.       } else if (token.tag == '/') {
  2272.         if (stack.length === 0) {
  2273.           throw new Error('Closing tag without opener: /' + token.n);
  2274.         }
  2275.         opener = stack.pop();
  2276.         if (token.n != opener.n && !isCloser(token.n, opener.n, customTags)) {
  2277.           throw new Error('Nesting error: ' + opener.n + ' vs. ' + token.n);
  2278.         }
  2279.         opener.end = token.i;
  2280.         return instructions;
  2281.       } else if (token.tag == '\n') {
  2282.         token.last = (tokens.length == 0) || (tokens[0].tag == '\n');
  2283.       }
  2284.  
  2285.       instructions.push(token);
  2286.     }
  2287.  
  2288.     if (stack.length > 0) {
  2289.       throw new Error('missing closing tag: ' + stack.pop().n);
  2290.     }
  2291.  
  2292.     return instructions;
  2293.   }
  2294.  
  2295.   function isOpener(token, tags) {
  2296.     for (var i = 0, l = tags.length; i < l; i++) {
  2297.       if (tags[i].o == token.n) {
  2298.         token.tag = '#';
  2299.         return true;
  2300.       }
  2301.     }
  2302.   }
  2303.  
  2304.   function isCloser(close, open, tags) {
  2305.     for (var i = 0, l = tags.length; i < l; i++) {
  2306.       if (tags[i].c == close && tags[i].o == open) {
  2307.         return true;
  2308.       }
  2309.     }
  2310.   }
  2311.  
  2312.   function stringifySubstitutions(obj) {
  2313.     var items = [];
  2314.     for (var key in obj) {
  2315.       items.push('"' + esc(key) + '": function(c,p,t,i) {' + obj[key] + '}');
  2316.     }
  2317.     return "{ " + items.join(",") + " }";
  2318.   }
  2319.  
  2320.   function stringifyPartials(codeObj) {
  2321.     var partials = [];
  2322.     for (var key in codeObj.partials) {
  2323.       partials.push('"' + esc(key) + '":{name:"' + esc(codeObj.partials[key].name) + '", ' + stringifyPartials(codeObj.partials[key]) + "}");
  2324.     }
  2325.     return "partials: {" + partials.join(",") + "}, subs: " + stringifySubstitutions(codeObj.subs);
  2326.   }
  2327.  
  2328.   Hogan.stringify = function(codeObj, text, options) {
  2329.     return "{code: function (c,p,i) { " + Hogan.wrapMain(codeObj.code) + " }," + stringifyPartials(codeObj) +  "}";
  2330.   }
  2331.  
  2332.   var serialNo = 0;
  2333.   Hogan.generate = function(tree, text, options) {
  2334.     serialNo = 0;
  2335.     var context = { code: '', subs: {}, partials: {} };
  2336.     Hogan.walk(tree, context);
  2337.  
  2338.     if (options.asString) {
  2339.       return this.stringify(context, text, options);
  2340.     }
  2341.  
  2342.     return this.makeTemplate(context, text, options);
  2343.   }
  2344.  
  2345.   Hogan.wrapMain = function(code) {
  2346.     return 'var t=this;t.b(i=i||"");' + code + 'return t.fl();';
  2347.   }
  2348.  
  2349.   Hogan.template = Hogan.Template;
  2350.  
  2351.   Hogan.makeTemplate = function(codeObj, text, options) {
  2352.     var template = this.makePartials(codeObj);
  2353.     template.code = new Function('c', 'p', 'i', this.wrapMain(codeObj.code));
  2354.     return new this.template(template, text, this, options);
  2355.   }
  2356.  
  2357.   Hogan.makePartials = function(codeObj) {
  2358.     var key, template = {subs: {}, partials: codeObj.partials, name: codeObj.name};
  2359.     for (key in template.partials) {
  2360.       template.partials[key] = this.makePartials(template.partials[key]);
  2361.     }
  2362.     for (key in codeObj.subs) {
  2363.       template.subs[key] = new Function('c', 'p', 't', 'i', codeObj.subs[key]);
  2364.     }
  2365.     return template;
  2366.   }
  2367.  
  2368.   function esc(s) {
  2369.     return s.replace(rSlash, '\\\\')
  2370.             .replace(rQuot, '\\\"')
  2371.             .replace(rNewline, '\\n')
  2372.             .replace(rCr, '\\r')
  2373.             .replace(rLineSep, '\\u2028')
  2374.             .replace(rParagraphSep, '\\u2029');
  2375.   }
  2376.  
  2377.   function chooseMethod(s) {
  2378.     return (~s.indexOf('.')) ? 'd' : 'f';
  2379.   }
  2380.  
  2381.   function createPartial(node, context) {
  2382.     var prefix = "<" + (context.prefix || "");
  2383.     var sym = prefix + node.n + serialNo++;
  2384.     context.partials[sym] = {name: node.n, partials: {}};
  2385.     context.code += 't.b(t.rp("' +  esc(sym) + '",c,p,"' + (node.indent || '') + '"));';
  2386.     return sym;
  2387.   }
  2388.  
  2389.   Hogan.codegen = {
  2390.     '#': function(node, context) {
  2391.       context.code += 'if(t.s(t.' + chooseMethod(node.n) + '("' + esc(node.n) + '",c,p,1),' +
  2392.                       'c,p,0,' + node.i + ',' + node.end + ',"' + node.otag + " " + node.ctag + '")){' +
  2393.                       't.rs(c,p,' + 'function(c,p,t){';
  2394.       Hogan.walk(node.nodes, context);
  2395.       context.code += '});c.pop();}';
  2396.     },
  2397.  
  2398.     '^': function(node, context) {
  2399.       context.code += 'if(!t.s(t.' + chooseMethod(node.n) + '("' + esc(node.n) + '",c,p,1),c,p,1,0,0,"")){';
  2400.       Hogan.walk(node.nodes, context);
  2401.       context.code += '};';
  2402.     },
  2403.  
  2404.     '>': createPartial,
  2405.     '<': function(node, context) {
  2406.       var ctx = {partials: {}, code: '', subs: {}, inPartial: true};
  2407.       Hogan.walk(node.nodes, ctx);
  2408.       var template = context.partials[createPartial(node, context)];
  2409.       template.subs = ctx.subs;
  2410.       template.partials = ctx.partials;
  2411.     },
  2412.  
  2413.     '$': function(node, context) {
  2414.       var ctx = {subs: {}, code: '', partials: context.partials, prefix: node.n};
  2415.       Hogan.walk(node.nodes, ctx);
  2416.       context.subs[node.n] = ctx.code;
  2417.       if (!context.inPartial) {
  2418.         context.code += 't.sub("' + esc(node.n) + '",c,p,i);';
  2419.       }
  2420.     },
  2421.  
  2422.     '\n': function(node, context) {
  2423.       context.code += write('"\\n"' + (node.last ? '' : ' + i'));
  2424.     },
  2425.  
  2426.     '_v': function(node, context) {
  2427.       context.code += 't.b(t.v(t.' + chooseMethod(node.n) + '("' + esc(node.n) + '",c,p,0)));';
  2428.     },
  2429.  
  2430.     '_t': function(node, context) {
  2431.       context.code += write('"' + esc(node.text) + '"');
  2432.     },
  2433.  
  2434.     '{': tripleStache,
  2435.  
  2436.     '&': tripleStache
  2437.   }
  2438.  
  2439.   function tripleStache(node, context) {
  2440.     context.code += 't.b(t.t(t.' + chooseMethod(node.n) + '("' + esc(node.n) + '",c,p,0)));';
  2441.   }
  2442.  
  2443.   function write(s) {
  2444.     return 't.b(' + s + ');';
  2445.   }
  2446.  
  2447.   Hogan.walk = function(nodelist, context) {
  2448.     var func;
  2449.     for (var i = 0, l = nodelist.length; i < l; i++) {
  2450.       func = Hogan.codegen[nodelist[i].tag];
  2451.       func && func(nodelist[i], context);
  2452.     }
  2453.     return context;
  2454.   }
  2455.  
  2456.   Hogan.parse = function(tokens, text, options) {
  2457.     options = options || {};
  2458.     return buildTree(tokens, '', [], options.sectionTags || []);
  2459.   }
  2460.  
  2461.   Hogan.cache = {};
  2462.  
  2463.   Hogan.cacheKey = function(text, options) {
  2464.     return [text, !!options.asString, !!options.disableLambda, options.delimiters, !!options.modelGet].join('||');
  2465.   }
  2466.  
  2467.   Hogan.compile = function(text, options) {
  2468.     options = options || {};
  2469.     var key = Hogan.cacheKey(text, options);
  2470.     var template = this.cache[key];
  2471.  
  2472.     if (template) {
  2473.       var partials = template.partials;
  2474.       for (var name in partials) {
  2475.         delete partials[name].instance;
  2476.       }
  2477.       return template;
  2478.     }
  2479.  
  2480.     template = this.generate(this.parse(this.scan(text, options.delimiters), text, options), text, options);
  2481.     return this.cache[key] = template;
  2482.   }
  2483. })( true ? exports : undefined);
  2484.  
  2485.  
  2486. /***/ }),
  2487.  
  2488. /***/ "Ruv9":
  2489. /***/ (function(module, exports, __webpack_require__) {
  2490.  
  2491. /*
  2492.  *  Copyright 2011 Twitter, Inc.
  2493.  *  Licensed under the Apache License, Version 2.0 (the "License");
  2494.  *  you may not use this file except in compliance with the License.
  2495.  *  You may obtain a copy of the License at
  2496.  *
  2497.  *  http://www.apache.org/licenses/LICENSE-2.0
  2498.  *
  2499.  *  Unless required by applicable law or agreed to in writing, software
  2500.  *  distributed under the License is distributed on an "AS IS" BASIS,
  2501.  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  2502.  *  See the License for the specific language governing permissions and
  2503.  *  limitations under the License.
  2504.  */
  2505.  
  2506. // This file is for use with Node.js. See dist/ for browser files.
  2507.  
  2508. var Hogan = __webpack_require__("PKsF");
  2509. Hogan.Template = __webpack_require__("cK6b").Template;
  2510. Hogan.template = Hogan.Template;
  2511. module.exports = Hogan;
  2512.  
  2513.  
  2514. /***/ }),
  2515.  
  2516. /***/ "cK6b":
  2517. /***/ (function(module, exports, __webpack_require__) {
  2518.  
  2519. /*
  2520.  *  Copyright 2011 Twitter, Inc.
  2521.  *  Licensed under the Apache License, Version 2.0 (the "License");
  2522.  *  you may not use this file except in compliance with the License.
  2523.  *  You may obtain a copy of the License at
  2524.  *
  2525.  *  http://www.apache.org/licenses/LICENSE-2.0
  2526.  *
  2527.  *  Unless required by applicable law or agreed to in writing, software
  2528.  *  distributed under the License is distributed on an "AS IS" BASIS,
  2529.  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  2530.  *  See the License for the specific language governing permissions and
  2531.  *  limitations under the License.
  2532.  */
  2533.  
  2534. var Hogan = {};
  2535.  
  2536. (function (Hogan) {
  2537.   Hogan.Template = function (codeObj, text, compiler, options) {
  2538.     codeObj = codeObj || {};
  2539.     this.r = codeObj.code || this.r;
  2540.     this.c = compiler;
  2541.     this.options = options || {};
  2542.     this.text = text || '';
  2543.     this.partials = codeObj.partials || {};
  2544.     this.subs = codeObj.subs || {};
  2545.     this.buf = '';
  2546.   }
  2547.  
  2548.   Hogan.Template.prototype = {
  2549.     // render: replaced by generated code.
  2550.     r: function (context, partials, indent) { return ''; },
  2551.  
  2552.     // variable escaping
  2553.     v: hoganEscape,
  2554.  
  2555.     // triple stache
  2556.     t: coerceToString,
  2557.  
  2558.     render: function render(context, partials, indent) {
  2559.       return this.ri([context], partials || {}, indent);
  2560.     },
  2561.  
  2562.     // render internal -- a hook for overrides that catches partials too
  2563.     ri: function (context, partials, indent) {
  2564.       return this.r(context, partials, indent);
  2565.     },
  2566.  
  2567.     // ensurePartial
  2568.     ep: function(symbol, partials) {
  2569.       var partial = this.partials[symbol];
  2570.  
  2571.       // check to see that if we've instantiated this partial before
  2572.       var template = partials[partial.name];
  2573.       if (partial.instance && partial.base == template) {
  2574.         return partial.instance;
  2575.       }
  2576.  
  2577.       if (typeof template == 'string') {
  2578.         if (!this.c) {
  2579.           throw new Error("No compiler available.");
  2580.         }
  2581.         template = this.c.compile(template, this.options);
  2582.       }
  2583.  
  2584.       if (!template) {
  2585.         return null;
  2586.       }
  2587.  
  2588.       // We use this to check whether the partials dictionary has changed
  2589.       this.partials[symbol].base = template;
  2590.  
  2591.       if (partial.subs) {
  2592.         // Make sure we consider parent template now
  2593.         if (!partials.stackText) partials.stackText = {};
  2594.         for (key in partial.subs) {
  2595.           if (!partials.stackText[key]) {
  2596.             partials.stackText[key] = (this.activeSub !== undefined && partials.stackText[this.activeSub]) ? partials.stackText[this.activeSub] : this.text;
  2597.           }
  2598.         }
  2599.         template = createSpecializedPartial(template, partial.subs, partial.partials,
  2600.           this.stackSubs, this.stackPartials, partials.stackText);
  2601.       }
  2602.       this.partials[symbol].instance = template;
  2603.  
  2604.       return template;
  2605.     },
  2606.  
  2607.     // tries to find a partial in the current scope and render it
  2608.     rp: function(symbol, context, partials, indent) {
  2609.       var partial = this.ep(symbol, partials);
  2610.       if (!partial) {
  2611.         return '';
  2612.       }
  2613.  
  2614.       return partial.ri(context, partials, indent);
  2615.     },
  2616.  
  2617.     // render a section
  2618.     rs: function(context, partials, section) {
  2619.       var tail = context[context.length - 1];
  2620.  
  2621.       if (!isArray(tail)) {
  2622.         section(context, partials, this);
  2623.         return;
  2624.       }
  2625.  
  2626.       for (var i = 0; i < tail.length; i++) {
  2627.         context.push(tail[i]);
  2628.         section(context, partials, this);
  2629.         context.pop();
  2630.       }
  2631.     },
  2632.  
  2633.     // maybe start a section
  2634.     s: function(val, ctx, partials, inverted, start, end, tags) {
  2635.       var pass;
  2636.  
  2637.       if (isArray(val) && val.length === 0) {
  2638.         return false;
  2639.       }
  2640.  
  2641.       if (typeof val == 'function') {
  2642.         val = this.ms(val, ctx, partials, inverted, start, end, tags);
  2643.       }
  2644.  
  2645.       pass = !!val;
  2646.  
  2647.       if (!inverted && pass && ctx) {
  2648.         ctx.push((typeof val == 'object') ? val : ctx[ctx.length - 1]);
  2649.       }
  2650.  
  2651.       return pass;
  2652.     },
  2653.  
  2654.     // find values with dotted names
  2655.     d: function(key, ctx, partials, returnFound) {
  2656.       var found,
  2657.           names = key.split('.'),
  2658.           val = this.f(names[0], ctx, partials, returnFound),
  2659.           doModelGet = this.options.modelGet,
  2660.           cx = null;
  2661.  
  2662.       if (key === '.' && isArray(ctx[ctx.length - 2])) {
  2663.         val = ctx[ctx.length - 1];
  2664.       } else {
  2665.         for (var i = 1; i < names.length; i++) {
  2666.           found = findInScope(names[i], val, doModelGet);
  2667.           if (found !== undefined) {
  2668.             cx = val;
  2669.             val = found;
  2670.           } else {
  2671.             val = '';
  2672.           }
  2673.         }
  2674.       }
  2675.  
  2676.       if (returnFound && !val) {
  2677.         return false;
  2678.       }
  2679.  
  2680.       if (!returnFound && typeof val == 'function') {
  2681.         ctx.push(cx);
  2682.         val = this.mv(val, ctx, partials);
  2683.         ctx.pop();
  2684.       }
  2685.  
  2686.       return val;
  2687.     },
  2688.  
  2689.     // find values with normal names
  2690.     f: function(key, ctx, partials, returnFound) {
  2691.       var val = false,
  2692.           v = null,
  2693.           found = false,
  2694.           doModelGet = this.options.modelGet;
  2695.  
  2696.       for (var i = ctx.length - 1; i >= 0; i--) {
  2697.         v = ctx[i];
  2698.         val = findInScope(key, v, doModelGet);
  2699.         if (val !== undefined) {
  2700.           found = true;
  2701.           break;
  2702.         }
  2703.       }
  2704.  
  2705.       if (!found) {
  2706.         return (returnFound) ? false : "";
  2707.       }
  2708.  
  2709.       if (!returnFound && typeof val == 'function') {
  2710.         val = this.mv(val, ctx, partials);
  2711.       }
  2712.  
  2713.       return val;
  2714.     },
  2715.  
  2716.     // higher order templates
  2717.     ls: function(func, cx, partials, text, tags) {
  2718.       var oldTags = this.options.delimiters;
  2719.  
  2720.       this.options.delimiters = tags;
  2721.       this.b(this.ct(coerceToString(func.call(cx, text)), cx, partials));
  2722.       this.options.delimiters = oldTags;
  2723.  
  2724.       return false;
  2725.     },
  2726.  
  2727.     // compile text
  2728.     ct: function(text, cx, partials) {
  2729.       if (this.options.disableLambda) {
  2730.         throw new Error('Lambda features disabled.');
  2731.       }
  2732.       return this.c.compile(text, this.options).render(cx, partials);
  2733.     },
  2734.  
  2735.     // template result buffering
  2736.     b: function(s) { this.buf += s; },
  2737.  
  2738.     fl: function() { var r = this.buf; this.buf = ''; return r; },
  2739.  
  2740.     // method replace section
  2741.     ms: function(func, ctx, partials, inverted, start, end, tags) {
  2742.       var textSource,
  2743.           cx = ctx[ctx.length - 1],
  2744.           result = func.call(cx);
  2745.  
  2746.       if (typeof result == 'function') {
  2747.         if (inverted) {
  2748.           return true;
  2749.         } else {
  2750.           textSource = (this.activeSub && this.subsText && this.subsText[this.activeSub]) ? this.subsText[this.activeSub] : this.text;
  2751.           return this.ls(result, cx, partials, textSource.substring(start, end), tags);
  2752.         }
  2753.       }
  2754.  
  2755.       return result;
  2756.     },
  2757.  
  2758.     // method replace variable
  2759.     mv: function(func, ctx, partials) {
  2760.       var cx = ctx[ctx.length - 1];
  2761.       var result = func.call(cx);
  2762.  
  2763.       if (typeof result == 'function') {
  2764.         return this.ct(coerceToString(result.call(cx)), cx, partials);
  2765.       }
  2766.  
  2767.       return result;
  2768.     },
  2769.  
  2770.     sub: function(name, context, partials, indent) {
  2771.       var f = this.subs[name];
  2772.       if (f) {
  2773.         this.activeSub = name;
  2774.         f(context, partials, this, indent);
  2775.         this.activeSub = false;
  2776.       }
  2777.     }
  2778.  
  2779.   };
  2780.  
  2781.   //Find a key in an object
  2782.   function findInScope(key, scope, doModelGet) {
  2783.     var val;
  2784.  
  2785.     if (scope && typeof scope == 'object') {
  2786.  
  2787.       if (scope[key] !== undefined) {
  2788.         val = scope[key];
  2789.  
  2790.       // try lookup with get for backbone or similar model data
  2791.       } else if (doModelGet && scope.get && typeof scope.get == 'function') {
  2792.         val = scope.get(key);
  2793.       }
  2794.     }
  2795.  
  2796.     return val;
  2797.   }
  2798.  
  2799.   function createSpecializedPartial(instance, subs, partials, stackSubs, stackPartials, stackText) {
  2800.     function PartialTemplate() {};
  2801.     PartialTemplate.prototype = instance;
  2802.     function Substitutions() {};
  2803.     Substitutions.prototype = instance.subs;
  2804.     var key;
  2805.     var partial = new PartialTemplate();
  2806.     partial.subs = new Substitutions();
  2807.     partial.subsText = {};  //hehe. substext.
  2808.     partial.buf = '';
  2809.  
  2810.     stackSubs = stackSubs || {};
  2811.     partial.stackSubs = stackSubs;
  2812.     partial.subsText = stackText;
  2813.     for (key in subs) {
  2814.       if (!stackSubs[key]) stackSubs[key] = subs[key];
  2815.     }
  2816.     for (key in stackSubs) {
  2817.       partial.subs[key] = stackSubs[key];
  2818.     }
  2819.  
  2820.     stackPartials = stackPartials || {};
  2821.     partial.stackPartials = stackPartials;
  2822.     for (key in partials) {
  2823.       if (!stackPartials[key]) stackPartials[key] = partials[key];
  2824.     }
  2825.     for (key in stackPartials) {
  2826.       partial.partials[key] = stackPartials[key];
  2827.     }
  2828.  
  2829.     return partial;
  2830.   }
  2831.  
  2832.   var rAmp = /&/g,
  2833.       rLt = /</g,
  2834.       rGt = />/g,
  2835.       rApos = /\'/g,
  2836.       rQuot = /\"/g,
  2837.       hChars = /[&<>\"\']/;
  2838.  
  2839.   function coerceToString(val) {
  2840.     return String((val === null || val === undefined) ? '' : val);
  2841.   }
  2842.  
  2843.   function hoganEscape(str) {
  2844.     str = coerceToString(str);
  2845.     return hChars.test(str) ?
  2846.       str
  2847.         .replace(rAmp, '&amp;')
  2848.         .replace(rLt, '&lt;')
  2849.         .replace(rGt, '&gt;')
  2850.         .replace(rApos, '&#39;')
  2851.         .replace(rQuot, '&quot;') :
  2852.       str;
  2853.   }
  2854.  
  2855.   var isArray = Array.isArray || function(a) {
  2856.     return Object.prototype.toString.call(a) === '[object Array]';
  2857.   };
  2858.  
  2859. })( true ? exports : undefined);
  2860.  
  2861.  
  2862. /***/ }),
  2863.  
  2864. /***/ "e6Wu":
  2865. /***/ (function(module, __webpack_exports__, __webpack_require__) {
  2866.  
  2867. "use strict";
  2868. // ESM COMPAT FLAG
  2869. __webpack_require__.r(__webpack_exports__);
  2870.  
  2871. // EXTERNAL MODULE: ./node_modules/difflib/index.js
  2872. var difflib = __webpack_require__("7Mwc");
  2873.  
  2874. // CONCATENATED MODULE: ./node_modules/diff2html/lib-esm/types.js
  2875. var LineType;
  2876. (function (LineType) {
  2877.     LineType["INSERT"] = "insert";
  2878.     LineType["DELETE"] = "delete";
  2879.     LineType["CONTEXT"] = "context";
  2880. })(LineType || (LineType = {}));
  2881. var OutputFormatType = {
  2882.     LINE_BY_LINE: 'line-by-line',
  2883.     SIDE_BY_SIDE: 'side-by-side',
  2884. };
  2885. var LineMatchingType = {
  2886.     LINES: 'lines',
  2887.     WORDS: 'words',
  2888.     NONE: 'none',
  2889. };
  2890. var DiffStyleType = {
  2891.     WORD: 'word',
  2892.     CHAR: 'char',
  2893. };
  2894. //# sourceMappingURL=types.js.map
  2895. // CONCATENATED MODULE: ./node_modules/diff2html/lib-esm/utils.js
  2896. var specials = [
  2897.     '-',
  2898.     '[',
  2899.     ']',
  2900.     '/',
  2901.     '{',
  2902.     '}',
  2903.     '(',
  2904.     ')',
  2905.     '*',
  2906.     '+',
  2907.     '?',
  2908.     '.',
  2909.     '\\',
  2910.     '^',
  2911.     '$',
  2912.     '|',
  2913. ];
  2914. var regex = RegExp('[' + specials.join('\\') + ']', 'g');
  2915. function escapeForRegExp(str) {
  2916.     return str.replace(regex, '\\$&');
  2917. }
  2918. function unifyPath(path) {
  2919.     return path ? path.replace(/\\/g, '/') : path;
  2920. }
  2921. function hashCode(text) {
  2922.     var i, chr, len;
  2923.     var hash = 0;
  2924.     for (i = 0, len = text.length; i < len; i++) {
  2925.         chr = text.charCodeAt(i);
  2926.         hash = (hash << 5) - hash + chr;
  2927.         hash |= 0;
  2928.     }
  2929.     return hash;
  2930. }
  2931. //# sourceMappingURL=utils.js.map
  2932. // CONCATENATED MODULE: ./node_modules/diff2html/lib-esm/diff-parser.js
  2933. var __spreadArrays = (undefined && undefined.__spreadArrays) || function () {
  2934.     for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
  2935.     for (var r = Array(s), k = 0, i = 0; i < il; i++)
  2936.         for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
  2937.             r[k] = a[j];
  2938.     return r;
  2939. };
  2940.  
  2941.  
  2942. function getExtension(filename, language) {
  2943.     var filenameParts = filename.split('.');
  2944.     return filenameParts.length > 1 ? filenameParts[filenameParts.length - 1] : language;
  2945. }
  2946. function startsWithAny(str, prefixes) {
  2947.     return prefixes.reduce(function (startsWith, prefix) { return startsWith || str.startsWith(prefix); }, false);
  2948. }
  2949. var baseDiffFilenamePrefixes = ['a/', 'b/', 'i/', 'w/', 'c/', 'o/'];
  2950. function getFilename(line, linePrefix, extraPrefix) {
  2951.     var prefixes = extraPrefix !== undefined ? __spreadArrays(baseDiffFilenamePrefixes, [extraPrefix]) : baseDiffFilenamePrefixes;
  2952.     var FilenameRegExp = linePrefix
  2953.         ? new RegExp("^" + escapeForRegExp(linePrefix) + " \"?(.+?)\"?$")
  2954.         : new RegExp('^"?(.+?)"?$');
  2955.     var _a = FilenameRegExp.exec(line) || [], _b = _a[1], filename = _b === void 0 ? '' : _b;
  2956.     var matchingPrefix = prefixes.find(function (p) { return filename.indexOf(p) === 0; });
  2957.     var fnameWithoutPrefix = matchingPrefix ? filename.slice(matchingPrefix.length) : filename;
  2958.     return fnameWithoutPrefix.replace(/\s+\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d+)? [+-]\d{4}.*$/, '');
  2959. }
  2960. function getSrcFilename(line, srcPrefix) {
  2961.     return getFilename(line, '---', srcPrefix);
  2962. }
  2963. function getDstFilename(line, dstPrefix) {
  2964.     return getFilename(line, '+++', dstPrefix);
  2965. }
  2966. function parse(diffInput, config) {
  2967.     if (config === void 0) { config = {}; }
  2968.     var files = [];
  2969.     var currentFile = null;
  2970.     var currentBlock = null;
  2971.     var oldLine = null;
  2972.     var oldLine2 = null;
  2973.     var newLine = null;
  2974.     var possibleOldName = null;
  2975.     var possibleNewName = null;
  2976.     var oldFileNameHeader = '--- ';
  2977.     var newFileNameHeader = '+++ ';
  2978.     var hunkHeaderPrefix = '@@';
  2979.     var oldMode = /^old mode (\d{6})/;
  2980.     var newMode = /^new mode (\d{6})/;
  2981.     var deletedFileMode = /^deleted file mode (\d{6})/;
  2982.     var newFileMode = /^new file mode (\d{6})/;
  2983.     var copyFrom = /^copy from "?(.+)"?/;
  2984.     var copyTo = /^copy to "?(.+)"?/;
  2985.     var renameFrom = /^rename from "?(.+)"?/;
  2986.     var renameTo = /^rename to "?(.+)"?/;
  2987.     var similarityIndex = /^similarity index (\d+)%/;
  2988.     var dissimilarityIndex = /^dissimilarity index (\d+)%/;
  2989.     var index = /^index ([\da-z]+)\.\.([\da-z]+)\s*(\d{6})?/;
  2990.     var binaryFiles = /^Binary files (.*) and (.*) differ/;
  2991.     var binaryDiff = /^GIT binary patch/;
  2992.     var combinedIndex = /^index ([\da-z]+),([\da-z]+)\.\.([\da-z]+)/;
  2993.     var combinedMode = /^mode (\d{6}),(\d{6})\.\.(\d{6})/;
  2994.     var combinedNewFile = /^new file mode (\d{6})/;
  2995.     var combinedDeletedFile = /^deleted file mode (\d{6}),(\d{6})/;
  2996.     var diffLines = diffInput
  2997.         .replace(/\\ No newline at end of file/g, '')
  2998.         .replace(/\r\n?/g, '\n')
  2999.         .split('\n');
  3000.     function saveBlock() {
  3001.         if (currentBlock !== null && currentFile !== null) {
  3002.             currentFile.blocks.push(currentBlock);
  3003.             currentBlock = null;
  3004.         }
  3005.     }
  3006.     function saveFile() {
  3007.         if (currentFile !== null) {
  3008.             if (!currentFile.oldName && possibleOldName !== null) {
  3009.                 currentFile.oldName = possibleOldName;
  3010.             }
  3011.             if (!currentFile.newName && possibleNewName !== null) {
  3012.                 currentFile.newName = possibleNewName;
  3013.             }
  3014.             if (currentFile.newName) {
  3015.                 files.push(currentFile);
  3016.                 currentFile = null;
  3017.             }
  3018.         }
  3019.         possibleOldName = null;
  3020.         possibleNewName = null;
  3021.     }
  3022.     function startFile() {
  3023.         saveBlock();
  3024.         saveFile();
  3025.         currentFile = {
  3026.             blocks: [],
  3027.             deletedLines: 0,
  3028.             addedLines: 0,
  3029.         };
  3030.     }
  3031.     function startBlock(line) {
  3032.         saveBlock();
  3033.         var values;
  3034.         if (currentFile !== null) {
  3035.             if ((values = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@.*/.exec(line))) {
  3036.                 currentFile.isCombined = false;
  3037.                 oldLine = parseInt(values[1], 10);
  3038.                 newLine = parseInt(values[2], 10);
  3039.             }
  3040.             else if ((values = /^@@@ -(\d+)(?:,\d+)? -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@@.*/.exec(line))) {
  3041.                 currentFile.isCombined = true;
  3042.                 oldLine = parseInt(values[1], 10);
  3043.                 oldLine2 = parseInt(values[2], 10);
  3044.                 newLine = parseInt(values[3], 10);
  3045.             }
  3046.             else {
  3047.                 if (line.startsWith(hunkHeaderPrefix)) {
  3048.                     console.error('Failed to parse lines, starting in 0!');
  3049.                 }
  3050.                 oldLine = 0;
  3051.                 newLine = 0;
  3052.                 currentFile.isCombined = false;
  3053.             }
  3054.         }
  3055.         currentBlock = {
  3056.             lines: [],
  3057.             oldStartLine: oldLine,
  3058.             oldStartLine2: oldLine2,
  3059.             newStartLine: newLine,
  3060.             header: line,
  3061.         };
  3062.     }
  3063.     function createLine(line) {
  3064.         if (currentFile === null || currentBlock === null || oldLine === null || newLine === null)
  3065.             return;
  3066.         var currentLine = {
  3067.             content: line,
  3068.         };
  3069.         var addedPrefixes = currentFile.isCombined ? ['+ ', ' +', '++'] : ['+'];
  3070.         var deletedPrefixes = currentFile.isCombined ? ['- ', ' -', '--'] : ['-'];
  3071.         if (startsWithAny(line, addedPrefixes)) {
  3072.             currentFile.addedLines++;
  3073.             currentLine.type = LineType.INSERT;
  3074.             currentLine.oldNumber = undefined;
  3075.             currentLine.newNumber = newLine++;
  3076.         }
  3077.         else if (startsWithAny(line, deletedPrefixes)) {
  3078.             currentFile.deletedLines++;
  3079.             currentLine.type = LineType.DELETE;
  3080.             currentLine.oldNumber = oldLine++;
  3081.             currentLine.newNumber = undefined;
  3082.         }
  3083.         else {
  3084.             currentLine.type = LineType.CONTEXT;
  3085.             currentLine.oldNumber = oldLine++;
  3086.             currentLine.newNumber = newLine++;
  3087.         }
  3088.         currentBlock.lines.push(currentLine);
  3089.     }
  3090.     function existHunkHeader(line, lineIdx) {
  3091.         var idx = lineIdx;
  3092.         while (idx < diffLines.length - 3) {
  3093.             if (line.startsWith('diff')) {
  3094.                 return false;
  3095.             }
  3096.             if (diffLines[idx].startsWith(oldFileNameHeader) &&
  3097.                 diffLines[idx + 1].startsWith(newFileNameHeader) &&
  3098.                 diffLines[idx + 2].startsWith(hunkHeaderPrefix)) {
  3099.                 return true;
  3100.             }
  3101.             idx++;
  3102.         }
  3103.         return false;
  3104.     }
  3105.     diffLines.forEach(function (line, lineIndex) {
  3106.         if (!line || line.startsWith('*')) {
  3107.             return;
  3108.         }
  3109.         var values;
  3110.         var prevLine = diffLines[lineIndex - 1];
  3111.         var nxtLine = diffLines[lineIndex + 1];
  3112.         var afterNxtLine = diffLines[lineIndex + 2];
  3113.         if (line.startsWith('diff')) {
  3114.             startFile();
  3115.             var gitDiffStart = /^diff --git "?(.+)"? "?(.+)"?/;
  3116.             if ((values = gitDiffStart.exec(line))) {
  3117.                 possibleOldName = getFilename(values[1], undefined, config.dstPrefix);
  3118.                 possibleNewName = getFilename(values[2], undefined, config.srcPrefix);
  3119.             }
  3120.             if (currentFile === null) {
  3121.                 throw new Error('Where is my file !!!');
  3122.             }
  3123.             currentFile.isGitDiff = true;
  3124.             return;
  3125.         }
  3126.         if (!currentFile ||
  3127.             (!currentFile.isGitDiff &&
  3128.                 currentFile &&
  3129.                 line.startsWith(oldFileNameHeader) &&
  3130.                 nxtLine.startsWith(newFileNameHeader) &&
  3131.                 afterNxtLine.startsWith(hunkHeaderPrefix))) {
  3132.             startFile();
  3133.         }
  3134.         if ((line.startsWith(oldFileNameHeader) && nxtLine.startsWith(newFileNameHeader)) ||
  3135.             (line.startsWith(newFileNameHeader) && prevLine.startsWith(oldFileNameHeader))) {
  3136.             if (currentFile &&
  3137.                 !currentFile.oldName &&
  3138.                 line.startsWith('--- ') &&
  3139.                 (values = getSrcFilename(line, config.srcPrefix))) {
  3140.                 currentFile.oldName = values;
  3141.                 currentFile.language = getExtension(currentFile.oldName, currentFile.language);
  3142.                 return;
  3143.             }
  3144.             if (currentFile &&
  3145.                 !currentFile.newName &&
  3146.                 line.startsWith('+++ ') &&
  3147.                 (values = getDstFilename(line, config.dstPrefix))) {
  3148.                 currentFile.newName = values;
  3149.                 currentFile.language = getExtension(currentFile.newName, currentFile.language);
  3150.                 return;
  3151.             }
  3152.         }
  3153.         if (currentFile &&
  3154.             (line.startsWith(hunkHeaderPrefix) ||
  3155.                 (currentFile.isGitDiff && currentFile.oldName && currentFile.newName && !currentBlock))) {
  3156.             startBlock(line);
  3157.             return;
  3158.         }
  3159.         if (currentBlock && (line.startsWith('+') || line.startsWith('-') || line.startsWith(' '))) {
  3160.             createLine(line);
  3161.             return;
  3162.         }
  3163.         var doesNotExistHunkHeader = !existHunkHeader(line, lineIndex);
  3164.         if (currentFile === null) {
  3165.             throw new Error('Where is my file !!!');
  3166.         }
  3167.         if ((values = oldMode.exec(line))) {
  3168.             currentFile.oldMode = values[1];
  3169.         }
  3170.         else if ((values = newMode.exec(line))) {
  3171.             currentFile.newMode = values[1];
  3172.         }
  3173.         else if ((values = deletedFileMode.exec(line))) {
  3174.             currentFile.deletedFileMode = values[1];
  3175.             currentFile.isDeleted = true;
  3176.         }
  3177.         else if ((values = newFileMode.exec(line))) {
  3178.             currentFile.newFileMode = values[1];
  3179.             currentFile.isNew = true;
  3180.         }
  3181.         else if ((values = copyFrom.exec(line))) {
  3182.             if (doesNotExistHunkHeader) {
  3183.                 currentFile.oldName = values[1];
  3184.             }
  3185.             currentFile.isCopy = true;
  3186.         }
  3187.         else if ((values = copyTo.exec(line))) {
  3188.             if (doesNotExistHunkHeader) {
  3189.                 currentFile.newName = values[1];
  3190.             }
  3191.             currentFile.isCopy = true;
  3192.         }
  3193.         else if ((values = renameFrom.exec(line))) {
  3194.             if (doesNotExistHunkHeader) {
  3195.                 currentFile.oldName = values[1];
  3196.             }
  3197.             currentFile.isRename = true;
  3198.         }
  3199.         else if ((values = renameTo.exec(line))) {
  3200.             if (doesNotExistHunkHeader) {
  3201.                 currentFile.newName = values[1];
  3202.             }
  3203.             currentFile.isRename = true;
  3204.         }
  3205.         else if ((values = binaryFiles.exec(line))) {
  3206.             currentFile.isBinary = true;
  3207.             currentFile.oldName = getFilename(values[1], undefined, config.srcPrefix);
  3208.             currentFile.newName = getFilename(values[2], undefined, config.dstPrefix);
  3209.             startBlock('Binary file');
  3210.         }
  3211.         else if (binaryDiff.test(line)) {
  3212.             currentFile.isBinary = true;
  3213.             startBlock(line);
  3214.         }
  3215.         else if ((values = similarityIndex.exec(line))) {
  3216.             currentFile.unchangedPercentage = parseInt(values[1], 10);
  3217.         }
  3218.         else if ((values = dissimilarityIndex.exec(line))) {
  3219.             currentFile.changedPercentage = parseInt(values[1], 10);
  3220.         }
  3221.         else if ((values = index.exec(line))) {
  3222.             currentFile.checksumBefore = values[1];
  3223.             currentFile.checksumAfter = values[2];
  3224.             values[3] && (currentFile.mode = values[3]);
  3225.         }
  3226.         else if ((values = combinedIndex.exec(line))) {
  3227.             currentFile.checksumBefore = [values[2], values[3]];
  3228.             currentFile.checksumAfter = values[1];
  3229.         }
  3230.         else if ((values = combinedMode.exec(line))) {
  3231.             currentFile.oldMode = [values[2], values[3]];
  3232.             currentFile.newMode = values[1];
  3233.         }
  3234.         else if ((values = combinedNewFile.exec(line))) {
  3235.             currentFile.newFileMode = values[1];
  3236.             currentFile.isNew = true;
  3237.         }
  3238.         else if ((values = combinedDeletedFile.exec(line))) {
  3239.             currentFile.deletedFileMode = values[1];
  3240.             currentFile.isDeleted = true;
  3241.         }
  3242.     });
  3243.     saveBlock();
  3244.     saveFile();
  3245.     return files;
  3246. }
  3247. //# sourceMappingURL=diff-parser.js.map
  3248. // EXTERNAL MODULE: ./node_modules/diff/dist/diff.js
  3249. var dist_diff = __webpack_require__("v2jn");
  3250.  
  3251. // CONCATENATED MODULE: ./node_modules/diff2html/lib-esm/rematch.js
  3252. function levenshtein(a, b) {
  3253.     if (a.length === 0) {
  3254.         return b.length;
  3255.     }
  3256.     if (b.length === 0) {
  3257.         return a.length;
  3258.     }
  3259.     var matrix = [];
  3260.     var i;
  3261.     for (i = 0; i <= b.length; i++) {
  3262.         matrix[i] = [i];
  3263.     }
  3264.     var j;
  3265.     for (j = 0; j <= a.length; j++) {
  3266.         matrix[0][j] = j;
  3267.     }
  3268.     for (i = 1; i <= b.length; i++) {
  3269.         for (j = 1; j <= a.length; j++) {
  3270.             if (b.charAt(i - 1) === a.charAt(j - 1)) {
  3271.                 matrix[i][j] = matrix[i - 1][j - 1];
  3272.             }
  3273.             else {
  3274.                 matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, Math.min(matrix[i][j - 1] + 1, matrix[i - 1][j] + 1));
  3275.             }
  3276.         }
  3277.     }
  3278.     return matrix[b.length][a.length];
  3279. }
  3280. function newDistanceFn(str) {
  3281.     return function (x, y) {
  3282.         var xValue = str(x).trim();
  3283.         var yValue = str(y).trim();
  3284.         var lev = levenshtein(xValue, yValue);
  3285.         return lev / (xValue.length + yValue.length);
  3286.     };
  3287. }
  3288. function newMatcherFn(distance) {
  3289.     function findBestMatch(a, b, cache) {
  3290.         if (cache === void 0) { cache = new Map(); }
  3291.         var bestMatchDist = Infinity;
  3292.         var bestMatch;
  3293.         for (var i = 0; i < a.length; ++i) {
  3294.             for (var j = 0; j < b.length; ++j) {
  3295.                 var cacheKey = JSON.stringify([a[i], b[j]]);
  3296.                 var md = void 0;
  3297.                 if (!(cache.has(cacheKey) && (md = cache.get(cacheKey)))) {
  3298.                     md = distance(a[i], b[j]);
  3299.                     cache.set(cacheKey, md);
  3300.                 }
  3301.                 if (md < bestMatchDist) {
  3302.                     bestMatchDist = md;
  3303.                     bestMatch = { indexA: i, indexB: j, score: bestMatchDist };
  3304.                 }
  3305.             }
  3306.         }
  3307.         return bestMatch;
  3308.     }
  3309.     function group(a, b, level, cache) {
  3310.         if (level === void 0) { level = 0; }
  3311.         if (cache === void 0) { cache = new Map(); }
  3312.         var bm = findBestMatch(a, b, cache);
  3313.         if (!bm || a.length + b.length < 3) {
  3314.             return [[a, b]];
  3315.         }
  3316.         var a1 = a.slice(0, bm.indexA);
  3317.         var b1 = b.slice(0, bm.indexB);
  3318.         var aMatch = [a[bm.indexA]];
  3319.         var bMatch = [b[bm.indexB]];
  3320.         var tailA = bm.indexA + 1;
  3321.         var tailB = bm.indexB + 1;
  3322.         var a2 = a.slice(tailA);
  3323.         var b2 = b.slice(tailB);
  3324.         var group1 = group(a1, b1, level + 1, cache);
  3325.         var groupMatch = group(aMatch, bMatch, level + 1, cache);
  3326.         var group2 = group(a2, b2, level + 1, cache);
  3327.         var result = groupMatch;
  3328.         if (bm.indexA > 0 || bm.indexB > 0) {
  3329.             result = group1.concat(result);
  3330.         }
  3331.         if (a.length > tailA || b.length > tailB) {
  3332.             result = result.concat(group2);
  3333.         }
  3334.         return result;
  3335.     }
  3336.     return group;
  3337. }
  3338. //# sourceMappingURL=rematch.js.map
  3339. // CONCATENATED MODULE: ./node_modules/diff2html/lib-esm/render-utils.js
  3340. var __assign = (undefined && undefined.__assign) || function () {
  3341.     __assign = Object.assign || function(t) {
  3342.         for (var s, i = 1, n = arguments.length; i < n; i++) {
  3343.             s = arguments[i];
  3344.             for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
  3345.                 t[p] = s[p];
  3346.         }
  3347.         return t;
  3348.     };
  3349.     return __assign.apply(this, arguments);
  3350. };
  3351.  
  3352.  
  3353.  
  3354.  
  3355. var CSSLineClass = {
  3356.     INSERTS: 'd2h-ins',
  3357.     DELETES: 'd2h-del',
  3358.     CONTEXT: 'd2h-cntx',
  3359.     INFO: 'd2h-info',
  3360.     INSERT_CHANGES: 'd2h-ins d2h-change',
  3361.     DELETE_CHANGES: 'd2h-del d2h-change',
  3362. };
  3363. var defaultRenderConfig = {
  3364.     matching: LineMatchingType.NONE,
  3365.     matchWordsThreshold: 0.25,
  3366.     maxLineLengthHighlight: 10000,
  3367.     diffStyle: DiffStyleType.WORD,
  3368. };
  3369. var separator = '/';
  3370. var distance = newDistanceFn(function (change) { return change.value; });
  3371. var render_utils_matcher = newMatcherFn(distance);
  3372. function isDevNullName(name) {
  3373.     return name.indexOf('dev/null') !== -1;
  3374. }
  3375. function removeInsElements(line) {
  3376.     return line.replace(/(<ins[^>]*>((.|\n)*?)<\/ins>)/g, '');
  3377. }
  3378. function removeDelElements(line) {
  3379.     return line.replace(/(<del[^>]*>((.|\n)*?)<\/del>)/g, '');
  3380. }
  3381. function toCSSClass(lineType) {
  3382.     switch (lineType) {
  3383.         case LineType.CONTEXT:
  3384.             return CSSLineClass.CONTEXT;
  3385.         case LineType.INSERT:
  3386.             return CSSLineClass.INSERTS;
  3387.         case LineType.DELETE:
  3388.             return CSSLineClass.DELETES;
  3389.     }
  3390. }
  3391. function prefixLength(isCombined) {
  3392.     return isCombined ? 2 : 1;
  3393. }
  3394. function escapeForHtml(str) {
  3395.     return str
  3396.         .slice(0)
  3397.         .replace(/&/g, '&amp;')
  3398.         .replace(/</g, '&lt;')
  3399.         .replace(/>/g, '&gt;')
  3400.         .replace(/"/g, '&quot;')
  3401.         .replace(/'/g, '&#x27;')
  3402.         .replace(/\//g, '&#x2F;');
  3403. }
  3404. function deconstructLine(line, isCombined, escape) {
  3405.     if (escape === void 0) { escape = true; }
  3406.     var indexToSplit = prefixLength(isCombined);
  3407.     return {
  3408.         prefix: line.substring(0, indexToSplit),
  3409.         content: escape ? escapeForHtml(line.substring(indexToSplit)) : line.substring(indexToSplit),
  3410.     };
  3411. }
  3412. function filenameDiff(file) {
  3413.     var oldFilename = unifyPath(file.oldName);
  3414.     var newFilename = unifyPath(file.newName);
  3415.     if (oldFilename !== newFilename && !isDevNullName(oldFilename) && !isDevNullName(newFilename)) {
  3416.         var prefixPaths = [];
  3417.         var suffixPaths = [];
  3418.         var oldFilenameParts = oldFilename.split(separator);
  3419.         var newFilenameParts = newFilename.split(separator);
  3420.         var oldFilenamePartsSize = oldFilenameParts.length;
  3421.         var newFilenamePartsSize = newFilenameParts.length;
  3422.         var i = 0;
  3423.         var j = oldFilenamePartsSize - 1;
  3424.         var k = newFilenamePartsSize - 1;
  3425.         while (i < j && i < k) {
  3426.             if (oldFilenameParts[i] === newFilenameParts[i]) {
  3427.                 prefixPaths.push(newFilenameParts[i]);
  3428.                 i += 1;
  3429.             }
  3430.             else {
  3431.                 break;
  3432.             }
  3433.         }
  3434.         while (j > i && k > i) {
  3435.             if (oldFilenameParts[j] === newFilenameParts[k]) {
  3436.                 suffixPaths.unshift(newFilenameParts[k]);
  3437.                 j -= 1;
  3438.                 k -= 1;
  3439.             }
  3440.             else {
  3441.                 break;
  3442.             }
  3443.         }
  3444.         var finalPrefix = prefixPaths.join(separator);
  3445.         var finalSuffix = suffixPaths.join(separator);
  3446.         var oldRemainingPath = oldFilenameParts.slice(i, j + 1).join(separator);
  3447.         var newRemainingPath = newFilenameParts.slice(i, k + 1).join(separator);
  3448.         if (finalPrefix.length && finalSuffix.length) {
  3449.             return (finalPrefix + separator + '{' + oldRemainingPath + ' → ' + newRemainingPath + '}' + separator + finalSuffix);
  3450.         }
  3451.         else if (finalPrefix.length) {
  3452.             return finalPrefix + separator + '{' + oldRemainingPath + ' → ' + newRemainingPath + '}';
  3453.         }
  3454.         else if (finalSuffix.length) {
  3455.             return '{' + oldRemainingPath + ' → ' + newRemainingPath + '}' + separator + finalSuffix;
  3456.         }
  3457.         return oldFilename + ' → ' + newFilename;
  3458.     }
  3459.     else if (!isDevNullName(newFilename)) {
  3460.         return newFilename;
  3461.     }
  3462.     else {
  3463.         return oldFilename;
  3464.     }
  3465. }
  3466. function getHtmlId(file) {
  3467.     return "d2h-" + hashCode(filenameDiff(file))
  3468.         .toString()
  3469.         .slice(-6);
  3470. }
  3471. function getFileIcon(file) {
  3472.     var templateName = 'file-changed';
  3473.     if (file.isRename) {
  3474.         templateName = 'file-renamed';
  3475.     }
  3476.     else if (file.isCopy) {
  3477.         templateName = 'file-renamed';
  3478.     }
  3479.     else if (file.isNew) {
  3480.         templateName = 'file-added';
  3481.     }
  3482.     else if (file.isDeleted) {
  3483.         templateName = 'file-deleted';
  3484.     }
  3485.     else if (file.newName !== file.oldName) {
  3486.         templateName = 'file-renamed';
  3487.     }
  3488.     return templateName;
  3489. }
  3490. function diffHighlight(diffLine1, diffLine2, isCombined, config) {
  3491.     if (config === void 0) { config = {}; }
  3492.     var _a = __assign(__assign({}, defaultRenderConfig), config), matching = _a.matching, maxLineLengthHighlight = _a.maxLineLengthHighlight, matchWordsThreshold = _a.matchWordsThreshold, diffStyle = _a.diffStyle;
  3493.     var line1 = deconstructLine(diffLine1, isCombined, false);
  3494.     var line2 = deconstructLine(diffLine2, isCombined, false);
  3495.     if (line1.content.length > maxLineLengthHighlight || line2.content.length > maxLineLengthHighlight) {
  3496.         return {
  3497.             oldLine: {
  3498.                 prefix: line1.prefix,
  3499.                 content: line1.content,
  3500.             },
  3501.             newLine: {
  3502.                 prefix: line2.prefix,
  3503.                 content: line2.content,
  3504.             },
  3505.         };
  3506.     }
  3507.     var diff = diffStyle === 'char'
  3508.         ? dist_diff["diffChars"](line1.content, line2.content)
  3509.         : dist_diff["diffWordsWithSpace"](line1.content, line2.content);
  3510.     var changedWords = [];
  3511.     if (diffStyle === 'word' && matching === 'words') {
  3512.         var removed = diff.filter(function (element) { return element.removed; });
  3513.         var added = diff.filter(function (element) { return element.added; });
  3514.         var chunks = render_utils_matcher(added, removed);
  3515.         chunks.forEach(function (chunk) {
  3516.             if (chunk[0].length === 1 && chunk[1].length === 1) {
  3517.                 var dist = distance(chunk[0][0], chunk[1][0]);
  3518.                 if (dist < matchWordsThreshold) {
  3519.                     changedWords.push(chunk[0][0]);
  3520.                     changedWords.push(chunk[1][0]);
  3521.                 }
  3522.             }
  3523.         });
  3524.     }
  3525.     var highlightedLine = diff.reduce(function (highlightedLine, part) {
  3526.         var elemType = part.added ? 'ins' : part.removed ? 'del' : null;
  3527.         var addClass = changedWords.indexOf(part) > -1 ? ' class="d2h-change"' : '';
  3528.         var escapedValue = escapeForHtml(part.value);
  3529.         return elemType !== null
  3530.             ? highlightedLine + "<" + elemType + addClass + ">" + escapedValue + "</" + elemType + ">"
  3531.             : "" + highlightedLine + escapedValue;
  3532.     }, '');
  3533.     return {
  3534.         oldLine: {
  3535.             prefix: line1.prefix,
  3536.             content: removeInsElements(highlightedLine),
  3537.         },
  3538.         newLine: {
  3539.             prefix: line2.prefix,
  3540.             content: removeDelElements(highlightedLine),
  3541.         },
  3542.     };
  3543. }
  3544. //# sourceMappingURL=render-utils.js.map
  3545. // CONCATENATED MODULE: ./node_modules/diff2html/lib-esm/file-list-renderer.js
  3546.  
  3547. var baseTemplatesPath = 'file-summary';
  3548. var iconsBaseTemplatesPath = 'icon';
  3549. function render(diffFiles, hoganUtils) {
  3550.     var files = diffFiles
  3551.         .map(function (file) {
  3552.         return hoganUtils.render(baseTemplatesPath, 'line', {
  3553.             fileHtmlId: getHtmlId(file),
  3554.             oldName: file.oldName,
  3555.             newName: file.newName,
  3556.             fileName: filenameDiff(file),
  3557.             deletedLines: '-' + file.deletedLines,
  3558.             addedLines: '+' + file.addedLines,
  3559.         }, {
  3560.             fileIcon: hoganUtils.template(iconsBaseTemplatesPath, getFileIcon(file)),
  3561.         });
  3562.     })
  3563.         .join('\n');
  3564.     return hoganUtils.render(baseTemplatesPath, 'wrapper', {
  3565.         filesNumber: diffFiles.length,
  3566.         files: files,
  3567.     });
  3568. }
  3569. //# sourceMappingURL=file-list-renderer.js.map
  3570. // CONCATENATED MODULE: ./node_modules/diff2html/lib-esm/line-by-line-renderer.js
  3571. var line_by_line_renderer_assign = (undefined && undefined.__assign) || function () {
  3572.     line_by_line_renderer_assign = Object.assign || function(t) {
  3573.         for (var s, i = 1, n = arguments.length; i < n; i++) {
  3574.             s = arguments[i];
  3575.             for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
  3576.                 t[p] = s[p];
  3577.         }
  3578.         return t;
  3579.     };
  3580.     return line_by_line_renderer_assign.apply(this, arguments);
  3581. };
  3582.  
  3583.  
  3584.  
  3585. var defaultLineByLineRendererConfig = line_by_line_renderer_assign(line_by_line_renderer_assign({}, defaultRenderConfig), { renderNothingWhenEmpty: false, matchingMaxComparisons: 2500, maxLineSizeInBlockForComparison: 200 });
  3586. var genericTemplatesPath = 'generic';
  3587. var line_by_line_renderer_baseTemplatesPath = 'line-by-line';
  3588. var line_by_line_renderer_iconsBaseTemplatesPath = 'icon';
  3589. var tagsBaseTemplatesPath = 'tag';
  3590. var line_by_line_renderer_LineByLineRenderer = (function () {
  3591.     function LineByLineRenderer(hoganUtils, config) {
  3592.         if (config === void 0) { config = {}; }
  3593.         this.hoganUtils = hoganUtils;
  3594.         this.config = line_by_line_renderer_assign(line_by_line_renderer_assign({}, defaultLineByLineRendererConfig), config);
  3595.     }
  3596.     LineByLineRenderer.prototype.render = function (diffFiles) {
  3597.         var _this = this;
  3598.         var diffsHtml = diffFiles
  3599.             .map(function (file) {
  3600.             var diffs;
  3601.             if (file.blocks.length) {
  3602.                 diffs = _this.generateFileHtml(file);
  3603.             }
  3604.             else {
  3605.                 diffs = _this.generateEmptyDiff();
  3606.             }
  3607.             return _this.makeFileDiffHtml(file, diffs);
  3608.         })
  3609.             .join('\n');
  3610.         return this.hoganUtils.render(genericTemplatesPath, 'wrapper', { content: diffsHtml });
  3611.     };
  3612.     LineByLineRenderer.prototype.makeFileDiffHtml = function (file, diffs) {
  3613.         if (this.config.renderNothingWhenEmpty && Array.isArray(file.blocks) && file.blocks.length === 0)
  3614.             return '';
  3615.         var fileDiffTemplate = this.hoganUtils.template(line_by_line_renderer_baseTemplatesPath, 'file-diff');
  3616.         var filePathTemplate = this.hoganUtils.template(genericTemplatesPath, 'file-path');
  3617.         var fileIconTemplate = this.hoganUtils.template(line_by_line_renderer_iconsBaseTemplatesPath, 'file');
  3618.         var fileTagTemplate = this.hoganUtils.template(tagsBaseTemplatesPath, getFileIcon(file));
  3619.         return fileDiffTemplate.render({
  3620.             file: file,
  3621.             fileHtmlId: getHtmlId(file),
  3622.             diffs: diffs,
  3623.             filePath: filePathTemplate.render({
  3624.                 fileDiffName: filenameDiff(file),
  3625.             }, {
  3626.                 fileIcon: fileIconTemplate,
  3627.                 fileTag: fileTagTemplate,
  3628.             }),
  3629.         });
  3630.     };
  3631.     LineByLineRenderer.prototype.generateEmptyDiff = function () {
  3632.         return this.hoganUtils.render(genericTemplatesPath, 'empty-diff', {
  3633.             contentClass: 'd2h-code-line',
  3634.             CSSLineClass: CSSLineClass,
  3635.         });
  3636.     };
  3637.     LineByLineRenderer.prototype.generateFileHtml = function (file) {
  3638.         var _this = this;
  3639.         var matcher = newMatcherFn(newDistanceFn(function (e) { return deconstructLine(e.content, file.isCombined).content; }));
  3640.         return file.blocks
  3641.             .map(function (block) {
  3642.             var lines = _this.hoganUtils.render(genericTemplatesPath, 'block-header', {
  3643.                 CSSLineClass: CSSLineClass,
  3644.                 blockHeader: block.header,
  3645.                 lineClass: 'd2h-code-linenumber',
  3646.                 contentClass: 'd2h-code-line',
  3647.             });
  3648.             _this.applyLineGroupping(block).forEach(function (_a) {
  3649.                 var contextLines = _a[0], oldLines = _a[1], newLines = _a[2];
  3650.                 if (oldLines.length && newLines.length && !contextLines.length) {
  3651.                     _this.applyRematchMatching(oldLines, newLines, matcher).map(function (_a) {
  3652.                         var oldLines = _a[0], newLines = _a[1];
  3653.                         var _b = _this.processChangedLines(file.isCombined, oldLines, newLines), left = _b.left, right = _b.right;
  3654.                         lines += left;
  3655.                         lines += right;
  3656.                     });
  3657.                 }
  3658.                 else if (contextLines.length) {
  3659.                     contextLines.forEach(function (line) {
  3660.                         var _a = deconstructLine(line.content, file.isCombined), prefix = _a.prefix, content = _a.content;
  3661.                         lines += _this.generateSingleLineHtml({
  3662.                             type: CSSLineClass.CONTEXT,
  3663.                             prefix: prefix,
  3664.                             content: content,
  3665.                             oldNumber: line.oldNumber,
  3666.                             newNumber: line.newNumber,
  3667.                         });
  3668.                     });
  3669.                 }
  3670.                 else if (oldLines.length || newLines.length) {
  3671.                     var _b = _this.processChangedLines(file.isCombined, oldLines, newLines), left = _b.left, right = _b.right;
  3672.                     lines += left;
  3673.                     lines += right;
  3674.                 }
  3675.                 else {
  3676.                     console.error('Unknown state reached while processing groups of lines', contextLines, oldLines, newLines);
  3677.                 }
  3678.             });
  3679.             return lines;
  3680.         })
  3681.             .join('\n');
  3682.     };
  3683.     LineByLineRenderer.prototype.applyLineGroupping = function (block) {
  3684.         var blockLinesGroups = [];
  3685.         var oldLines = [];
  3686.         var newLines = [];
  3687.         for (var i = 0; i < block.lines.length; i++) {
  3688.             var diffLine = block.lines[i];
  3689.             if ((diffLine.type !== LineType.INSERT && newLines.length) ||
  3690.                 (diffLine.type === LineType.CONTEXT && oldLines.length > 0)) {
  3691.                 blockLinesGroups.push([[], oldLines, newLines]);
  3692.                 oldLines = [];
  3693.                 newLines = [];
  3694.             }
  3695.             if (diffLine.type === LineType.CONTEXT) {
  3696.                 blockLinesGroups.push([[diffLine], [], []]);
  3697.             }
  3698.             else if (diffLine.type === LineType.INSERT && oldLines.length === 0) {
  3699.                 blockLinesGroups.push([[], [], [diffLine]]);
  3700.             }
  3701.             else if (diffLine.type === LineType.INSERT && oldLines.length > 0) {
  3702.                 newLines.push(diffLine);
  3703.             }
  3704.             else if (diffLine.type === LineType.DELETE) {
  3705.                 oldLines.push(diffLine);
  3706.             }
  3707.         }
  3708.         if (oldLines.length || newLines.length) {
  3709.             blockLinesGroups.push([[], oldLines, newLines]);
  3710.             oldLines = [];
  3711.             newLines = [];
  3712.         }
  3713.         return blockLinesGroups;
  3714.     };
  3715.     LineByLineRenderer.prototype.applyRematchMatching = function (oldLines, newLines, matcher) {
  3716.         var comparisons = oldLines.length * newLines.length;
  3717.         var maxLineSizeInBlock = Math.max.apply(null, [0].concat(oldLines.concat(newLines).map(function (elem) { return elem.content.length; })));
  3718.         var doMatching = comparisons < this.config.matchingMaxComparisons &&
  3719.             maxLineSizeInBlock < this.config.maxLineSizeInBlockForComparison &&
  3720.             (this.config.matching === 'lines' || this.config.matching === 'words');
  3721.         return doMatching ? matcher(oldLines, newLines) : [[oldLines, newLines]];
  3722.     };
  3723.     LineByLineRenderer.prototype.processChangedLines = function (isCombined, oldLines, newLines) {
  3724.         var fileHtml = {
  3725.             right: '',
  3726.             left: '',
  3727.         };
  3728.         var maxLinesNumber = Math.max(oldLines.length, newLines.length);
  3729.         for (var i = 0; i < maxLinesNumber; i++) {
  3730.             var oldLine = oldLines[i];
  3731.             var newLine = newLines[i];
  3732.             var diff = oldLine !== undefined && newLine !== undefined
  3733.                 ? diffHighlight(oldLine.content, newLine.content, isCombined, this.config)
  3734.                 : undefined;
  3735.             var preparedOldLine = oldLine !== undefined && oldLine.oldNumber !== undefined
  3736.                 ? line_by_line_renderer_assign(line_by_line_renderer_assign({}, (diff !== undefined
  3737.                     ? {
  3738.                         prefix: diff.oldLine.prefix,
  3739.                         content: diff.oldLine.content,
  3740.                         type: CSSLineClass.DELETE_CHANGES,
  3741.                     }
  3742.                     : line_by_line_renderer_assign(line_by_line_renderer_assign({}, deconstructLine(oldLine.content, isCombined)), { type: toCSSClass(oldLine.type) }))), { oldNumber: oldLine.oldNumber, newNumber: oldLine.newNumber }) : undefined;
  3743.             var preparedNewLine = newLine !== undefined && newLine.newNumber !== undefined
  3744.                 ? line_by_line_renderer_assign(line_by_line_renderer_assign({}, (diff !== undefined
  3745.                     ? {
  3746.                         prefix: diff.newLine.prefix,
  3747.                         content: diff.newLine.content,
  3748.                         type: CSSLineClass.INSERT_CHANGES,
  3749.                     }
  3750.                     : line_by_line_renderer_assign(line_by_line_renderer_assign({}, deconstructLine(newLine.content, isCombined)), { type: toCSSClass(newLine.type) }))), { oldNumber: newLine.oldNumber, newNumber: newLine.newNumber }) : undefined;
  3751.             var _a = this.generateLineHtml(preparedOldLine, preparedNewLine), left = _a.left, right = _a.right;
  3752.             fileHtml.left += left;
  3753.             fileHtml.right += right;
  3754.         }
  3755.         return fileHtml;
  3756.     };
  3757.     LineByLineRenderer.prototype.generateLineHtml = function (oldLine, newLine) {
  3758.         return {
  3759.             left: this.generateSingleLineHtml(oldLine),
  3760.             right: this.generateSingleLineHtml(newLine),
  3761.         };
  3762.     };
  3763.     LineByLineRenderer.prototype.generateSingleLineHtml = function (line) {
  3764.         if (line === undefined)
  3765.             return '';
  3766.         var lineNumberHtml = this.hoganUtils.render(line_by_line_renderer_baseTemplatesPath, 'numbers', {
  3767.             oldNumber: line.oldNumber || '',
  3768.             newNumber: line.newNumber || '',
  3769.         });
  3770.         return this.hoganUtils.render(genericTemplatesPath, 'line', {
  3771.             type: line.type,
  3772.             lineClass: 'd2h-code-linenumber',
  3773.             contentClass: 'd2h-code-line',
  3774.             prefix: line.prefix === ' ' ? '&nbsp;' : line.prefix,
  3775.             content: line.content,
  3776.             lineNumber: lineNumberHtml,
  3777.         });
  3778.     };
  3779.     return LineByLineRenderer;
  3780. }());
  3781. /* harmony default export */ var line_by_line_renderer = (line_by_line_renderer_LineByLineRenderer);
  3782. //# sourceMappingURL=line-by-line-renderer.js.map
  3783. // CONCATENATED MODULE: ./node_modules/diff2html/lib-esm/side-by-side-renderer.js
  3784. var side_by_side_renderer_assign = (undefined && undefined.__assign) || function () {
  3785.     side_by_side_renderer_assign = Object.assign || function(t) {
  3786.         for (var s, i = 1, n = arguments.length; i < n; i++) {
  3787.             s = arguments[i];
  3788.             for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
  3789.                 t[p] = s[p];
  3790.         }
  3791.         return t;
  3792.     };
  3793.     return side_by_side_renderer_assign.apply(this, arguments);
  3794. };
  3795.  
  3796.  
  3797.  
  3798. var defaultSideBySideRendererConfig = side_by_side_renderer_assign(side_by_side_renderer_assign({}, defaultRenderConfig), { renderNothingWhenEmpty: false, matchingMaxComparisons: 2500, maxLineSizeInBlockForComparison: 200 });
  3799. var side_by_side_renderer_genericTemplatesPath = 'generic';
  3800. var side_by_side_renderer_baseTemplatesPath = 'side-by-side';
  3801. var side_by_side_renderer_iconsBaseTemplatesPath = 'icon';
  3802. var side_by_side_renderer_tagsBaseTemplatesPath = 'tag';
  3803. var side_by_side_renderer_SideBySideRenderer = (function () {
  3804.     function SideBySideRenderer(hoganUtils, config) {
  3805.         if (config === void 0) { config = {}; }
  3806.         this.hoganUtils = hoganUtils;
  3807.         this.config = side_by_side_renderer_assign(side_by_side_renderer_assign({}, defaultSideBySideRendererConfig), config);
  3808.     }
  3809.     SideBySideRenderer.prototype.render = function (diffFiles) {
  3810.         var _this = this;
  3811.         var diffsHtml = diffFiles
  3812.             .map(function (file) {
  3813.             var diffs;
  3814.             if (file.blocks.length) {
  3815.                 diffs = _this.generateFileHtml(file);
  3816.             }
  3817.             else {
  3818.                 diffs = _this.generateEmptyDiff();
  3819.             }
  3820.             return _this.makeFileDiffHtml(file, diffs);
  3821.         })
  3822.             .join('\n');
  3823.         return this.hoganUtils.render(side_by_side_renderer_genericTemplatesPath, 'wrapper', { content: diffsHtml });
  3824.     };
  3825.     SideBySideRenderer.prototype.makeFileDiffHtml = function (file, diffs) {
  3826.         if (this.config.renderNothingWhenEmpty && Array.isArray(file.blocks) && file.blocks.length === 0)
  3827.             return '';
  3828.         var fileDiffTemplate = this.hoganUtils.template(side_by_side_renderer_baseTemplatesPath, 'file-diff');
  3829.         var filePathTemplate = this.hoganUtils.template(side_by_side_renderer_genericTemplatesPath, 'file-path');
  3830.         var fileIconTemplate = this.hoganUtils.template(side_by_side_renderer_iconsBaseTemplatesPath, 'file');
  3831.         var fileTagTemplate = this.hoganUtils.template(side_by_side_renderer_tagsBaseTemplatesPath, getFileIcon(file));
  3832.         return fileDiffTemplate.render({
  3833.             file: file,
  3834.             fileHtmlId: getHtmlId(file),
  3835.             diffs: diffs,
  3836.             filePath: filePathTemplate.render({
  3837.                 fileDiffName: filenameDiff(file),
  3838.             }, {
  3839.                 fileIcon: fileIconTemplate,
  3840.                 fileTag: fileTagTemplate,
  3841.             }),
  3842.         });
  3843.     };
  3844.     SideBySideRenderer.prototype.generateEmptyDiff = function () {
  3845.         return {
  3846.             right: '',
  3847.             left: this.hoganUtils.render(side_by_side_renderer_genericTemplatesPath, 'empty-diff', {
  3848.                 contentClass: 'd2h-code-side-line',
  3849.                 CSSLineClass: CSSLineClass,
  3850.             }),
  3851.         };
  3852.     };
  3853.     SideBySideRenderer.prototype.generateFileHtml = function (file) {
  3854.         var _this = this;
  3855.         var matcher = newMatcherFn(newDistanceFn(function (e) { return deconstructLine(e.content, file.isCombined).content; }));
  3856.         return file.blocks
  3857.             .map(function (block) {
  3858.             var fileHtml = {
  3859.                 left: _this.makeHeaderHtml(block.header),
  3860.                 right: _this.makeHeaderHtml(''),
  3861.             };
  3862.             _this.applyLineGroupping(block).forEach(function (_a) {
  3863.                 var contextLines = _a[0], oldLines = _a[1], newLines = _a[2];
  3864.                 if (oldLines.length && newLines.length && !contextLines.length) {
  3865.                     _this.applyRematchMatching(oldLines, newLines, matcher).map(function (_a) {
  3866.                         var oldLines = _a[0], newLines = _a[1];
  3867.                         var _b = _this.processChangedLines(file.isCombined, oldLines, newLines), left = _b.left, right = _b.right;
  3868.                         fileHtml.left += left;
  3869.                         fileHtml.right += right;
  3870.                     });
  3871.                 }
  3872.                 else if (contextLines.length) {
  3873.                     contextLines.forEach(function (line) {
  3874.                         var _a = deconstructLine(line.content, file.isCombined), prefix = _a.prefix, content = _a.content;
  3875.                         var _b = _this.generateLineHtml({
  3876.                             type: CSSLineClass.CONTEXT,
  3877.                             prefix: prefix,
  3878.                             content: content,
  3879.                             number: line.oldNumber,
  3880.                         }, {
  3881.                             type: CSSLineClass.CONTEXT,
  3882.                             prefix: prefix,
  3883.                             content: content,
  3884.                             number: line.newNumber,
  3885.                         }), left = _b.left, right = _b.right;
  3886.                         fileHtml.left += left;
  3887.                         fileHtml.right += right;
  3888.                     });
  3889.                 }
  3890.                 else if (oldLines.length || newLines.length) {
  3891.                     var _b = _this.processChangedLines(file.isCombined, oldLines, newLines), left = _b.left, right = _b.right;
  3892.                     fileHtml.left += left;
  3893.                     fileHtml.right += right;
  3894.                 }
  3895.                 else {
  3896.                     console.error('Unknown state reached while processing groups of lines', contextLines, oldLines, newLines);
  3897.                 }
  3898.             });
  3899.             return fileHtml;
  3900.         })
  3901.             .reduce(function (accomulated, html) {
  3902.             return { left: accomulated.left + html.left, right: accomulated.right + html.right };
  3903.         }, { left: '', right: '' });
  3904.     };
  3905.     SideBySideRenderer.prototype.applyLineGroupping = function (block) {
  3906.         var blockLinesGroups = [];
  3907.         var oldLines = [];
  3908.         var newLines = [];
  3909.         for (var i = 0; i < block.lines.length; i++) {
  3910.             var diffLine = block.lines[i];
  3911.             if ((diffLine.type !== LineType.INSERT && newLines.length) ||
  3912.                 (diffLine.type === LineType.CONTEXT && oldLines.length > 0)) {
  3913.                 blockLinesGroups.push([[], oldLines, newLines]);
  3914.                 oldLines = [];
  3915.                 newLines = [];
  3916.             }
  3917.             if (diffLine.type === LineType.CONTEXT) {
  3918.                 blockLinesGroups.push([[diffLine], [], []]);
  3919.             }
  3920.             else if (diffLine.type === LineType.INSERT && oldLines.length === 0) {
  3921.                 blockLinesGroups.push([[], [], [diffLine]]);
  3922.             }
  3923.             else if (diffLine.type === LineType.INSERT && oldLines.length > 0) {
  3924.                 newLines.push(diffLine);
  3925.             }
  3926.             else if (diffLine.type === LineType.DELETE) {
  3927.                 oldLines.push(diffLine);
  3928.             }
  3929.         }
  3930.         if (oldLines.length || newLines.length) {
  3931.             blockLinesGroups.push([[], oldLines, newLines]);
  3932.             oldLines = [];
  3933.             newLines = [];
  3934.         }
  3935.         return blockLinesGroups;
  3936.     };
  3937.     SideBySideRenderer.prototype.applyRematchMatching = function (oldLines, newLines, matcher) {
  3938.         var comparisons = oldLines.length * newLines.length;
  3939.         var maxLineSizeInBlock = Math.max.apply(null, [0].concat(oldLines.concat(newLines).map(function (elem) { return elem.content.length; })));
  3940.         var doMatching = comparisons < this.config.matchingMaxComparisons &&
  3941.             maxLineSizeInBlock < this.config.maxLineSizeInBlockForComparison &&
  3942.             (this.config.matching === 'lines' || this.config.matching === 'words');
  3943.         return doMatching ? matcher(oldLines, newLines) : [[oldLines, newLines]];
  3944.     };
  3945.     SideBySideRenderer.prototype.makeHeaderHtml = function (blockHeader) {
  3946.         return this.hoganUtils.render(side_by_side_renderer_genericTemplatesPath, 'block-header', {
  3947.             CSSLineClass: CSSLineClass,
  3948.             blockHeader: blockHeader,
  3949.             lineClass: 'd2h-code-side-linenumber',
  3950.             contentClass: 'd2h-code-side-line',
  3951.         });
  3952.     };
  3953.     SideBySideRenderer.prototype.processChangedLines = function (isCombined, oldLines, newLines) {
  3954.         var fileHtml = {
  3955.             right: '',
  3956.             left: '',
  3957.         };
  3958.         var maxLinesNumber = Math.max(oldLines.length, newLines.length);
  3959.         for (var i = 0; i < maxLinesNumber; i++) {
  3960.             var oldLine = oldLines[i];
  3961.             var newLine = newLines[i];
  3962.             var diff = oldLine !== undefined && newLine !== undefined
  3963.                 ? diffHighlight(oldLine.content, newLine.content, isCombined, this.config)
  3964.                 : undefined;
  3965.             var preparedOldLine = oldLine !== undefined && oldLine.oldNumber !== undefined
  3966.                 ? side_by_side_renderer_assign(side_by_side_renderer_assign({}, (diff !== undefined
  3967.                     ? {
  3968.                         prefix: diff.oldLine.prefix,
  3969.                         content: diff.oldLine.content,
  3970.                         type: CSSLineClass.DELETE_CHANGES,
  3971.                     }
  3972.                     : side_by_side_renderer_assign(side_by_side_renderer_assign({}, deconstructLine(oldLine.content, isCombined)), { type: toCSSClass(oldLine.type) }))), { number: oldLine.oldNumber }) : undefined;
  3973.             var preparedNewLine = newLine !== undefined && newLine.newNumber !== undefined
  3974.                 ? side_by_side_renderer_assign(side_by_side_renderer_assign({}, (diff !== undefined
  3975.                     ? {
  3976.                         prefix: diff.newLine.prefix,
  3977.                         content: diff.newLine.content,
  3978.                         type: CSSLineClass.INSERT_CHANGES,
  3979.                     }
  3980.                     : side_by_side_renderer_assign(side_by_side_renderer_assign({}, deconstructLine(newLine.content, isCombined)), { type: toCSSClass(newLine.type) }))), { number: newLine.newNumber }) : undefined;
  3981.             var _a = this.generateLineHtml(preparedOldLine, preparedNewLine), left = _a.left, right = _a.right;
  3982.             fileHtml.left += left;
  3983.             fileHtml.right += right;
  3984.         }
  3985.         return fileHtml;
  3986.     };
  3987.     SideBySideRenderer.prototype.generateLineHtml = function (oldLine, newLine) {
  3988.         return {
  3989.             left: this.generateSingleHtml(oldLine),
  3990.             right: this.generateSingleHtml(newLine),
  3991.         };
  3992.     };
  3993.     SideBySideRenderer.prototype.generateSingleHtml = function (line) {
  3994.         var lineClass = 'd2h-code-side-linenumber';
  3995.         var contentClass = 'd2h-code-side-line';
  3996.         return this.hoganUtils.render(side_by_side_renderer_genericTemplatesPath, 'line', {
  3997.             type: (line === null || line === void 0 ? void 0 : line.type) || CSSLineClass.CONTEXT + " d2h-emptyplaceholder",
  3998.             lineClass: line !== undefined ? lineClass : lineClass + " d2h-code-side-emptyplaceholder",
  3999.             contentClass: line !== undefined ? contentClass : contentClass + " d2h-code-side-emptyplaceholder",
  4000.             prefix: (line === null || line === void 0 ? void 0 : line.prefix) === ' ' ? '&nbsp;' : line === null || line === void 0 ? void 0 : line.prefix,
  4001.             content: line === null || line === void 0 ? void 0 : line.content,
  4002.             lineNumber: line === null || line === void 0 ? void 0 : line.number,
  4003.         });
  4004.     };
  4005.     return SideBySideRenderer;
  4006. }());
  4007. /* harmony default export */ var side_by_side_renderer = (side_by_side_renderer_SideBySideRenderer);
  4008. //# sourceMappingURL=side-by-side-renderer.js.map
  4009. // EXTERNAL MODULE: ./node_modules/hogan.js/lib/hogan.js
  4010. var hogan = __webpack_require__("Ruv9");
  4011.  
  4012. // CONCATENATED MODULE: ./node_modules/diff2html/lib-esm/diff2html-templates.js
  4013.  
  4014. var defaultTemplates = {};
  4015. defaultTemplates["file-summary-line"] = new hogan["Template"]({ code: function (c, p, i) { var t = this; t.b(i = i || ""); t.b("<li class=\"d2h-file-list-line\">"); t.b("\n" + i); t.b("    <span class=\"d2h-file-name-wrapper\">"); t.b("\n" + i); t.b(t.rp("<fileIcon0", c, p, "      ")); t.b("      <a href=\"#"); t.b(t.v(t.f("fileHtmlId", c, p, 0))); t.b("\" class=\"d2h-file-name\">"); t.b(t.v(t.f("fileName", c, p, 0))); t.b("</a>"); t.b("\n" + i); t.b("      <span class=\"d2h-file-stats\">"); t.b("\n" + i); t.b("          <span class=\"d2h-lines-added\">"); t.b(t.v(t.f("addedLines", c, p, 0))); t.b("</span>"); t.b("\n" + i); t.b("          <span class=\"d2h-lines-deleted\">"); t.b(t.v(t.f("deletedLines", c, p, 0))); t.b("</span>"); t.b("\n" + i); t.b("      </span>"); t.b("\n" + i); t.b("    </span>"); t.b("\n" + i); t.b("</li>"); return t.fl(); }, partials: { "<fileIcon0": { name: "fileIcon", partials: {}, subs: {} } }, subs: {} });
  4016. defaultTemplates["file-summary-wrapper"] = new hogan["Template"]({ code: function (c, p, i) { var t = this; t.b(i = i || ""); t.b("<div class=\"d2h-file-list-wrapper\">"); t.b("\n" + i); t.b("    <div class=\"d2h-file-list-header\">"); t.b("\n" + i); t.b("        <span class=\"d2h-file-list-title\">Files changed ("); t.b(t.v(t.f("filesNumber", c, p, 0))); t.b(")</span>"); t.b("\n" + i); t.b("        <a class=\"d2h-file-switch d2h-hide\">hide</a>"); t.b("\n" + i); t.b("        <a class=\"d2h-file-switch d2h-show\">show</a>"); t.b("\n" + i); t.b("    </div>"); t.b("\n" + i); t.b("    <ol class=\"d2h-file-list\">"); t.b("\n" + i); t.b("    "); t.b(t.t(t.f("files", c, p, 0))); t.b("\n" + i); t.b("    </ol>"); t.b("\n" + i); t.b("</div>"); return t.fl(); }, partials: {}, subs: {} });
  4017. defaultTemplates["generic-block-header"] = new hogan["Template"]({ code: function (c, p, i) { var t = this; t.b(i = i || ""); t.b("<tr>"); t.b("\n" + i); t.b("    <td class=\""); t.b(t.v(t.f("lineClass", c, p, 0))); t.b(" "); t.b(t.v(t.d("CSSLineClass.INFO", c, p, 0))); t.b("\"></td>"); t.b("\n" + i); t.b("    <td class=\""); t.b(t.v(t.d("CSSLineClass.INFO", c, p, 0))); t.b("\">"); t.b("\n" + i); t.b("        <div class=\""); t.b(t.v(t.f("contentClass", c, p, 0))); t.b(" "); t.b(t.v(t.d("CSSLineClass.INFO", c, p, 0))); t.b("\">"); t.b(t.t(t.f("blockHeader", c, p, 0))); t.b("</div>"); t.b("\n" + i); t.b("    </td>"); t.b("\n" + i); t.b("</tr>"); return t.fl(); }, partials: {}, subs: {} });
  4018. defaultTemplates["generic-empty-diff"] = new hogan["Template"]({ code: function (c, p, i) { var t = this; t.b(i = i || ""); t.b("<tr>"); t.b("\n" + i); t.b("    <td class=\""); t.b(t.v(t.d("CSSLineClass.INFO", c, p, 0))); t.b("\">"); t.b("\n" + i); t.b("        <div class=\""); t.b(t.v(t.f("contentClass", c, p, 0))); t.b(" "); t.b(t.v(t.d("CSSLineClass.INFO", c, p, 0))); t.b("\">"); t.b("\n" + i); t.b("            File without changes"); t.b("\n" + i); t.b("        </div>"); t.b("\n" + i); t.b("    </td>"); t.b("\n" + i); t.b("</tr>"); return t.fl(); }, partials: {}, subs: {} });
  4019. defaultTemplates["generic-file-path"] = new hogan["Template"]({ code: function (c, p, i) { var t = this; t.b(i = i || ""); t.b("<span class=\"d2h-file-name-wrapper\">"); t.b("\n" + i); t.b(t.rp("<fileIcon0", c, p, "    ")); t.b("    <span class=\"d2h-file-name\">"); t.b(t.v(t.f("fileDiffName", c, p, 0))); t.b("</span>"); t.b("\n" + i); t.b(t.rp("<fileTag1", c, p, "    ")); t.b("</span>"); return t.fl(); }, partials: { "<fileIcon0": { name: "fileIcon", partials: {}, subs: {} }, "<fileTag1": { name: "fileTag", partials: {}, subs: {} } }, subs: {} });
  4020. defaultTemplates["generic-line"] = new hogan["Template"]({ code: function (c, p, i) { var t = this; t.b(i = i || ""); t.b("<tr>"); t.b("\n" + i); t.b("    <td class=\""); t.b(t.v(t.f("lineClass", c, p, 0))); t.b(" "); t.b(t.v(t.f("type", c, p, 0))); t.b("\">"); t.b("\n" + i); t.b("      "); t.b(t.t(t.f("lineNumber", c, p, 0))); t.b("\n" + i); t.b("    </td>"); t.b("\n" + i); t.b("    <td class=\""); t.b(t.v(t.f("type", c, p, 0))); t.b("\">"); t.b("\n" + i); t.b("        <div class=\""); t.b(t.v(t.f("contentClass", c, p, 0))); t.b(" "); t.b(t.v(t.f("type", c, p, 0))); t.b("\">"); t.b("\n" + i); if (t.s(t.f("prefix", c, p, 1), c, p, 0, 171, 247, "{{ }}")) {
  4021.         t.rs(c, p, function (c, p, t) { t.b("            <span class=\"d2h-code-line-prefix\">"); t.b(t.t(t.f("prefix", c, p, 0))); t.b("</span>"); t.b("\n" + i); });
  4022.         c.pop();
  4023.     } if (!t.s(t.f("prefix", c, p, 1), c, p, 1, 0, 0, "")) {
  4024.         t.b("            <span class=\"d2h-code-line-prefix\">&nbsp;</span>");
  4025.         t.b("\n" + i);
  4026.     } ; if (t.s(t.f("content", c, p, 1), c, p, 0, 380, 454, "{{ }}")) {
  4027.         t.rs(c, p, function (c, p, t) { t.b("            <span class=\"d2h-code-line-ctn\">"); t.b(t.t(t.f("content", c, p, 0))); t.b("</span>"); t.b("\n" + i); });
  4028.         c.pop();
  4029.     } if (!t.s(t.f("content", c, p, 1), c, p, 1, 0, 0, "")) {
  4030.         t.b("            <span class=\"d2h-code-line-ctn\"><br></span>");
  4031.         t.b("\n" + i);
  4032.     } ; t.b("        </div>"); t.b("\n" + i); t.b("    </td>"); t.b("\n" + i); t.b("</tr>"); return t.fl(); }, partials: {}, subs: {} });
  4033. defaultTemplates["generic-wrapper"] = new hogan["Template"]({ code: function (c, p, i) { var t = this; t.b(i = i || ""); t.b("<div class=\"d2h-wrapper\">"); t.b("\n" + i); t.b("    "); t.b(t.t(t.f("content", c, p, 0))); t.b("\n" + i); t.b("</div>"); return t.fl(); }, partials: {}, subs: {} });
  4034. defaultTemplates["icon-file-added"] = new hogan["Template"]({ code: function (c, p, i) { var t = this; t.b(i = i || ""); t.b("<svg aria-hidden=\"true\" class=\"d2h-icon d2h-added\" height=\"16\" title=\"added\" version=\"1.1\" viewBox=\"0 0 14 16\""); t.b("\n" + i); t.b("     width=\"14\">"); t.b("\n" + i); t.b("    <path d=\"M13 1H1C0.45 1 0 1.45 0 2v12c0 0.55 0.45 1 1 1h12c0.55 0 1-0.45 1-1V2c0-0.55-0.45-1-1-1z m0 13H1V2h12v12zM6 9H3V7h3V4h2v3h3v2H8v3H6V9z\"></path>"); t.b("\n" + i); t.b("</svg>"); return t.fl(); }, partials: {}, subs: {} });
  4035. defaultTemplates["icon-file-changed"] = new hogan["Template"]({ code: function (c, p, i) { var t = this; t.b(i = i || ""); t.b("<svg aria-hidden=\"true\" class=\"d2h-icon d2h-changed\" height=\"16\" title=\"modified\" version=\"1.1\""); t.b("\n" + i); t.b("     viewBox=\"0 0 14 16\" width=\"14\">"); t.b("\n" + i); t.b("    <path d=\"M13 1H1C0.45 1 0 1.45 0 2v12c0 0.55 0.45 1 1 1h12c0.55 0 1-0.45 1-1V2c0-0.55-0.45-1-1-1z m0 13H1V2h12v12zM4 8c0-1.66 1.34-3 3-3s3 1.34 3 3-1.34 3-3 3-3-1.34-3-3z\"></path>"); t.b("\n" + i); t.b("</svg>"); return t.fl(); }, partials: {}, subs: {} });
  4036. defaultTemplates["icon-file-deleted"] = new hogan["Template"]({ code: function (c, p, i) { var t = this; t.b(i = i || ""); t.b("<svg aria-hidden=\"true\" class=\"d2h-icon d2h-deleted\" height=\"16\" title=\"removed\" version=\"1.1\""); t.b("\n" + i); t.b("     viewBox=\"0 0 14 16\" width=\"14\">"); t.b("\n" + i); t.b("    <path d=\"M13 1H1C0.45 1 0 1.45 0 2v12c0 0.55 0.45 1 1 1h12c0.55 0 1-0.45 1-1V2c0-0.55-0.45-1-1-1z m0 13H1V2h12v12zM11 9H3V7h8v2z\"></path>"); t.b("\n" + i); t.b("</svg>"); return t.fl(); }, partials: {}, subs: {} });
  4037. defaultTemplates["icon-file-renamed"] = new hogan["Template"]({ code: function (c, p, i) { var t = this; t.b(i = i || ""); t.b("<svg aria-hidden=\"true\" class=\"d2h-icon d2h-moved\" height=\"16\" title=\"renamed\" version=\"1.1\""); t.b("\n" + i); t.b("     viewBox=\"0 0 14 16\" width=\"14\">"); t.b("\n" + i); t.b("    <path d=\"M6 9H3V7h3V4l5 4-5 4V9z m8-7v12c0 0.55-0.45 1-1 1H1c-0.55 0-1-0.45-1-1V2c0-0.55 0.45-1 1-1h12c0.55 0 1 0.45 1 1z m-1 0H1v12h12V2z\"></path>"); t.b("\n" + i); t.b("</svg>"); return t.fl(); }, partials: {}, subs: {} });
  4038. defaultTemplates["icon-file"] = new hogan["Template"]({ code: function (c, p, i) { var t = this; t.b(i = i || ""); t.b("<svg aria-hidden=\"true\" class=\"d2h-icon\" height=\"16\" version=\"1.1\" viewBox=\"0 0 12 16\" width=\"12\">"); t.b("\n" + i); t.b("    <path d=\"M6 5H2v-1h4v1zM2 8h7v-1H2v1z m0 2h7v-1H2v1z m0 2h7v-1H2v1z m10-7.5v9.5c0 0.55-0.45 1-1 1H1c-0.55 0-1-0.45-1-1V2c0-0.55 0.45-1 1-1h7.5l3.5 3.5z m-1 0.5L8 2H1v12h10V5z\"></path>"); t.b("\n" + i); t.b("</svg>"); return t.fl(); }, partials: {}, subs: {} });
  4039. defaultTemplates["line-by-line-file-diff"] = new hogan["Template"]({ code: function (c, p, i) { var t = this; t.b(i = i || ""); t.b("<div id=\""); t.b(t.v(t.f("fileHtmlId", c, p, 0))); t.b("\" class=\"d2h-file-wrapper\" data-lang=\""); t.b(t.v(t.d("file.language", c, p, 0))); t.b("\">"); t.b("\n" + i); t.b("    <div class=\"d2h-file-header\">"); t.b("\n" + i); t.b("    "); t.b(t.t(t.f("filePath", c, p, 0))); t.b("\n" + i); t.b("    </div>"); t.b("\n" + i); t.b("    <div class=\"d2h-file-diff\">"); t.b("\n" + i); t.b("        <div class=\"d2h-code-wrapper\">"); t.b("\n" + i); t.b("            <table class=\"d2h-diff-table\">"); t.b("\n" + i); t.b("                <tbody class=\"d2h-diff-tbody\">"); t.b("\n" + i); t.b("                "); t.b(t.t(t.f("diffs", c, p, 0))); t.b("\n" + i); t.b("                </tbody>"); t.b("\n" + i); t.b("            </table>"); t.b("\n" + i); t.b("        </div>"); t.b("\n" + i); t.b("    </div>"); t.b("\n" + i); t.b("</div>"); return t.fl(); }, partials: {}, subs: {} });
  4040. defaultTemplates["line-by-line-numbers"] = new hogan["Template"]({ code: function (c, p, i) { var t = this; t.b(i = i || ""); t.b("<div class=\"line-num1\">"); t.b(t.v(t.f("oldNumber", c, p, 0))); t.b("</div>"); t.b("\n" + i); t.b("<div class=\"line-num2\">"); t.b(t.v(t.f("newNumber", c, p, 0))); t.b("</div>"); return t.fl(); }, partials: {}, subs: {} });
  4041. defaultTemplates["side-by-side-file-diff"] = new hogan["Template"]({ code: function (c, p, i) { var t = this; t.b(i = i || ""); t.b("<div id=\""); t.b(t.v(t.f("fileHtmlId", c, p, 0))); t.b("\" class=\"d2h-file-wrapper\" data-lang=\""); t.b(t.v(t.d("file.language", c, p, 0))); t.b("\">"); t.b("\n" + i); t.b("    <div class=\"d2h-file-header\">"); t.b("\n" + i); t.b("      "); t.b(t.t(t.f("filePath", c, p, 0))); t.b("\n" + i); t.b("    </div>"); t.b("\n" + i); t.b("    <div class=\"d2h-files-diff\">"); t.b("\n" + i); t.b("        <div class=\"d2h-file-side-diff\">"); t.b("\n" + i); t.b("            <div class=\"d2h-code-wrapper\">"); t.b("\n" + i); t.b("                <table class=\"d2h-diff-table\">"); t.b("\n" + i); t.b("                    <tbody class=\"d2h-diff-tbody\">"); t.b("\n" + i); t.b("                    "); t.b(t.t(t.d("diffs.left", c, p, 0))); t.b("\n" + i); t.b("                    </tbody>"); t.b("\n" + i); t.b("                </table>"); t.b("\n" + i); t.b("            </div>"); t.b("\n" + i); t.b("        </div>"); t.b("\n" + i); t.b("        <div class=\"d2h-file-side-diff\">"); t.b("\n" + i); t.b("            <div class=\"d2h-code-wrapper\">"); t.b("\n" + i); t.b("                <table class=\"d2h-diff-table\">"); t.b("\n" + i); t.b("                    <tbody class=\"d2h-diff-tbody\">"); t.b("\n" + i); t.b("                    "); t.b(t.t(t.d("diffs.right", c, p, 0))); t.b("\n" + i); t.b("                    </tbody>"); t.b("\n" + i); t.b("                </table>"); t.b("\n" + i); t.b("            </div>"); t.b("\n" + i); t.b("        </div>"); t.b("\n" + i); t.b("    </div>"); t.b("\n" + i); t.b("</div>"); return t.fl(); }, partials: {}, subs: {} });
  4042. defaultTemplates["tag-file-added"] = new hogan["Template"]({ code: function (c, p, i) { var t = this; t.b(i = i || ""); t.b("<span class=\"d2h-tag d2h-added d2h-added-tag\">ADDED</span>"); return t.fl(); }, partials: {}, subs: {} });
  4043. defaultTemplates["tag-file-changed"] = new hogan["Template"]({ code: function (c, p, i) { var t = this; t.b(i = i || ""); t.b("<span class=\"d2h-tag d2h-changed d2h-changed-tag\">CHANGED</span>"); return t.fl(); }, partials: {}, subs: {} });
  4044. defaultTemplates["tag-file-deleted"] = new hogan["Template"]({ code: function (c, p, i) { var t = this; t.b(i = i || ""); t.b("<span class=\"d2h-tag d2h-deleted d2h-deleted-tag\">DELETED</span>"); return t.fl(); }, partials: {}, subs: {} });
  4045. defaultTemplates["tag-file-renamed"] = new hogan["Template"]({ code: function (c, p, i) { var t = this; t.b(i = i || ""); t.b("<span class=\"d2h-tag d2h-moved d2h-moved-tag\">RENAMED</span>"); return t.fl(); }, partials: {}, subs: {} });
  4046. //# sourceMappingURL=diff2html-templates.js.map
  4047. // CONCATENATED MODULE: ./node_modules/diff2html/lib-esm/hoganjs-utils.js
  4048. var hoganjs_utils_assign = (undefined && undefined.__assign) || function () {
  4049.     hoganjs_utils_assign = Object.assign || function(t) {
  4050.         for (var s, i = 1, n = arguments.length; i < n; i++) {
  4051.             s = arguments[i];
  4052.             for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
  4053.                 t[p] = s[p];
  4054.         }
  4055.         return t;
  4056.     };
  4057.     return hoganjs_utils_assign.apply(this, arguments);
  4058. };
  4059.  
  4060.  
  4061. var hoganjs_utils_HoganJsUtils = (function () {
  4062.     function HoganJsUtils(_a) {
  4063.         var _b = _a.compiledTemplates, compiledTemplates = _b === void 0 ? {} : _b, _c = _a.rawTemplates, rawTemplates = _c === void 0 ? {} : _c;
  4064.         var compiledRawTemplates = Object.entries(rawTemplates).reduce(function (previousTemplates, _a) {
  4065.             var _b;
  4066.             var name = _a[0], templateString = _a[1];
  4067.             var compiledTemplate = hogan["compile"](templateString, { asString: false });
  4068.             return hoganjs_utils_assign(hoganjs_utils_assign({}, previousTemplates), (_b = {}, _b[name] = compiledTemplate, _b));
  4069.         }, {});
  4070.         this.preCompiledTemplates = hoganjs_utils_assign(hoganjs_utils_assign(hoganjs_utils_assign({}, defaultTemplates), compiledTemplates), compiledRawTemplates);
  4071.     }
  4072.     HoganJsUtils.compile = function (templateString) {
  4073.         return hogan["compile"](templateString, { asString: false });
  4074.     };
  4075.     HoganJsUtils.prototype.render = function (namespace, view, params, partials, indent) {
  4076.         var templateKey = this.templateKey(namespace, view);
  4077.         try {
  4078.             var template = this.preCompiledTemplates[templateKey];
  4079.             return template.render(params, partials, indent);
  4080.         }
  4081.         catch (e) {
  4082.             throw new Error("Could not find template to render '" + templateKey + "'");
  4083.         }
  4084.     };
  4085.     HoganJsUtils.prototype.template = function (namespace, view) {
  4086.         return this.preCompiledTemplates[this.templateKey(namespace, view)];
  4087.     };
  4088.     HoganJsUtils.prototype.templateKey = function (namespace, view) {
  4089.         return namespace + "-" + view;
  4090.     };
  4091.     return HoganJsUtils;
  4092. }());
  4093. /* harmony default export */ var hoganjs_utils = (hoganjs_utils_HoganJsUtils);
  4094. //# sourceMappingURL=hoganjs-utils.js.map
  4095. // CONCATENATED MODULE: ./node_modules/diff2html/lib-esm/diff2html.js
  4096. var diff2html_assign = (undefined && undefined.__assign) || function () {
  4097.     diff2html_assign = Object.assign || function(t) {
  4098.         for (var s, i = 1, n = arguments.length; i < n; i++) {
  4099.             s = arguments[i];
  4100.             for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
  4101.                 t[p] = s[p];
  4102.         }
  4103.         return t;
  4104.     };
  4105.     return diff2html_assign.apply(this, arguments);
  4106. };
  4107.  
  4108.  
  4109.  
  4110.  
  4111.  
  4112.  
  4113. var defaultDiff2HtmlConfig = diff2html_assign(diff2html_assign(diff2html_assign({}, defaultLineByLineRendererConfig), defaultSideBySideRendererConfig), { outputFormat: OutputFormatType.LINE_BY_LINE, drawFileList: true });
  4114. function diff2html_parse(diffInput, configuration) {
  4115.     if (configuration === void 0) { configuration = {}; }
  4116.     return parse(diffInput, diff2html_assign(diff2html_assign({}, defaultDiff2HtmlConfig), configuration));
  4117. }
  4118. function html(diffInput, configuration) {
  4119.     if (configuration === void 0) { configuration = {}; }
  4120.     var config = diff2html_assign(diff2html_assign({}, defaultDiff2HtmlConfig), configuration);
  4121.     var diffJson = typeof diffInput === 'string' ? parse(diffInput, config) : diffInput;
  4122.     var hoganUtils = new hoganjs_utils(config);
  4123.     var fileList = config.drawFileList ? render(diffJson, hoganUtils) : '';
  4124.     var diffOutput = config.outputFormat === 'side-by-side'
  4125.         ? new side_by_side_renderer(hoganUtils, config).render(diffJson)
  4126.         : new line_by_line_renderer(hoganUtils, config).render(diffJson);
  4127.     return fileList + diffOutput;
  4128. }
  4129. //# sourceMappingURL=diff2html.js.map
  4130. // EXTERNAL MODULE: external "$"
  4131. var external_$_ = __webpack_require__("xeH2");
  4132.  
  4133. // CONCATENATED MODULE: ./src/js/utils.js
  4134. function request (url) {
  4135.   return new Promise((resolve, reject) => {
  4136.     window.GM_xmlhttpRequest({
  4137.       url,
  4138.       onload: function ({ response, responseText, }) {
  4139.         resolve({ response, responseText })
  4140.       }
  4141.     })
  4142.   })
  4143. }
  4144.  
  4145.  
  4146.  
  4147. // CONCATENATED MODULE: ./src/js/index.js
  4148.  
  4149.  
  4150.  
  4151.  
  4152.  
  4153. function main () {
  4154.   console.log('start bgm wiki rev diff UserScript')
  4155.   initUI()
  4156. }
  4157.  
  4158. function initUI () {
  4159.   external_$_('#pagehistory li').each(function () {
  4160.     const el = external_$_(this)
  4161.     const rev = parseRevEl(el)
  4162.     el.prepend(`<input type="checkbox" class="rev-trim21-cn" name="rev" label="select to compare" value="${rev.id}">`)
  4163.   })
  4164.   external_$_('#columnInSubjectA span.text').append('<a href="#;" id="compare-trim21-cn" tar class="l"> > 比较选中的版本</a>')
  4165.   external_$_('#compare-trim21-cn').click(function () {
  4166.     const selectedRevs = getSelectedVersion()
  4167.     compare(selectedRevs)
  4168.   })
  4169. }
  4170.  
  4171. function getSelectedVersion () {
  4172.   const selectedVersion = []
  4173.   const selectedRev = external_$_('.rev-trim21-cn:checked')
  4174.   if (selectedRev.length < 2) {
  4175.     window.alert('请选中两个版本进行比较')
  4176.   }
  4177.   if (selectedRev.length > 2) {
  4178.     window.alert('只能比较两个版本')
  4179.   }
  4180.   selectedRev.each(function () {
  4181.     const el = external_$_(this)
  4182.     selectedVersion.push(el.val())
  4183.   })
  4184.   selectedVersion.reverse()
  4185.   return selectedVersion
  4186. }
  4187.  
  4188. function compare (revs) {
  4189.   console.log('compare')
  4190.   external_$_('head').append('<link rel="stylesheet" type="text/css" href="https://cdn.jsdelivr.net/npm/diff2html/bundles/css/diff2html.min.css" />')
  4191.   const rev1 = getRevInfo(revs[0])
  4192.   const rev2 = getRevInfo(revs[1])
  4193.   const p1 = request(rev1.url)
  4194.   const p2 = request(rev2.url)
  4195.   Promise.all([p1, p2]).then(values => {
  4196.     const contents = []
  4197.     for (const page of values) {
  4198.       const jq = external_$_(page.responseText)
  4199.       contents.push(jq.find('#subject_infobox').val())
  4200.     }
  4201.     const d = difflib["unifiedDiff"](contents[0].split('\n'), contents[1].split('\n'), {
  4202.       fromfile: rev1.comment,
  4203.       tofile: rev2.comment,
  4204.       fromfiledate: rev1.date,
  4205.       tofiledate: rev2.date,
  4206.       lineterm: ''
  4207.     })
  4208.     const rendered = js_render(d.join('\n'), {})
  4209.     external_$_('#columnInSubjectA').prepend(rendered)
  4210.   })
  4211. }
  4212.  
  4213. function getRevs () {
  4214.   const revs = []
  4215.   external_$_('#pagehistory li').each(function () {
  4216.     const el = external_$_(this)
  4217.     revs.push(parseRevEl(el))
  4218.   })
  4219.   return revs
  4220. }
  4221.  
  4222. function parseRevEl (el) {
  4223.   const date = el.find('a').first().html()
  4224.   const revEL = el.find('a.l:contains("恢复")')
  4225.   const revCommentEl = el.find('span.comment')
  4226.   let comment = ''
  4227.   if (revCommentEl.length) {
  4228.     comment = revCommentEl.html()
  4229.     comment = comment.substring(1, comment.length - 1)
  4230.   }
  4231.   const revHref = revEL.attr('href')
  4232.   const revID = revHref.split('/').pop()
  4233.   return {
  4234.     id: revID,
  4235.     comment,
  4236.     date,
  4237.     url: revHref,
  4238.   }
  4239. }
  4240.  
  4241. function getRevInfo (revID) {
  4242.   for (const rev of getRevs()) {
  4243.     if (rev.id === revID) {
  4244.       console.log(revID, rev)
  4245.       return rev
  4246.     }
  4247.   }
  4248. }
  4249.  
  4250. function js_render (diff) {
  4251.   return html(diff)
  4252. }
  4253.  
  4254. main()
  4255.  
  4256.  
  4257. /***/ }),
  4258.  
  4259. /***/ "qVjC":
  4260. /***/ (function(module, exports, __webpack_require__) {
  4261.  
  4262. // Generated by CoffeeScript 1.3.1
  4263.  
  4264. /*
  4265. Module difflib -- helpers for computing deltas between objects.
  4266.  
  4267. Function getCloseMatches(word, possibilities, n=3, cutoff=0.6):
  4268.     Use SequenceMatcher to return list of the best "good enough" matches.
  4269.  
  4270. Function contextDiff(a, b):
  4271.     For two lists of strings, return a delta in context diff format.
  4272.  
  4273. Function ndiff(a, b):
  4274.     Return a delta: the difference between `a` and `b` (lists of strings).
  4275.  
  4276. Function restore(delta, which):
  4277.     Return one of the two sequences that generated an ndiff delta.
  4278.  
  4279. Function unifiedDiff(a, b):
  4280.     For two lists of strings, return a delta in unified diff format.
  4281.  
  4282. Class SequenceMatcher:
  4283.     A flexible class for comparing pairs of sequences of any type.
  4284.  
  4285. Class Differ:
  4286.     For producing human-readable deltas from sequences of lines of text.
  4287. */
  4288.  
  4289.  
  4290. (function() {
  4291.   var Differ, Heap, IS_CHARACTER_JUNK, IS_LINE_JUNK, SequenceMatcher, assert, contextDiff, floor, getCloseMatches, max, min, ndiff, restore, unifiedDiff, _any, _arrayCmp, _calculateRatio, _countLeading, _formatRangeContext, _formatRangeUnified, _has,
  4292.     __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
  4293.  
  4294.   floor = Math.floor, max = Math.max, min = Math.min;
  4295.  
  4296.   Heap = __webpack_require__("F1pL");
  4297.  
  4298.   assert = __webpack_require__("9lTW");
  4299.  
  4300.   _calculateRatio = function(matches, length) {
  4301.     if (length) {
  4302.       return 2.0 * matches / length;
  4303.     } else {
  4304.       return 1.0;
  4305.     }
  4306.   };
  4307.  
  4308.   _arrayCmp = function(a, b) {
  4309.     var i, la, lb, _i, _ref, _ref1;
  4310.     _ref = [a.length, b.length], la = _ref[0], lb = _ref[1];
  4311.     for (i = _i = 0, _ref1 = min(la, lb); 0 <= _ref1 ? _i < _ref1 : _i > _ref1; i = 0 <= _ref1 ? ++_i : --_i) {
  4312.       if (a[i] < b[i]) {
  4313.         return -1;
  4314.       }
  4315.       if (a[i] > b[i]) {
  4316.         return 1;
  4317.       }
  4318.     }
  4319.     return la - lb;
  4320.   };
  4321.  
  4322.   _has = function(obj, key) {
  4323.     return Object.prototype.hasOwnProperty.call(obj, key);
  4324.   };
  4325.  
  4326.   _any = function(items) {
  4327.     var item, _i, _len;
  4328.     for (_i = 0, _len = items.length; _i < _len; _i++) {
  4329.       item = items[_i];
  4330.       if (item) {
  4331.         return true;
  4332.       }
  4333.     }
  4334.     return false;
  4335.   };
  4336.  
  4337.   SequenceMatcher = (function() {
  4338.  
  4339.     SequenceMatcher.name = 'SequenceMatcher';
  4340.  
  4341.     /*
  4342.       SequenceMatcher is a flexible class for comparing pairs of sequences of
  4343.       any type, so long as the sequence elements are hashable.  The basic
  4344.       algorithm predates, and is a little fancier than, an algorithm
  4345.       published in the late 1980's by Ratcliff and Obershelp under the
  4346.       hyperbolic name "gestalt pattern matching".  The basic idea is to find
  4347.       the longest contiguous matching subsequence that contains no "junk"
  4348.       elements (R-O doesn't address junk).  The same idea is then applied
  4349.       recursively to the pieces of the sequences to the left and to the right
  4350.       of the matching subsequence.  This does not yield minimal edit
  4351.       sequences, but does tend to yield matches that "look right" to people.
  4352.     
  4353.       SequenceMatcher tries to compute a "human-friendly diff" between two
  4354.       sequences.  Unlike e.g. UNIX(tm) diff, the fundamental notion is the
  4355.       longest *contiguous* & junk-free matching subsequence.  That's what
  4356.       catches peoples' eyes.  The Windows(tm) windiff has another interesting
  4357.       notion, pairing up elements that appear uniquely in each sequence.
  4358.       That, and the method here, appear to yield more intuitive difference
  4359.       reports than does diff.  This method appears to be the least vulnerable
  4360.       to synching up on blocks of "junk lines", though (like blank lines in
  4361.       ordinary text files, or maybe "<P>" lines in HTML files).  That may be
  4362.       because this is the only method of the 3 that has a *concept* of
  4363.       "junk" <wink>.
  4364.     
  4365.       Example, comparing two strings, and considering blanks to be "junk":
  4366.     
  4367.       >>> isjunk = (c) -> c is ' '
  4368.       >>> s = new SequenceMatcher(isjunk,
  4369.                                   'private Thread currentThread;',
  4370.                                   'private volatile Thread currentThread;')
  4371.     
  4372.       .ratio() returns a float in [0, 1], measuring the "similarity" of the
  4373.       sequences.  As a rule of thumb, a .ratio() value over 0.6 means the
  4374.       sequences are close matches:
  4375.     
  4376.       >>> s.ratio().toPrecision(3)
  4377.       '0.866'
  4378.     
  4379.       If you're only interested in where the sequences match,
  4380.       .getMatchingBlocks() is handy:
  4381.     
  4382.       >>> for [a, b, size] in s.getMatchingBlocks()
  4383.       ...   console.log("a[#{a}] and b[#{b}] match for #{size} elements");
  4384.       a[0] and b[0] match for 8 elements
  4385.       a[8] and b[17] match for 21 elements
  4386.       a[29] and b[38] match for 0 elements
  4387.     
  4388.       Note that the last tuple returned by .get_matching_blocks() is always a
  4389.       dummy, (len(a), len(b), 0), and this is the only case in which the last
  4390.       tuple element (number of elements matched) is 0.
  4391.     
  4392.       If you want to know how to change the first sequence into the second,
  4393.       use .get_opcodes():
  4394.     
  4395.       >>> for [op, a1, a2, b1, b2] in s.getOpcodes()
  4396.       ...   console.log "#{op} a[#{a1}:#{a2}] b[#{b1}:#{b2}]"
  4397.       equal a[0:8] b[0:8]
  4398.       insert a[8:8] b[8:17]
  4399.       equal a[8:29] b[17:38]
  4400.     
  4401.       See the Differ class for a fancy human-friendly file differencer, which
  4402.       uses SequenceMatcher both to compare sequences of lines, and to compare
  4403.       sequences of characters within similar (near-matching) lines.
  4404.     
  4405.       See also function getCloseMatches() in this module, which shows how
  4406.       simple code building on SequenceMatcher can be used to do useful work.
  4407.     
  4408.       Timing:  Basic R-O is cubic time worst case and quadratic time expected
  4409.       case.  SequenceMatcher is quadratic time for the worst case and has
  4410.       expected-case behavior dependent in a complicated way on how many
  4411.       elements the sequences have in common; best case time is linear.
  4412.     
  4413.       Methods:
  4414.     
  4415.       constructor(isjunk=null, a='', b='')
  4416.           Construct a SequenceMatcher.
  4417.     
  4418.       setSeqs(a, b)
  4419.           Set the two sequences to be compared.
  4420.     
  4421.       setSeq1(a)
  4422.           Set the first sequence to be compared.
  4423.     
  4424.       setSeq2(b)
  4425.           Set the second sequence to be compared.
  4426.     
  4427.       findLongestMatch(alo, ahi, blo, bhi)
  4428.           Find longest matching block in a[alo:ahi] and b[blo:bhi].
  4429.     
  4430.       getMatchingBlocks()
  4431.           Return list of triples describing matching subsequences.
  4432.     
  4433.       getOpcodes()
  4434.           Return list of 5-tuples describing how to turn a into b.
  4435.     
  4436.       ratio()
  4437.           Return a measure of the sequences' similarity (float in [0,1]).
  4438.     
  4439.       quickRatio()
  4440.           Return an upper bound on .ratio() relatively quickly.
  4441.     
  4442.       realQuickRatio()
  4443.           Return an upper bound on ratio() very quickly.
  4444.     */
  4445.  
  4446.  
  4447.     function SequenceMatcher(isjunk, a, b, autojunk) {
  4448.       this.isjunk = isjunk;
  4449.       if (a == null) {
  4450.         a = '';
  4451.       }
  4452.       if (b == null) {
  4453.         b = '';
  4454.       }
  4455.       this.autojunk = autojunk != null ? autojunk : true;
  4456.       /*
  4457.           Construct a SequenceMatcher.
  4458.       
  4459.           Optional arg isjunk is null (the default), or a one-argument
  4460.           function that takes a sequence element and returns true iff the
  4461.           element is junk.  Null is equivalent to passing "(x) -> 0", i.e.
  4462.           no elements are considered to be junk.  For example, pass
  4463.               (x) -> x in ' \t'
  4464.           if you're comparing lines as sequences of characters, and don't
  4465.           want to synch up on blanks or hard tabs.
  4466.       
  4467.           Optional arg a is the first of two sequences to be compared.  By
  4468.           default, an empty string.  The elements of a must be hashable.  See
  4469.           also .setSeqs() and .setSeq1().
  4470.       
  4471.           Optional arg b is the second of two sequences to be compared.  By
  4472.           default, an empty string.  The elements of b must be hashable. See
  4473.           also .setSeqs() and .setSeq2().
  4474.       
  4475.           Optional arg autojunk should be set to false to disable the
  4476.           "automatic junk heuristic" that treats popular elements as junk
  4477.           (see module documentation for more information).
  4478.       */
  4479.  
  4480.       this.a = this.b = null;
  4481.       this.setSeqs(a, b);
  4482.     }
  4483.  
  4484.     SequenceMatcher.prototype.setSeqs = function(a, b) {
  4485.       /* 
  4486.       Set the two sequences to be compared. 
  4487.       
  4488.       >>> s = new SequenceMatcher()
  4489.       >>> s.setSeqs('abcd', 'bcde')
  4490.       >>> s.ratio()
  4491.       0.75
  4492.       */
  4493.       this.setSeq1(a);
  4494.       return this.setSeq2(b);
  4495.     };
  4496.  
  4497.     SequenceMatcher.prototype.setSeq1 = function(a) {
  4498.       /* 
  4499.       Set the first sequence to be compared. 
  4500.       
  4501.       The second sequence to be compared is not changed.
  4502.       
  4503.       >>> s = new SequenceMatcher(null, 'abcd', 'bcde')
  4504.       >>> s.ratio()
  4505.       0.75
  4506.       >>> s.setSeq1('bcde')
  4507.       >>> s.ratio()
  4508.       1.0
  4509.       
  4510.       SequenceMatcher computes and caches detailed information about the
  4511.       second sequence, so if you want to compare one sequence S against
  4512.       many sequences, use .setSeq2(S) once and call .setSeq1(x)
  4513.       repeatedly for each of the other sequences.
  4514.       
  4515.       See also setSeqs() and setSeq2().
  4516.       */
  4517.       if (a === this.a) {
  4518.         return;
  4519.       }
  4520.       this.a = a;
  4521.       return this.matchingBlocks = this.opcodes = null;
  4522.     };
  4523.  
  4524.     SequenceMatcher.prototype.setSeq2 = function(b) {
  4525.       /*
  4526.           Set the second sequence to be compared. 
  4527.       
  4528.           The first sequence to be compared is not changed.
  4529.       
  4530.           >>> s = new SequenceMatcher(null, 'abcd', 'bcde')
  4531.           >>> s.ratio()
  4532.           0.75
  4533.           >>> s.setSeq2('abcd')
  4534.           >>> s.ratio()
  4535.           1.0
  4536.       
  4537.           SequenceMatcher computes and caches detailed information about the
  4538.           second sequence, so if you want to compare one sequence S against
  4539.           many sequences, use .setSeq2(S) once and call .setSeq1(x)
  4540.           repeatedly for each of the other sequences.
  4541.       
  4542.           See also setSeqs() and setSeq1().
  4543.       */
  4544.       if (b === this.b) {
  4545.         return;
  4546.       }
  4547.       this.b = b;
  4548.       this.matchingBlocks = this.opcodes = null;
  4549.       this.fullbcount = null;
  4550.       return this._chainB();
  4551.     };
  4552.  
  4553.     SequenceMatcher.prototype._chainB = function() {
  4554.       var b, b2j, elt, i, idxs, indices, isjunk, junk, n, ntest, popular, _i, _j, _len, _len1, _ref;
  4555.       b = this.b;
  4556.       this.b2j = b2j = {};
  4557.       for (i = _i = 0, _len = b.length; _i < _len; i = ++_i) {
  4558.         elt = b[i];
  4559.         indices = _has(b2j, elt) ? b2j[elt] : b2j[elt] = [];
  4560.         indices.push(i);
  4561.       }
  4562.       junk = {};
  4563.       isjunk = this.isjunk;
  4564.       if (isjunk) {
  4565.         _ref = Object.keys(b2j);
  4566.         for (_j = 0, _len1 = _ref.length; _j < _len1; _j++) {
  4567.           elt = _ref[_j];
  4568.           if (isjunk(elt)) {
  4569.             junk[elt] = true;
  4570.             delete b2j[elt];
  4571.           }
  4572.         }
  4573.       }
  4574.       popular = {};
  4575.       n = b.length;
  4576.       if (this.autojunk && n >= 200) {
  4577.         ntest = floor(n / 100) + 1;
  4578.         for (elt in b2j) {
  4579.           idxs = b2j[elt];
  4580.           if (idxs.length > ntest) {
  4581.             popular[elt] = true;
  4582.             delete b2j[elt];
  4583.           }
  4584.         }
  4585.       }
  4586.       this.isbjunk = function(b) {
  4587.         return _has(junk, b);
  4588.       };
  4589.       return this.isbpopular = function(b) {
  4590.         return _has(popular, b);
  4591.       };
  4592.     };
  4593.  
  4594.     SequenceMatcher.prototype.findLongestMatch = function(alo, ahi, blo, bhi) {
  4595.       /* 
  4596.       Find longest matching block in a[alo...ahi] and b[blo...bhi].  
  4597.       
  4598.       If isjunk is not defined:
  4599.       
  4600.       Return [i,j,k] such that a[i...i+k] is equal to b[j...j+k], where
  4601.           alo <= i <= i+k <= ahi
  4602.           blo <= j <= j+k <= bhi
  4603.       and for all [i',j',k'] meeting those conditions,
  4604.           k >= k'
  4605.           i <= i'
  4606.           and if i == i', j <= j'
  4607.       
  4608.       In other words, of all maximal matching blocks, return one that
  4609.       starts earliest in a, and of all those maximal matching blocks that
  4610.       start earliest in a, return the one that starts earliest in b.
  4611.       
  4612.       >>> isjunk = (x) -> x is ' '
  4613.       >>> s = new SequenceMatcher(isjunk, ' abcd', 'abcd abcd')
  4614.       >>> s.findLongestMatch(0, 5, 0, 9)
  4615.       [1, 0, 4]
  4616.       
  4617.       >>> s = new SequenceMatcher(null, 'ab', 'c')
  4618.       >>> s.findLongestMatch(0, 2, 0, 1)
  4619.       [0, 0, 0]
  4620.       */
  4621.  
  4622.       var a, b, b2j, besti, bestj, bestsize, i, isbjunk, j, j2len, k, newj2len, _i, _j, _len, _ref, _ref1, _ref2, _ref3, _ref4, _ref5;
  4623.       _ref = [this.a, this.b, this.b2j, this.isbjunk], a = _ref[0], b = _ref[1], b2j = _ref[2], isbjunk = _ref[3];
  4624.       _ref1 = [alo, blo, 0], besti = _ref1[0], bestj = _ref1[1], bestsize = _ref1[2];
  4625.       j2len = {};
  4626.       for (i = _i = alo; alo <= ahi ? _i < ahi : _i > ahi; i = alo <= ahi ? ++_i : --_i) {
  4627.         newj2len = {};
  4628.         _ref2 = (_has(b2j, a[i]) ? b2j[a[i]] : []);
  4629.         for (_j = 0, _len = _ref2.length; _j < _len; _j++) {
  4630.           j = _ref2[_j];
  4631.           if (j < blo) {
  4632.             continue;
  4633.           }
  4634.           if (j >= bhi) {
  4635.             break;
  4636.           }
  4637.           k = newj2len[j] = (j2len[j - 1] || 0) + 1;
  4638.           if (k > bestsize) {
  4639.             _ref3 = [i - k + 1, j - k + 1, k], besti = _ref3[0], bestj = _ref3[1], bestsize = _ref3[2];
  4640.           }
  4641.         }
  4642.         j2len = newj2len;
  4643.       }
  4644.       while (besti > alo && bestj > blo && !isbjunk(b[bestj - 1]) && a[besti - 1] === b[bestj - 1]) {
  4645.         _ref4 = [besti - 1, bestj - 1, bestsize + 1], besti = _ref4[0], bestj = _ref4[1], bestsize = _ref4[2];
  4646.       }
  4647.       while (besti + bestsize < ahi && bestj + bestsize < bhi && !isbjunk(b[bestj + bestsize]) && a[besti + bestsize] === b[bestj + bestsize]) {
  4648.         bestsize++;
  4649.       }
  4650.       while (besti > alo && bestj > blo && isbjunk(b[bestj - 1]) && a[besti - 1] === b[bestj - 1]) {
  4651.         _ref5 = [besti - 1, bestj - 1, bestsize + 1], besti = _ref5[0], bestj = _ref5[1], bestsize = _ref5[2];
  4652.       }
  4653.       while (besti + bestsize < ahi && bestj + bestsize < bhi && isbjunk(b[bestj + bestsize]) && a[besti + bestsize] === b[bestj + bestsize]) {
  4654.         bestsize++;
  4655.       }
  4656.       return [besti, bestj, bestsize];
  4657.     };
  4658.  
  4659.     SequenceMatcher.prototype.getMatchingBlocks = function() {
  4660.       /*
  4661.           Return list of triples describing matching subsequences.
  4662.       
  4663.           Each triple is of the form [i, j, n], and means that
  4664.           a[i...i+n] == b[j...j+n].  The triples are monotonically increasing in
  4665.           i and in j.  it's also guaranteed that if
  4666.           [i, j, n] and [i', j', n'] are adjacent triples in the list, and
  4667.           the second is not the last triple in the list, then i+n != i' or
  4668.           j+n != j'.  IOW, adjacent triples never describe adjacent equal
  4669.           blocks.
  4670.       
  4671.           The last triple is a dummy, [a.length, b.length, 0], and is the only
  4672.           triple with n==0.
  4673.       
  4674.           >>> s = new SequenceMatcher(null, 'abxcd', 'abcd')
  4675.           >>> s.getMatchingBlocks()
  4676.           [[0, 0, 2], [3, 2, 2], [5, 4, 0]]
  4677.       */
  4678.  
  4679.       var ahi, alo, bhi, blo, i, i1, i2, j, j1, j2, k, k1, k2, la, lb, matchingBlocks, nonAdjacent, queue, x, _i, _len, _ref, _ref1, _ref2, _ref3, _ref4;
  4680.       if (this.matchingBlocks) {
  4681.         return this.matchingBlocks;
  4682.       }
  4683.       _ref = [this.a.length, this.b.length], la = _ref[0], lb = _ref[1];
  4684.       queue = [[0, la, 0, lb]];
  4685.       matchingBlocks = [];
  4686.       while (queue.length) {
  4687.         _ref1 = queue.pop(), alo = _ref1[0], ahi = _ref1[1], blo = _ref1[2], bhi = _ref1[3];
  4688.         _ref2 = x = this.findLongestMatch(alo, ahi, blo, bhi), i = _ref2[0], j = _ref2[1], k = _ref2[2];
  4689.         if (k) {
  4690.           matchingBlocks.push(x);
  4691.           if (alo < i && blo < j) {
  4692.             queue.push([alo, i, blo, j]);
  4693.           }
  4694.           if (i + k < ahi && j + k < bhi) {
  4695.             queue.push([i + k, ahi, j + k, bhi]);
  4696.           }
  4697.         }
  4698.       }
  4699.       matchingBlocks.sort(_arrayCmp);
  4700.       i1 = j1 = k1 = 0;
  4701.       nonAdjacent = [];
  4702.       for (_i = 0, _len = matchingBlocks.length; _i < _len; _i++) {
  4703.         _ref3 = matchingBlocks[_i], i2 = _ref3[0], j2 = _ref3[1], k2 = _ref3[2];
  4704.         if (i1 + k1 === i2 && j1 + k1 === j2) {
  4705.           k1 += k2;
  4706.         } else {
  4707.           if (k1) {
  4708.             nonAdjacent.push([i1, j1, k1]);
  4709.           }
  4710.           _ref4 = [i2, j2, k2], i1 = _ref4[0], j1 = _ref4[1], k1 = _ref4[2];
  4711.         }
  4712.       }
  4713.       if (k1) {
  4714.         nonAdjacent.push([i1, j1, k1]);
  4715.       }
  4716.       nonAdjacent.push([la, lb, 0]);
  4717.       return this.matchingBlocks = nonAdjacent;
  4718.     };
  4719.  
  4720.     SequenceMatcher.prototype.getOpcodes = function() {
  4721.       /* 
  4722.       Return list of 5-tuples describing how to turn a into b.
  4723.       
  4724.       Each tuple is of the form [tag, i1, i2, j1, j2].  The first tuple
  4725.       has i1 == j1 == 0, and remaining tuples have i1 == the i2 from the
  4726.       tuple preceding it, and likewise for j1 == the previous j2.
  4727.       
  4728.       The tags are strings, with these meanings:
  4729.       
  4730.       'replace':  a[i1...i2] should be replaced by b[j1...j2]
  4731.       'delete':   a[i1...i2] should be deleted.
  4732.                   Note that j1==j2 in this case.
  4733.       'insert':   b[j1...j2] should be inserted at a[i1...i1].
  4734.                   Note that i1==i2 in this case.
  4735.       'equal':    a[i1...i2] == b[j1...j2]
  4736.       
  4737.       >>> s = new SequenceMatcher(null, 'qabxcd', 'abycdf')
  4738.       >>> s.getOpcodes()
  4739.       [ [ 'delete'  , 0 , 1 , 0 , 0 ] ,
  4740.         [ 'equal'   , 1 , 3 , 0 , 2 ] ,
  4741.         [ 'replace' , 3 , 4 , 2 , 3 ] ,
  4742.         [ 'equal'   , 4 , 6 , 3 , 5 ] ,
  4743.         [ 'insert'  , 6 , 6 , 5 , 6 ] ]
  4744.       */
  4745.  
  4746.       var ai, answer, bj, i, j, size, tag, _i, _len, _ref, _ref1, _ref2;
  4747.       if (this.opcodes) {
  4748.         return this.opcodes;
  4749.       }
  4750.       i = j = 0;
  4751.       this.opcodes = answer = [];
  4752.       _ref = this.getMatchingBlocks();
  4753.       for (_i = 0, _len = _ref.length; _i < _len; _i++) {
  4754.         _ref1 = _ref[_i], ai = _ref1[0], bj = _ref1[1], size = _ref1[2];
  4755.         tag = '';
  4756.         if (i < ai && j < bj) {
  4757.           tag = 'replace';
  4758.         } else if (i < ai) {
  4759.           tag = 'delete';
  4760.         } else if (j < bj) {
  4761.           tag = 'insert';
  4762.         }
  4763.         if (tag) {
  4764.           answer.push([tag, i, ai, j, bj]);
  4765.         }
  4766.         _ref2 = [ai + size, bj + size], i = _ref2[0], j = _ref2[1];
  4767.         if (size) {
  4768.           answer.push(['equal', ai, i, bj, j]);
  4769.         }
  4770.       }
  4771.       return answer;
  4772.     };
  4773.  
  4774.     SequenceMatcher.prototype.getGroupedOpcodes = function(n) {
  4775.       var codes, group, groups, i1, i2, j1, j2, nn, tag, _i, _len, _ref, _ref1, _ref2, _ref3;
  4776.       if (n == null) {
  4777.         n = 3;
  4778.       }
  4779.       /* 
  4780.       Isolate change clusters by eliminating ranges with no changes.
  4781.       
  4782.       Return a list groups with upto n lines of context.
  4783.       Each group is in the same format as returned by get_opcodes().
  4784.       
  4785.       >>> a = [1...40].map(String)
  4786.       >>> b = a.slice()
  4787.       >>> b[8...8] = 'i'
  4788.       >>> b[20] += 'x'
  4789.       >>> b[23...28] = []
  4790.       >>> b[30] += 'y'
  4791.       >>> s = new SequenceMatcher(null, a, b)
  4792.       >>> s.getGroupedOpcodes()
  4793.       [ [ [ 'equal'  , 5 , 8  , 5 , 8 ],
  4794.           [ 'insert' , 8 , 8  , 8 , 9 ],
  4795.           [ 'equal'  , 8 , 11 , 9 , 12 ] ],
  4796.         [ [ 'equal'   , 16 , 19 , 17 , 20 ],
  4797.           [ 'replace' , 19 , 20 , 20 , 21 ],
  4798.           [ 'equal'   , 20 , 22 , 21 , 23 ],
  4799.           [ 'delete'  , 22 , 27 , 23 , 23 ],
  4800.           [ 'equal'   , 27 , 30 , 23 , 26 ] ],
  4801.         [ [ 'equal'   , 31 , 34 , 27 , 30 ],
  4802.           [ 'replace' , 34 , 35 , 30 , 31 ],
  4803.           [ 'equal'   , 35 , 38 , 31 , 34 ] ] ]
  4804.       */
  4805.  
  4806.       codes = this.getOpcodes();
  4807.       if (!codes.length) {
  4808.         codes = [['equal', 0, 1, 0, 1]];
  4809.       }
  4810.       if (codes[0][0] === 'equal') {
  4811.         _ref = codes[0], tag = _ref[0], i1 = _ref[1], i2 = _ref[2], j1 = _ref[3], j2 = _ref[4];
  4812.         codes[0] = [tag, max(i1, i2 - n), i2, max(j1, j2 - n), j2];
  4813.       }
  4814.       if (codes[codes.length - 1][0] === 'equal') {
  4815.         _ref1 = codes[codes.length - 1], tag = _ref1[0], i1 = _ref1[1], i2 = _ref1[2], j1 = _ref1[3], j2 = _ref1[4];
  4816.         codes[codes.length - 1] = [tag, i1, min(i2, i1 + n), j1, min(j2, j1 + n)];
  4817.       }
  4818.       nn = n + n;
  4819.       groups = [];
  4820.       group = [];
  4821.       for (_i = 0, _len = codes.length; _i < _len; _i++) {
  4822.         _ref2 = codes[_i], tag = _ref2[0], i1 = _ref2[1], i2 = _ref2[2], j1 = _ref2[3], j2 = _ref2[4];
  4823.         if (tag === 'equal' && i2 - i1 > nn) {
  4824.           group.push([tag, i1, min(i2, i1 + n), j1, min(j2, j1 + n)]);
  4825.           groups.push(group);
  4826.           group = [];
  4827.           _ref3 = [max(i1, i2 - n), max(j1, j2 - n)], i1 = _ref3[0], j1 = _ref3[1];
  4828.         }
  4829.         group.push([tag, i1, i2, j1, j2]);
  4830.       }
  4831.       if (group.length && !(group.length === 1 && group[0][0] === 'equal')) {
  4832.         groups.push(group);
  4833.       }
  4834.       return groups;
  4835.     };
  4836.  
  4837.     SequenceMatcher.prototype.ratio = function() {
  4838.       /*
  4839.           Return a measure of the sequences' similarity (float in [0,1]).
  4840.       
  4841.           Where T is the total number of elements in both sequences, and
  4842.           M is the number of matches, this is 2.0*M / T.
  4843.           Note that this is 1 if the sequences are identical, and 0 if
  4844.           they have nothing in common.
  4845.       
  4846.           .ratio() is expensive to compute if you haven't already computed
  4847.           .getMatchingBlocks() or .getOpcodes(), in which case you may
  4848.           want to try .quickRatio() or .realQuickRatio() first to get an
  4849.           upper bound.
  4850.           
  4851.           >>> s = new SequenceMatcher(null, 'abcd', 'bcde')
  4852.           >>> s.ratio()
  4853.           0.75
  4854.           >>> s.quickRatio()
  4855.           0.75
  4856.           >>> s.realQuickRatio()
  4857.           1.0
  4858.       */
  4859.  
  4860.       var match, matches, _i, _len, _ref;
  4861.       matches = 0;
  4862.       _ref = this.getMatchingBlocks();
  4863.       for (_i = 0, _len = _ref.length; _i < _len; _i++) {
  4864.         match = _ref[_i];
  4865.         matches += match[2];
  4866.       }
  4867.       return _calculateRatio(matches, this.a.length + this.b.length);
  4868.     };
  4869.  
  4870.     SequenceMatcher.prototype.quickRatio = function() {
  4871.       /*
  4872.           Return an upper bound on ratio() relatively quickly.
  4873.       
  4874.           This isn't defined beyond that it is an upper bound on .ratio(), and
  4875.           is faster to compute.
  4876.       */
  4877.  
  4878.       var avail, elt, fullbcount, matches, numb, _i, _j, _len, _len1, _ref, _ref1;
  4879.       if (!this.fullbcount) {
  4880.         this.fullbcount = fullbcount = {};
  4881.         _ref = this.b;
  4882.         for (_i = 0, _len = _ref.length; _i < _len; _i++) {
  4883.           elt = _ref[_i];
  4884.           fullbcount[elt] = (fullbcount[elt] || 0) + 1;
  4885.         }
  4886.       }
  4887.       fullbcount = this.fullbcount;
  4888.       avail = {};
  4889.       matches = 0;
  4890.       _ref1 = this.a;
  4891.       for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
  4892.         elt = _ref1[_j];
  4893.         if (_has(avail, elt)) {
  4894.           numb = avail[elt];
  4895.         } else {
  4896.           numb = fullbcount[elt] || 0;
  4897.         }
  4898.         avail[elt] = numb - 1;
  4899.         if (numb > 0) {
  4900.           matches++;
  4901.         }
  4902.       }
  4903.       return _calculateRatio(matches, this.a.length + this.b.length);
  4904.     };
  4905.  
  4906.     SequenceMatcher.prototype.realQuickRatio = function() {
  4907.       /*
  4908.           Return an upper bound on ratio() very quickly.
  4909.       
  4910.           This isn't defined beyond that it is an upper bound on .ratio(), and
  4911.           is faster to compute than either .ratio() or .quickRatio().
  4912.       */
  4913.  
  4914.       var la, lb, _ref;
  4915.       _ref = [this.a.length, this.b.length], la = _ref[0], lb = _ref[1];
  4916.       return _calculateRatio(min(la, lb), la + lb);
  4917.     };
  4918.  
  4919.     return SequenceMatcher;
  4920.  
  4921.   })();
  4922.  
  4923.   getCloseMatches = function(word, possibilities, n, cutoff) {
  4924.     var result, s, score, x, _i, _j, _len, _len1, _ref, _results;
  4925.     if (n == null) {
  4926.       n = 3;
  4927.     }
  4928.     if (cutoff == null) {
  4929.       cutoff = 0.6;
  4930.     }
  4931.     /*
  4932.       Use SequenceMatcher to return list of the best "good enough" matches.
  4933.     
  4934.       word is a sequence for which close matches are desired (typically a
  4935.       string).
  4936.     
  4937.       possibilities is a list of sequences against which to match word
  4938.       (typically a list of strings).
  4939.     
  4940.       Optional arg n (default 3) is the maximum number of close matches to
  4941.       return.  n must be > 0.
  4942.     
  4943.       Optional arg cutoff (default 0.6) is a float in [0, 1].  Possibilities
  4944.       that don't score at least that similar to word are ignored.
  4945.     
  4946.       The best (no more than n) matches among the possibilities are returned
  4947.       in a list, sorted by similarity score, most similar first.
  4948.     
  4949.       >>> getCloseMatches('appel', ['ape', 'apple', 'peach', 'puppy'])
  4950.       ['apple', 'ape']
  4951.       >>> KEYWORDS = require('coffee-script').RESERVED
  4952.       >>> getCloseMatches('wheel', KEYWORDS)
  4953.       ['when', 'while']
  4954.       >>> getCloseMatches('accost', KEYWORDS)
  4955.       ['const']
  4956.     */
  4957.  
  4958.     if (!(n > 0)) {
  4959.       throw new Error("n must be > 0: (" + n + ")");
  4960.     }
  4961.     if (!((0.0 <= cutoff && cutoff <= 1.0))) {
  4962.       throw new Error("cutoff must be in [0.0, 1.0]: (" + cutoff + ")");
  4963.     }
  4964.     result = [];
  4965.     s = new SequenceMatcher();
  4966.     s.setSeq2(word);
  4967.     for (_i = 0, _len = possibilities.length; _i < _len; _i++) {
  4968.       x = possibilities[_i];
  4969.       s.setSeq1(x);
  4970.       if (s.realQuickRatio() >= cutoff && s.quickRatio() >= cutoff && s.ratio() >= cutoff) {
  4971.         result.push([s.ratio(), x]);
  4972.       }
  4973.     }
  4974.     result = Heap.nlargest(result, n, _arrayCmp);
  4975.     _results = [];
  4976.     for (_j = 0, _len1 = result.length; _j < _len1; _j++) {
  4977.       _ref = result[_j], score = _ref[0], x = _ref[1];
  4978.       _results.push(x);
  4979.     }
  4980.     return _results;
  4981.   };
  4982.  
  4983.   _countLeading = function(line, ch) {
  4984.     /*
  4985.       Return number of `ch` characters at the start of `line`.
  4986.     
  4987.       >>> _countLeading('   abc', ' ')
  4988.       3
  4989.     */
  4990.  
  4991.     var i, n, _ref;
  4992.     _ref = [0, line.length], i = _ref[0], n = _ref[1];
  4993.     while (i < n && line[i] === ch) {
  4994.       i++;
  4995.     }
  4996.     return i;
  4997.   };
  4998.  
  4999.   Differ = (function() {
  5000.  
  5001.     Differ.name = 'Differ';
  5002.  
  5003.     /*
  5004.       Differ is a class for comparing sequences of lines of text, and
  5005.       producing human-readable differences or deltas.  Differ uses
  5006.       SequenceMatcher both to compare sequences of lines, and to compare
  5007.       sequences of characters within similar (near-matching) lines.
  5008.     
  5009.       Each line of a Differ delta begins with a two-letter code:
  5010.     
  5011.           '- '    line unique to sequence 1
  5012.           '+ '    line unique to sequence 2
  5013.           '  '    line common to both sequences
  5014.           '? '    line not present in either input sequence
  5015.     
  5016.       Lines beginning with '? ' attempt to guide the eye to intraline
  5017.       differences, and were not present in either input sequence.  These lines
  5018.       can be confusing if the sequences contain tab characters.
  5019.     
  5020.       Note that Differ makes no claim to produce a *minimal* diff.  To the
  5021.       contrary, minimal diffs are often counter-intuitive, because they synch
  5022.       up anywhere possible, sometimes accidental matches 100 pages apart.
  5023.       Restricting synch points to contiguous matches preserves some notion of
  5024.       locality, at the occasional cost of producing a longer diff.
  5025.     
  5026.       Example: Comparing two texts.
  5027.     
  5028.       >>> text1 = ['1. Beautiful is better than ugly.\n',
  5029.       ...   '2. Explicit is better than implicit.\n',
  5030.       ...   '3. Simple is better than complex.\n',
  5031.       ...   '4. Complex is better than complicated.\n']
  5032.       >>> text1.length
  5033.       4
  5034.       >>> text2 = ['1. Beautiful is better than ugly.\n',
  5035.       ...   '3.   Simple is better than complex.\n',
  5036.       ...   '4. Complicated is better than complex.\n',
  5037.       ...   '5. Flat is better than nested.\n']
  5038.     
  5039.       Next we instantiate a Differ object:
  5040.     
  5041.       >>> d = new Differ()
  5042.     
  5043.       Note that when instantiating a Differ object we may pass functions to
  5044.       filter out line and character 'junk'.
  5045.     
  5046.       Finally, we compare the two:
  5047.     
  5048.       >>> result = d.compare(text1, text2)
  5049.       [ '  1. Beautiful is better than ugly.\n',
  5050.         '- 2. Explicit is better than implicit.\n',
  5051.         '- 3. Simple is better than complex.\n',
  5052.         '+ 3.   Simple is better than complex.\n',
  5053.         '?   ++\n',
  5054.         '- 4. Complex is better than complicated.\n',
  5055.         '?          ^                     ---- ^\n',
  5056.         '+ 4. Complicated is better than complex.\n',
  5057.         '?         ++++ ^                      ^\n',
  5058.         '+ 5. Flat is better than nested.\n' ]
  5059.     
  5060.       Methods:
  5061.     
  5062.       constructor(linejunk=null, charjunk=null)
  5063.           Construct a text differencer, with optional filters.
  5064.       compare(a, b)
  5065.           Compare two sequences of lines; generate the resulting delta.
  5066.     */
  5067.  
  5068.  
  5069.     function Differ(linejunk, charjunk) {
  5070.       this.linejunk = linejunk;
  5071.       this.charjunk = charjunk;
  5072.       /*
  5073.           Construct a text differencer, with optional filters.
  5074.       
  5075.           The two optional keyword parameters are for filter functions:
  5076.       
  5077.           - `linejunk`: A function that should accept a single string argument,
  5078.             and return true iff the string is junk. The module-level function
  5079.             `IS_LINE_JUNK` may be used to filter out lines without visible
  5080.             characters, except for at most one splat ('#').  It is recommended
  5081.             to leave linejunk null. 
  5082.       
  5083.           - `charjunk`: A function that should accept a string of length 1. The
  5084.             module-level function `IS_CHARACTER_JUNK` may be used to filter out
  5085.             whitespace characters (a blank or tab; **note**: bad idea to include
  5086.             newline in this!).  Use of IS_CHARACTER_JUNK is recommended.
  5087.       */
  5088.  
  5089.     }
  5090.  
  5091.     Differ.prototype.compare = function(a, b) {
  5092.       /*
  5093.           Compare two sequences of lines; generate the resulting delta.
  5094.       
  5095.           Each sequence must contain individual single-line strings ending with
  5096.           newlines. Such sequences can be obtained from the `readlines()` method
  5097.           of file-like objects.  The delta generated also consists of newline-
  5098.           terminated strings, ready to be printed as-is via the writeline()
  5099.           method of a file-like object.
  5100.       
  5101.           Example:
  5102.       
  5103.           >>> d = new Differ
  5104.           >>> d.compare(['one\n', 'two\n', 'three\n'],
  5105.           ...           ['ore\n', 'tree\n', 'emu\n'])
  5106.           [ '- one\n',
  5107.             '?  ^\n',
  5108.             '+ ore\n',
  5109.             '?  ^\n',
  5110.             '- two\n',
  5111.             '- three\n',
  5112.             '?  -\n',
  5113.             '+ tree\n',
  5114.             '+ emu\n' ]
  5115.       */
  5116.  
  5117.       var ahi, alo, bhi, blo, cruncher, g, line, lines, tag, _i, _j, _len, _len1, _ref, _ref1;
  5118.       cruncher = new SequenceMatcher(this.linejunk, a, b);
  5119.       lines = [];
  5120.       _ref = cruncher.getOpcodes();
  5121.       for (_i = 0, _len = _ref.length; _i < _len; _i++) {
  5122.         _ref1 = _ref[_i], tag = _ref1[0], alo = _ref1[1], ahi = _ref1[2], blo = _ref1[3], bhi = _ref1[4];
  5123.         switch (tag) {
  5124.           case 'replace':
  5125.             g = this._fancyReplace(a, alo, ahi, b, blo, bhi);
  5126.             break;
  5127.           case 'delete':
  5128.             g = this._dump('-', a, alo, ahi);
  5129.             break;
  5130.           case 'insert':
  5131.             g = this._dump('+', b, blo, bhi);
  5132.             break;
  5133.           case 'equal':
  5134.             g = this._dump(' ', a, alo, ahi);
  5135.             break;
  5136.           default:
  5137.             throw new Error("unknow tag (" + tag + ")");
  5138.         }
  5139.         for (_j = 0, _len1 = g.length; _j < _len1; _j++) {
  5140.           line = g[_j];
  5141.           lines.push(line);
  5142.         }
  5143.       }
  5144.       return lines;
  5145.     };
  5146.  
  5147.     Differ.prototype._dump = function(tag, x, lo, hi) {
  5148.       /*
  5149.           Generate comparison results for a same-tagged range.
  5150.       */
  5151.  
  5152.       var i, _i, _results;
  5153.       _results = [];
  5154.       for (i = _i = lo; lo <= hi ? _i < hi : _i > hi; i = lo <= hi ? ++_i : --_i) {
  5155.         _results.push("" + tag + " " + x[i]);
  5156.       }
  5157.       return _results;
  5158.     };
  5159.  
  5160.     Differ.prototype._plainReplace = function(a, alo, ahi, b, blo, bhi) {
  5161.       var first, g, line, lines, second, _i, _j, _len, _len1, _ref;
  5162.       assert(alo < ahi && blo < bhi);
  5163.       if (bhi - blo < ahi - alo) {
  5164.         first = this._dump('+', b, blo, bhi);
  5165.         second = this._dump('-', a, alo, ahi);
  5166.       } else {
  5167.         first = this._dump('-', a, alo, ahi);
  5168.         second = this._dump('+', b, blo, bhi);
  5169.       }
  5170.       lines = [];
  5171.       _ref = [first, second];
  5172.       for (_i = 0, _len = _ref.length; _i < _len; _i++) {
  5173.         g = _ref[_i];
  5174.         for (_j = 0, _len1 = g.length; _j < _len1; _j++) {
  5175.           line = g[_j];
  5176.           lines.push(line);
  5177.         }
  5178.       }
  5179.       return lines;
  5180.     };
  5181.  
  5182.     Differ.prototype._fancyReplace = function(a, alo, ahi, b, blo, bhi) {
  5183.       /*
  5184.           When replacing one block of lines with another, search the blocks
  5185.           for *similar* lines; the best-matching pair (if any) is used as a
  5186.           synch point, and intraline difference marking is done on the
  5187.           similar pair. Lots of work, but often worth it.
  5188.       
  5189.           Example:
  5190.           >>> d = new Differ
  5191.           >>> d._fancyReplace(['abcDefghiJkl\n'], 0, 1,
  5192.           ...                 ['abcdefGhijkl\n'], 0, 1)
  5193.           [ '- abcDefghiJkl\n',
  5194.             '?    ^  ^  ^\n',
  5195.             '+ abcdefGhijkl\n',
  5196.             '?    ^  ^  ^\n' ]
  5197.       */
  5198.  
  5199.       var aelt, ai, ai1, ai2, atags, belt, bestRatio, besti, bestj, bj, bj1, bj2, btags, cruncher, cutoff, eqi, eqj, i, j, la, lb, line, lines, tag, _i, _j, _k, _l, _len, _len1, _len2, _len3, _len4, _m, _n, _o, _ref, _ref1, _ref10, _ref11, _ref12, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7, _ref8, _ref9;
  5200.       _ref = [0.74, 0.75], bestRatio = _ref[0], cutoff = _ref[1];
  5201.       cruncher = new SequenceMatcher(this.charjunk);
  5202.       _ref1 = [null, null], eqi = _ref1[0], eqj = _ref1[1];
  5203.       lines = [];
  5204.       for (j = _i = blo; blo <= bhi ? _i < bhi : _i > bhi; j = blo <= bhi ? ++_i : --_i) {
  5205.         bj = b[j];
  5206.         cruncher.setSeq2(bj);
  5207.         for (i = _j = alo; alo <= ahi ? _j < ahi : _j > ahi; i = alo <= ahi ? ++_j : --_j) {
  5208.           ai = a[i];
  5209.           if (ai === bj) {
  5210.             if (eqi === null) {
  5211.               _ref2 = [i, j], eqi = _ref2[0], eqj = _ref2[1];
  5212.             }
  5213.             continue;
  5214.           }
  5215.           cruncher.setSeq1(ai);
  5216.           if (cruncher.realQuickRatio() > bestRatio && cruncher.quickRatio() > bestRatio && cruncher.ratio() > bestRatio) {
  5217.             _ref3 = [cruncher.ratio(), i, j], bestRatio = _ref3[0], besti = _ref3[1], bestj = _ref3[2];
  5218.           }
  5219.         }
  5220.       }
  5221.       if (bestRatio < cutoff) {
  5222.         if (eqi === null) {
  5223.           _ref4 = this._plainReplace(a, alo, ahi, b, blo, bhi);
  5224.           for (_k = 0, _len = _ref4.length; _k < _len; _k++) {
  5225.             line = _ref4[_k];
  5226.             lines.push(line);
  5227.           }
  5228.           return lines;
  5229.         }
  5230.         _ref5 = [eqi, eqj, 1.0], besti = _ref5[0], bestj = _ref5[1], bestRatio = _ref5[2];
  5231.       } else {
  5232.         eqi = null;
  5233.       }
  5234.       _ref6 = this._fancyHelper(a, alo, besti, b, blo, bestj);
  5235.       for (_l = 0, _len1 = _ref6.length; _l < _len1; _l++) {
  5236.         line = _ref6[_l];
  5237.         lines.push(line);
  5238.       }
  5239.       _ref7 = [a[besti], b[bestj]], aelt = _ref7[0], belt = _ref7[1];
  5240.       if (eqi === null) {
  5241.         atags = btags = '';
  5242.         cruncher.setSeqs(aelt, belt);
  5243.         _ref8 = cruncher.getOpcodes();
  5244.         for (_m = 0, _len2 = _ref8.length; _m < _len2; _m++) {
  5245.           _ref9 = _ref8[_m], tag = _ref9[0], ai1 = _ref9[1], ai2 = _ref9[2], bj1 = _ref9[3], bj2 = _ref9[4];
  5246.           _ref10 = [ai2 - ai1, bj2 - bj1], la = _ref10[0], lb = _ref10[1];
  5247.           switch (tag) {
  5248.             case 'replace':
  5249.               atags += Array(la + 1).join('^');
  5250.               btags += Array(lb + 1).join('^');
  5251.               break;
  5252.             case 'delete':
  5253.               atags += Array(la + 1).join('-');
  5254.               break;
  5255.             case 'insert':
  5256.               btags += Array(lb + 1).join('+');
  5257.               break;
  5258.             case 'equal':
  5259.               atags += Array(la + 1).join(' ');
  5260.               btags += Array(lb + 1).join(' ');
  5261.               break;
  5262.             default:
  5263.               throw new Error("unknow tag (" + tag + ")");
  5264.           }
  5265.         }
  5266.         _ref11 = this._qformat(aelt, belt, atags, btags);
  5267.         for (_n = 0, _len3 = _ref11.length; _n < _len3; _n++) {
  5268.           line = _ref11[_n];
  5269.           lines.push(line);
  5270.         }
  5271.       } else {
  5272.         lines.push('  ' + aelt);
  5273.       }
  5274.       _ref12 = this._fancyHelper(a, besti + 1, ahi, b, bestj + 1, bhi);
  5275.       for (_o = 0, _len4 = _ref12.length; _o < _len4; _o++) {
  5276.         line = _ref12[_o];
  5277.         lines.push(line);
  5278.       }
  5279.       return lines;
  5280.     };
  5281.  
  5282.     Differ.prototype._fancyHelper = function(a, alo, ahi, b, blo, bhi) {
  5283.       var g;
  5284.       g = [];
  5285.       if (alo < ahi) {
  5286.         if (blo < bhi) {
  5287.           g = this._fancyReplace(a, alo, ahi, b, blo, bhi);
  5288.         } else {
  5289.           g = this._dump('-', a, alo, ahi);
  5290.         }
  5291.       } else if (blo < bhi) {
  5292.         g = this._dump('+', b, blo, bhi);
  5293.       }
  5294.       return g;
  5295.     };
  5296.  
  5297.     Differ.prototype._qformat = function(aline, bline, atags, btags) {
  5298.       /*
  5299.           Format "?" output and deal with leading tabs.
  5300.       
  5301.           Example:
  5302.       
  5303.           >>> d = new Differ
  5304.           >>> d._qformat('\tabcDefghiJkl\n', '\tabcdefGhijkl\n',
  5305.           [ '- \tabcDefghiJkl\n',
  5306.             '? \t ^ ^  ^\n',
  5307.             '+ \tabcdefGhijkl\n',
  5308.             '? \t ^ ^  ^\n' ]
  5309.       */
  5310.  
  5311.       var common, lines;
  5312.       lines = [];
  5313.       common = min(_countLeading(aline, '\t'), _countLeading(bline, '\t'));
  5314.       common = min(common, _countLeading(atags.slice(0, common), ' '));
  5315.       common = min(common, _countLeading(btags.slice(0, common), ' '));
  5316.       atags = atags.slice(common).replace(/\s+$/, '');
  5317.       btags = btags.slice(common).replace(/\s+$/, '');
  5318.       lines.push('- ' + aline);
  5319.       if (atags.length) {
  5320.         lines.push("? " + (Array(common + 1).join('\t')) + atags + "\n");
  5321.       }
  5322.       lines.push('+ ' + bline);
  5323.       if (btags.length) {
  5324.         lines.push("? " + (Array(common + 1).join('\t')) + btags + "\n");
  5325.       }
  5326.       return lines;
  5327.     };
  5328.  
  5329.     return Differ;
  5330.  
  5331.   })();
  5332.  
  5333.   IS_LINE_JUNK = function(line, pat) {
  5334.     if (pat == null) {
  5335.       pat = /^\s*#?\s*$/;
  5336.     }
  5337.     /*
  5338.       Return 1 for ignorable line: iff `line` is blank or contains a single '#'.
  5339.         
  5340.       Examples:
  5341.     
  5342.       >>> IS_LINE_JUNK('\n')
  5343.       true
  5344.       >>> IS_LINE_JUNK('  #   \n')
  5345.       true
  5346.       >>> IS_LINE_JUNK('hello\n')
  5347.       false
  5348.     */
  5349.  
  5350.     return pat.test(line);
  5351.   };
  5352.  
  5353.   IS_CHARACTER_JUNK = function(ch, ws) {
  5354.     if (ws == null) {
  5355.       ws = ' \t';
  5356.     }
  5357.     /*
  5358.       Return 1 for ignorable character: iff `ch` is a space or tab.
  5359.     
  5360.       Examples:
  5361.       >>> IS_CHARACTER_JUNK(' ').should.be.true
  5362.       true
  5363.       >>> IS_CHARACTER_JUNK('\t').should.be.true
  5364.       true
  5365.       >>> IS_CHARACTER_JUNK('\n').should.be.false
  5366.       false
  5367.       >>> IS_CHARACTER_JUNK('x').should.be.false
  5368.       false
  5369.     */
  5370.  
  5371.     return __indexOf.call(ws, ch) >= 0;
  5372.   };
  5373.  
  5374.   _formatRangeUnified = function(start, stop) {
  5375.     /*
  5376.       Convert range to the "ed" format'
  5377.     */
  5378.  
  5379.     var beginning, length;
  5380.     beginning = start + 1;
  5381.     length = stop - start;
  5382.     if (length === 1) {
  5383.       return "" + beginning;
  5384.     }
  5385.     if (!length) {
  5386.       beginning--;
  5387.     }
  5388.     return "" + beginning + "," + length;
  5389.   };
  5390.  
  5391.   unifiedDiff = function(a, b, _arg) {
  5392.     var file1Range, file2Range, first, fromdate, fromfile, fromfiledate, group, i1, i2, j1, j2, last, line, lines, lineterm, n, started, tag, todate, tofile, tofiledate, _i, _j, _k, _l, _len, _len1, _len2, _len3, _len4, _m, _ref, _ref1, _ref2, _ref3, _ref4, _ref5, _ref6;
  5393.     _ref = _arg != null ? _arg : {}, fromfile = _ref.fromfile, tofile = _ref.tofile, fromfiledate = _ref.fromfiledate, tofiledate = _ref.tofiledate, n = _ref.n, lineterm = _ref.lineterm;
  5394.     /*
  5395.       Compare two sequences of lines; generate the delta as a unified diff.
  5396.     
  5397.       Unified diffs are a compact way of showing line changes and a few
  5398.       lines of context.  The number of context lines is set by 'n' which
  5399.       defaults to three.
  5400.     
  5401.       By default, the diff control lines (those with ---, +++, or @@) are
  5402.       created with a trailing newline.  
  5403.     
  5404.       For inputs that do not have trailing newlines, set the lineterm
  5405.       argument to "" so that the output will be uniformly newline free.
  5406.     
  5407.       The unidiff format normally has a header for filenames and modification
  5408.       times.  Any or all of these may be specified using strings for
  5409.       'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'.
  5410.       The modification times are normally expressed in the ISO 8601 format.
  5411.     
  5412.       Example:
  5413.     
  5414.       >>> unifiedDiff('one two three four'.split(' '),
  5415.       ...             'zero one tree four'.split(' '), {
  5416.       ...               fromfile: 'Original'
  5417.       ...               tofile: 'Current',
  5418.       ...               fromfiledate: '2005-01-26 23:30:50',
  5419.       ...               tofiledate: '2010-04-02 10:20:52',
  5420.       ...               lineterm: ''
  5421.       ...             })
  5422.       [ '--- Original\t2005-01-26 23:30:50',
  5423.         '+++ Current\t2010-04-02 10:20:52',
  5424.         '@@ -1,4 +1,4 @@',
  5425.         '+zero',
  5426.         ' one',
  5427.         '-two',
  5428.         '-three',
  5429.         '+tree',
  5430.         ' four' ]
  5431.     */
  5432.  
  5433.     if (fromfile == null) {
  5434.       fromfile = '';
  5435.     }
  5436.     if (tofile == null) {
  5437.       tofile = '';
  5438.     }
  5439.     if (fromfiledate == null) {
  5440.       fromfiledate = '';
  5441.     }
  5442.     if (tofiledate == null) {
  5443.       tofiledate = '';
  5444.     }
  5445.     if (n == null) {
  5446.       n = 3;
  5447.     }
  5448.     if (lineterm == null) {
  5449.       lineterm = '\n';
  5450.     }
  5451.     lines = [];
  5452.     started = false;
  5453.     _ref1 = (new SequenceMatcher(null, a, b)).getGroupedOpcodes();
  5454.     for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
  5455.       group = _ref1[_i];
  5456.       if (!started) {
  5457.         started = true;
  5458.         fromdate = fromfiledate ? "\t" + fromfiledate : '';
  5459.         todate = tofiledate ? "\t" + tofiledate : '';
  5460.         lines.push("--- " + fromfile + fromdate + lineterm);
  5461.         lines.push("+++ " + tofile + todate + lineterm);
  5462.       }
  5463.       _ref2 = [group[0], group[group.length - 1]], first = _ref2[0], last = _ref2[1];
  5464.       file1Range = _formatRangeUnified(first[1], last[2]);
  5465.       file2Range = _formatRangeUnified(first[3], last[4]);
  5466.       lines.push("@@ -" + file1Range + " +" + file2Range + " @@" + lineterm);
  5467.       for (_j = 0, _len1 = group.length; _j < _len1; _j++) {
  5468.         _ref3 = group[_j], tag = _ref3[0], i1 = _ref3[1], i2 = _ref3[2], j1 = _ref3[3], j2 = _ref3[4];
  5469.         if (tag === 'equal') {
  5470.           _ref4 = a.slice(i1, i2);
  5471.           for (_k = 0, _len2 = _ref4.length; _k < _len2; _k++) {
  5472.             line = _ref4[_k];
  5473.             lines.push(' ' + line);
  5474.           }
  5475.           continue;
  5476.         }
  5477.         if (tag === 'replace' || tag === 'delete') {
  5478.           _ref5 = a.slice(i1, i2);
  5479.           for (_l = 0, _len3 = _ref5.length; _l < _len3; _l++) {
  5480.             line = _ref5[_l];
  5481.             lines.push('-' + line);
  5482.           }
  5483.         }
  5484.         if (tag === 'replace' || tag === 'insert') {
  5485.           _ref6 = b.slice(j1, j2);
  5486.           for (_m = 0, _len4 = _ref6.length; _m < _len4; _m++) {
  5487.             line = _ref6[_m];
  5488.             lines.push('+' + line);
  5489.           }
  5490.         }
  5491.       }
  5492.     }
  5493.     return lines;
  5494.   };
  5495.  
  5496.   _formatRangeContext = function(start, stop) {
  5497.     /*
  5498.       Convert range to the "ed" format'
  5499.     */
  5500.  
  5501.     var beginning, length;
  5502.     beginning = start + 1;
  5503.     length = stop - start;
  5504.     if (!length) {
  5505.       beginning--;
  5506.     }
  5507.     if (length <= 1) {
  5508.       return "" + beginning;
  5509.     }
  5510.     return "" + beginning + "," + (beginning + length - 1);
  5511.   };
  5512.  
  5513.   contextDiff = function(a, b, _arg) {
  5514.     var file1Range, file2Range, first, fromdate, fromfile, fromfiledate, group, i1, i2, j1, j2, last, line, lines, lineterm, n, prefix, started, tag, todate, tofile, tofiledate, _, _i, _j, _k, _l, _len, _len1, _len2, _len3, _len4, _m, _ref, _ref1, _ref2, _ref3, _ref4, _ref5, _ref6;
  5515.     _ref = _arg != null ? _arg : {}, fromfile = _ref.fromfile, tofile = _ref.tofile, fromfiledate = _ref.fromfiledate, tofiledate = _ref.tofiledate, n = _ref.n, lineterm = _ref.lineterm;
  5516.     /*
  5517.       Compare two sequences of lines; generate the delta as a context diff.
  5518.     
  5519.       Context diffs are a compact way of showing line changes and a few
  5520.       lines of context.  The number of context lines is set by 'n' which
  5521.       defaults to three.
  5522.     
  5523.       By default, the diff control lines (those with *** or ---) are
  5524.       created with a trailing newline.  This is helpful so that inputs
  5525.       created from file.readlines() result in diffs that are suitable for
  5526.       file.writelines() since both the inputs and outputs have trailing
  5527.       newlines.
  5528.     
  5529.       For inputs that do not have trailing newlines, set the lineterm
  5530.       argument to "" so that the output will be uniformly newline free.
  5531.     
  5532.       The context diff format normally has a header for filenames and
  5533.       modification times.  Any or all of these may be specified using
  5534.       strings for 'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'.
  5535.       The modification times are normally expressed in the ISO 8601 format.
  5536.       If not specified, the strings default to blanks.
  5537.     
  5538.       Example:
  5539.       >>> a = ['one\n', 'two\n', 'three\n', 'four\n']
  5540.       >>> b = ['zero\n', 'one\n', 'tree\n', 'four\n']
  5541.       >>> contextDiff(a, b, {fromfile: 'Original', tofile: 'Current'})
  5542.       [ '*** Original\n',
  5543.         '--- Current\n',
  5544.         '***************\n',
  5545.         '*** 1,4 ****\n',
  5546.         '  one\n',
  5547.         '! two\n',
  5548.         '! three\n',
  5549.         '  four\n',
  5550.         '--- 1,4 ----\n',
  5551.         '+ zero\n',
  5552.         '  one\n',
  5553.         '! tree\n',
  5554.         '  four\n' ]
  5555.     */
  5556.  
  5557.     if (fromfile == null) {
  5558.       fromfile = '';
  5559.     }
  5560.     if (tofile == null) {
  5561.       tofile = '';
  5562.     }
  5563.     if (fromfiledate == null) {
  5564.       fromfiledate = '';
  5565.     }
  5566.     if (tofiledate == null) {
  5567.       tofiledate = '';
  5568.     }
  5569.     if (n == null) {
  5570.       n = 3;
  5571.     }
  5572.     if (lineterm == null) {
  5573.       lineterm = '\n';
  5574.     }
  5575.     prefix = {
  5576.       insert: '+ ',
  5577.       "delete": '- ',
  5578.       replace: '! ',
  5579.       equal: '  '
  5580.     };
  5581.     started = false;
  5582.     lines = [];
  5583.     _ref1 = (new SequenceMatcher(null, a, b)).getGroupedOpcodes();
  5584.     for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
  5585.       group = _ref1[_i];
  5586.       if (!started) {
  5587.         started = true;
  5588.         fromdate = fromfiledate ? "\t" + fromfiledate : '';
  5589.         todate = tofiledate ? "\t" + tofiledate : '';
  5590.         lines.push("*** " + fromfile + fromdate + lineterm);
  5591.         lines.push("--- " + tofile + todate + lineterm);
  5592.         _ref2 = [group[0], group[group.length - 1]], first = _ref2[0], last = _ref2[1];
  5593.         lines.push('***************' + lineterm);
  5594.         file1Range = _formatRangeContext(first[1], last[2]);
  5595.         lines.push("*** " + file1Range + " ****" + lineterm);
  5596.         if (_any((function() {
  5597.           var _j, _len1, _ref3, _results;
  5598.           _results = [];
  5599.           for (_j = 0, _len1 = group.length; _j < _len1; _j++) {
  5600.             _ref3 = group[_j], tag = _ref3[0], _ = _ref3[1], _ = _ref3[2], _ = _ref3[3], _ = _ref3[4];
  5601.             _results.push(tag === 'replace' || tag === 'delete');
  5602.           }
  5603.           return _results;
  5604.         })())) {
  5605.           for (_j = 0, _len1 = group.length; _j < _len1; _j++) {
  5606.             _ref3 = group[_j], tag = _ref3[0], i1 = _ref3[1], i2 = _ref3[2], _ = _ref3[3], _ = _ref3[4];
  5607.             if (tag !== 'insert') {
  5608.               _ref4 = a.slice(i1, i2);
  5609.               for (_k = 0, _len2 = _ref4.length; _k < _len2; _k++) {
  5610.                 line = _ref4[_k];
  5611.                 lines.push(prefix[tag] + line);
  5612.               }
  5613.             }
  5614.           }
  5615.         }
  5616.         file2Range = _formatRangeContext(first[3], last[4]);
  5617.         lines.push("--- " + file2Range + " ----" + lineterm);
  5618.         if (_any((function() {
  5619.           var _l, _len3, _ref5, _results;
  5620.           _results = [];
  5621.           for (_l = 0, _len3 = group.length; _l < _len3; _l++) {
  5622.             _ref5 = group[_l], tag = _ref5[0], _ = _ref5[1], _ = _ref5[2], _ = _ref5[3], _ = _ref5[4];
  5623.             _results.push(tag === 'replace' || tag === 'insert');
  5624.           }
  5625.           return _results;
  5626.         })())) {
  5627.           for (_l = 0, _len3 = group.length; _l < _len3; _l++) {
  5628.             _ref5 = group[_l], tag = _ref5[0], _ = _ref5[1], _ = _ref5[2], j1 = _ref5[3], j2 = _ref5[4];
  5629.             if (tag !== 'delete') {
  5630.               _ref6 = b.slice(j1, j2);
  5631.               for (_m = 0, _len4 = _ref6.length; _m < _len4; _m++) {
  5632.                 line = _ref6[_m];
  5633.                 lines.push(prefix[tag] + line);
  5634.               }
  5635.             }
  5636.           }
  5637.         }
  5638.       }
  5639.     }
  5640.     return lines;
  5641.   };
  5642.  
  5643.   ndiff = function(a, b, linejunk, charjunk) {
  5644.     if (charjunk == null) {
  5645.       charjunk = IS_CHARACTER_JUNK;
  5646.     }
  5647.     /*
  5648.       Compare `a` and `b` (lists of strings); return a `Differ`-style delta.
  5649.     
  5650.       Optional keyword parameters `linejunk` and `charjunk` are for filter
  5651.       functions (or None):
  5652.     
  5653.       - linejunk: A function that should accept a single string argument, and
  5654.         return true iff the string is junk.  The default is null, and is
  5655.         recommended; 
  5656.     
  5657.       - charjunk: A function that should accept a string of length 1. The
  5658.         default is module-level function IS_CHARACTER_JUNK, which filters out
  5659.         whitespace characters (a blank or tab; note: bad idea to include newline
  5660.         in this!).
  5661.     
  5662.       Example:
  5663.       >>> a = ['one\n', 'two\n', 'three\n']
  5664.       >>> b = ['ore\n', 'tree\n', 'emu\n']
  5665.       >>> ndiff(a, b)
  5666.       [ '- one\n',
  5667.         '?  ^\n',
  5668.         '+ ore\n',
  5669.         '?  ^\n',
  5670.         '- two\n',
  5671.         '- three\n',
  5672.         '?  -\n',
  5673.         '+ tree\n',
  5674.         '+ emu\n' ]
  5675.     */
  5676.  
  5677.     return (new Differ(linejunk, charjunk)).compare(a, b);
  5678.   };
  5679.  
  5680.   restore = function(delta, which) {
  5681.     /*
  5682.       Generate one of the two sequences that generated a delta.
  5683.     
  5684.       Given a `delta` produced by `Differ.compare()` or `ndiff()`, extract
  5685.       lines originating from file 1 or 2 (parameter `which`), stripping off line
  5686.       prefixes.
  5687.     
  5688.       Examples:
  5689.       >>> a = ['one\n', 'two\n', 'three\n']
  5690.       >>> b = ['ore\n', 'tree\n', 'emu\n']
  5691.       >>> diff = ndiff(a, b)
  5692.       >>> restore(diff, 1)
  5693.       [ 'one\n',
  5694.         'two\n',
  5695.         'three\n' ]
  5696.       >>> restore(diff, 2)
  5697.       [ 'ore\n',
  5698.         'tree\n',
  5699.         'emu\n' ]
  5700.     */
  5701.  
  5702.     var line, lines, prefixes, tag, _i, _len, _ref;
  5703.     tag = {
  5704.       1: '- ',
  5705.       2: '+ '
  5706.     }[which];
  5707.     if (!tag) {
  5708.       throw new Error("unknow delta choice (must be 1 or 2): " + which);
  5709.     }
  5710.     prefixes = ['  ', tag];
  5711.     lines = [];
  5712.     for (_i = 0, _len = delta.length; _i < _len; _i++) {
  5713.       line = delta[_i];
  5714.       if (_ref = line.slice(0, 2), __indexOf.call(prefixes, _ref) >= 0) {
  5715.         lines.push(line.slice(2));
  5716.       }
  5717.     }
  5718.     return lines;
  5719.   };
  5720.  
  5721.   exports._arrayCmp = _arrayCmp;
  5722.  
  5723.   exports.SequenceMatcher = SequenceMatcher;
  5724.  
  5725.   exports.getCloseMatches = getCloseMatches;
  5726.  
  5727.   exports._countLeading = _countLeading;
  5728.  
  5729.   exports.Differ = Differ;
  5730.  
  5731.   exports.IS_LINE_JUNK = IS_LINE_JUNK;
  5732.  
  5733.   exports.IS_CHARACTER_JUNK = IS_CHARACTER_JUNK;
  5734.  
  5735.   exports._formatRangeUnified = _formatRangeUnified;
  5736.  
  5737.   exports.unifiedDiff = unifiedDiff;
  5738.  
  5739.   exports._formatRangeContext = _formatRangeContext;
  5740.  
  5741.   exports.contextDiff = contextDiff;
  5742.  
  5743.   exports.ndiff = ndiff;
  5744.  
  5745.   exports.restore = restore;
  5746.  
  5747. }).call(this);
  5748.  
  5749.  
  5750. /***/ }),
  5751.  
  5752. /***/ "v2jn":
  5753. /***/ (function(module, exports, __webpack_require__) {
  5754.  
  5755. /*!
  5756.  
  5757.  diff v4.0.1
  5758.  
  5759. Software License Agreement (BSD License)
  5760.  
  5761. Copyright (c) 2009-2015, Kevin Decker <kpdecker@gmail.com>
  5762.  
  5763. All rights reserved.
  5764.  
  5765. Redistribution and use of this software in source and binary forms, with or without modification,
  5766. are permitted provided that the following conditions are met:
  5767.  
  5768. * Redistributions of source code must retain the above
  5769.   copyright notice, this list of conditions and the
  5770.   following disclaimer.
  5771.  
  5772. * Redistributions in binary form must reproduce the above
  5773.   copyright notice, this list of conditions and the
  5774.   following disclaimer in the documentation and/or other
  5775.   materials provided with the distribution.
  5776.  
  5777. * Neither the name of Kevin Decker nor the names of its
  5778.   contributors may be used to endorse or promote products
  5779.   derived from this software without specific prior
  5780.   written permission.
  5781.  
  5782. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
  5783. IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  5784. FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  5785. CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  5786. DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  5787. DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  5788. IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  5789. OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  5790. @license
  5791. */
  5792. (function (global, factory) {
  5793.    true ? factory(exports) :
  5794.   undefined;
  5795. }(this, function (exports) { 'use strict';
  5796.  
  5797.   function Diff() {}
  5798.   Diff.prototype = {
  5799.     diff: function diff(oldString, newString) {
  5800.       var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
  5801.       var callback = options.callback;
  5802.  
  5803.       if (typeof options === 'function') {
  5804.         callback = options;
  5805.         options = {};
  5806.       }
  5807.  
  5808.       this.options = options;
  5809.       var self = this;
  5810.  
  5811.       function done(value) {
  5812.         if (callback) {
  5813.           setTimeout(function () {
  5814.             callback(undefined, value);
  5815.           }, 0);
  5816.           return true;
  5817.         } else {
  5818.           return value;
  5819.         }
  5820.       } // Allow subclasses to massage the input prior to running
  5821.  
  5822.  
  5823.       oldString = this.castInput(oldString);
  5824.       newString = this.castInput(newString);
  5825.       oldString = this.removeEmpty(this.tokenize(oldString));
  5826.       newString = this.removeEmpty(this.tokenize(newString));
  5827.       var newLen = newString.length,
  5828.           oldLen = oldString.length;
  5829.       var editLength = 1;
  5830.       var maxEditLength = newLen + oldLen;
  5831.       var bestPath = [{
  5832.         newPos: -1,
  5833.         components: []
  5834.       }]; // Seed editLength = 0, i.e. the content starts with the same values
  5835.  
  5836.       var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);
  5837.  
  5838.       if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) {
  5839.         // Identity per the equality and tokenizer
  5840.         return done([{
  5841.           value: this.join(newString),
  5842.           count: newString.length
  5843.         }]);
  5844.       } // Main worker method. checks all permutations of a given edit length for acceptance.
  5845.  
  5846.  
  5847.       function execEditLength() {
  5848.         for (var diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) {
  5849.           var basePath = void 0;
  5850.  
  5851.           var addPath = bestPath[diagonalPath - 1],
  5852.               removePath = bestPath[diagonalPath + 1],
  5853.               _oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;
  5854.  
  5855.           if (addPath) {
  5856.             // No one else is going to attempt to use this value, clear it
  5857.             bestPath[diagonalPath - 1] = undefined;
  5858.           }
  5859.  
  5860.           var canAdd = addPath && addPath.newPos + 1 < newLen,
  5861.               canRemove = removePath && 0 <= _oldPos && _oldPos < oldLen;
  5862.  
  5863.           if (!canAdd && !canRemove) {
  5864.             // If this path is a terminal then prune
  5865.             bestPath[diagonalPath] = undefined;
  5866.             continue;
  5867.           } // Select the diagonal that we want to branch from. We select the prior
  5868.           // path whose position in the new string is the farthest from the origin
  5869.           // and does not pass the bounds of the diff graph
  5870.  
  5871.  
  5872.           if (!canAdd || canRemove && addPath.newPos < removePath.newPos) {
  5873.             basePath = clonePath(removePath);
  5874.             self.pushComponent(basePath.components, undefined, true);
  5875.           } else {
  5876.             basePath = addPath; // No need to clone, we've pulled it from the list
  5877.  
  5878.             basePath.newPos++;
  5879.             self.pushComponent(basePath.components, true, undefined);
  5880.           }
  5881.  
  5882.           _oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath); // If we have hit the end of both strings, then we are done
  5883.  
  5884.           if (basePath.newPos + 1 >= newLen && _oldPos + 1 >= oldLen) {
  5885.             return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken));
  5886.           } else {
  5887.             // Otherwise track this path as a potential candidate and continue.
  5888.             bestPath[diagonalPath] = basePath;
  5889.           }
  5890.         }
  5891.  
  5892.         editLength++;
  5893.       } // Performs the length of edit iteration. Is a bit fugly as this has to support the
  5894.       // sync and async mode which is never fun. Loops over execEditLength until a value
  5895.       // is produced.
  5896.  
  5897.  
  5898.       if (callback) {
  5899.         (function exec() {
  5900.           setTimeout(function () {
  5901.             // This should not happen, but we want to be safe.
  5902.  
  5903.             /* istanbul ignore next */
  5904.             if (editLength > maxEditLength) {
  5905.               return callback();
  5906.             }
  5907.  
  5908.             if (!execEditLength()) {
  5909.               exec();
  5910.             }
  5911.           }, 0);
  5912.         })();
  5913.       } else {
  5914.         while (editLength <= maxEditLength) {
  5915.           var ret = execEditLength();
  5916.  
  5917.           if (ret) {
  5918.             return ret;
  5919.           }
  5920.         }
  5921.       }
  5922.     },
  5923.     pushComponent: function pushComponent(components, added, removed) {
  5924.       var last = components[components.length - 1];
  5925.  
  5926.       if (last && last.added === added && last.removed === removed) {
  5927.         // We need to clone here as the component clone operation is just
  5928.         // as shallow array clone
  5929.         components[components.length - 1] = {
  5930.           count: last.count + 1,
  5931.           added: added,
  5932.           removed: removed
  5933.         };
  5934.       } else {
  5935.         components.push({
  5936.           count: 1,
  5937.           added: added,
  5938.           removed: removed
  5939.         });
  5940.       }
  5941.     },
  5942.     extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) {
  5943.       var newLen = newString.length,
  5944.           oldLen = oldString.length,
  5945.           newPos = basePath.newPos,
  5946.           oldPos = newPos - diagonalPath,
  5947.           commonCount = 0;
  5948.  
  5949.       while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) {
  5950.         newPos++;
  5951.         oldPos++;
  5952.         commonCount++;
  5953.       }
  5954.  
  5955.       if (commonCount) {
  5956.         basePath.components.push({
  5957.           count: commonCount
  5958.         });
  5959.       }
  5960.  
  5961.       basePath.newPos = newPos;
  5962.       return oldPos;
  5963.     },
  5964.     equals: function equals(left, right) {
  5965.       if (this.options.comparator) {
  5966.         return this.options.comparator(left, right);
  5967.       } else {
  5968.         return left === right || this.options.ignoreCase && left.toLowerCase() === right.toLowerCase();
  5969.       }
  5970.     },
  5971.     removeEmpty: function removeEmpty(array) {
  5972.       var ret = [];
  5973.  
  5974.       for (var i = 0; i < array.length; i++) {
  5975.         if (array[i]) {
  5976.           ret.push(array[i]);
  5977.         }
  5978.       }
  5979.  
  5980.       return ret;
  5981.     },
  5982.     castInput: function castInput(value) {
  5983.       return value;
  5984.     },
  5985.     tokenize: function tokenize(value) {
  5986.       return value.split('');
  5987.     },
  5988.     join: function join(chars) {
  5989.       return chars.join('');
  5990.     }
  5991.   };
  5992.  
  5993.   function buildValues(diff, components, newString, oldString, useLongestToken) {
  5994.     var componentPos = 0,
  5995.         componentLen = components.length,
  5996.         newPos = 0,
  5997.         oldPos = 0;
  5998.  
  5999.     for (; componentPos < componentLen; componentPos++) {
  6000.       var component = components[componentPos];
  6001.  
  6002.       if (!component.removed) {
  6003.         if (!component.added && useLongestToken) {
  6004.           var value = newString.slice(newPos, newPos + component.count);
  6005.           value = value.map(function (value, i) {
  6006.             var oldValue = oldString[oldPos + i];
  6007.             return oldValue.length > value.length ? oldValue : value;
  6008.           });
  6009.           component.value = diff.join(value);
  6010.         } else {
  6011.           component.value = diff.join(newString.slice(newPos, newPos + component.count));
  6012.         }
  6013.  
  6014.         newPos += component.count; // Common case
  6015.  
  6016.         if (!component.added) {
  6017.           oldPos += component.count;
  6018.         }
  6019.       } else {
  6020.         component.value = diff.join(oldString.slice(oldPos, oldPos + component.count));
  6021.         oldPos += component.count; // Reverse add and remove so removes are output first to match common convention
  6022.         // The diffing algorithm is tied to add then remove output and this is the simplest
  6023.         // route to get the desired output with minimal overhead.
  6024.  
  6025.         if (componentPos && components[componentPos - 1].added) {
  6026.           var tmp = components[componentPos - 1];
  6027.           components[componentPos - 1] = components[componentPos];
  6028.           components[componentPos] = tmp;
  6029.         }
  6030.       }
  6031.     } // Special case handle for when one terminal is ignored (i.e. whitespace).
  6032.     // For this case we merge the terminal into the prior string and drop the change.
  6033.     // This is only available for string mode.
  6034.  
  6035.  
  6036.     var lastComponent = components[componentLen - 1];
  6037.  
  6038.     if (componentLen > 1 && typeof lastComponent.value === 'string' && (lastComponent.added || lastComponent.removed) && diff.equals('', lastComponent.value)) {
  6039.       components[componentLen - 2].value += lastComponent.value;
  6040.       components.pop();
  6041.     }
  6042.  
  6043.     return components;
  6044.   }
  6045.  
  6046.   function clonePath(path) {
  6047.     return {
  6048.       newPos: path.newPos,
  6049.       components: path.components.slice(0)
  6050.     };
  6051.   }
  6052.  
  6053.   var characterDiff = new Diff();
  6054.   function diffChars(oldStr, newStr, options) {
  6055.     return characterDiff.diff(oldStr, newStr, options);
  6056.   }
  6057.  
  6058.   function generateOptions(options, defaults) {
  6059.     if (typeof options === 'function') {
  6060.       defaults.callback = options;
  6061.     } else if (options) {
  6062.       for (var name in options) {
  6063.         /* istanbul ignore else */
  6064.         if (options.hasOwnProperty(name)) {
  6065.           defaults[name] = options[name];
  6066.         }
  6067.       }
  6068.     }
  6069.  
  6070.     return defaults;
  6071.   }
  6072.  
  6073.   //
  6074.   // Ranges and exceptions:
  6075.   // Latin-1 Supplement, 0080–00FF
  6076.   //  - U+00D7  × Multiplication sign
  6077.   //  - U+00F7  ÷ Division sign
  6078.   // Latin Extended-A, 0100–017F
  6079.   // Latin Extended-B, 0180–024F
  6080.   // IPA Extensions, 0250–02AF
  6081.   // Spacing Modifier Letters, 02B0–02FF
  6082.   //  - U+02C7  ˇ &#711;  Caron
  6083.   //  - U+02D8  ˘ &#728;  Breve
  6084.   //  - U+02D9  ˙ &#729;  Dot Above
  6085.   //  - U+02DA  ˚ &#730;  Ring Above
  6086.   //  - U+02DB  ˛ &#731;  Ogonek
  6087.   //  - U+02DC  ˜ &#732;  Small Tilde
  6088.   //  - U+02DD  ˝ &#733;  Double Acute Accent
  6089.   // Latin Extended Additional, 1E00–1EFF
  6090.  
  6091.   var extendedWordChars = /^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/;
  6092.   var reWhitespace = /\S/;
  6093.   var wordDiff = new Diff();
  6094.  
  6095.   wordDiff.equals = function (left, right) {
  6096.     if (this.options.ignoreCase) {
  6097.       left = left.toLowerCase();
  6098.       right = right.toLowerCase();
  6099.     }
  6100.  
  6101.     return left === right || this.options.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right);
  6102.   };
  6103.  
  6104.   wordDiff.tokenize = function (value) {
  6105.     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.
  6106.  
  6107.     for (var i = 0; i < tokens.length - 1; i++) {
  6108.       // If we have an empty string in the next field and we have only word chars before and after, merge
  6109.       if (!tokens[i + 1] && tokens[i + 2] && extendedWordChars.test(tokens[i]) && extendedWordChars.test(tokens[i + 2])) {
  6110.         tokens[i] += tokens[i + 2];
  6111.         tokens.splice(i + 1, 2);
  6112.         i--;
  6113.       }
  6114.     }
  6115.  
  6116.     return tokens;
  6117.   };
  6118.  
  6119.   function diffWords(oldStr, newStr, options) {
  6120.     options = generateOptions(options, {
  6121.       ignoreWhitespace: true
  6122.     });
  6123.     return wordDiff.diff(oldStr, newStr, options);
  6124.   }
  6125.   function diffWordsWithSpace(oldStr, newStr, options) {
  6126.     return wordDiff.diff(oldStr, newStr, options);
  6127.   }
  6128.  
  6129.   var lineDiff = new Diff();
  6130.  
  6131.   lineDiff.tokenize = function (value) {
  6132.     var retLines = [],
  6133.         linesAndNewlines = value.split(/(\n|\r\n)/); // Ignore the final empty token that occurs if the string ends with a new line
  6134.  
  6135.     if (!linesAndNewlines[linesAndNewlines.length - 1]) {
  6136.       linesAndNewlines.pop();
  6137.     } // Merge the content and line separators into single tokens
  6138.  
  6139.  
  6140.     for (var i = 0; i < linesAndNewlines.length; i++) {
  6141.       var line = linesAndNewlines[i];
  6142.  
  6143.       if (i % 2 && !this.options.newlineIsToken) {
  6144.         retLines[retLines.length - 1] += line;
  6145.       } else {
  6146.         if (this.options.ignoreWhitespace) {
  6147.           line = line.trim();
  6148.         }
  6149.  
  6150.         retLines.push(line);
  6151.       }
  6152.     }
  6153.  
  6154.     return retLines;
  6155.   };
  6156.  
  6157.   function diffLines(oldStr, newStr, callback) {
  6158.     return lineDiff.diff(oldStr, newStr, callback);
  6159.   }
  6160.   function diffTrimmedLines(oldStr, newStr, callback) {
  6161.     var options = generateOptions(callback, {
  6162.       ignoreWhitespace: true
  6163.     });
  6164.     return lineDiff.diff(oldStr, newStr, options);
  6165.   }
  6166.  
  6167.   var sentenceDiff = new Diff();
  6168.  
  6169.   sentenceDiff.tokenize = function (value) {
  6170.     return value.split(/(\S.+?[.!?])(?=\s+|$)/);
  6171.   };
  6172.  
  6173.   function diffSentences(oldStr, newStr, callback) {
  6174.     return sentenceDiff.diff(oldStr, newStr, callback);
  6175.   }
  6176.  
  6177.   var cssDiff = new Diff();
  6178.  
  6179.   cssDiff.tokenize = function (value) {
  6180.     return value.split(/([{}:;,]|\s+)/);
  6181.   };
  6182.  
  6183.   function diffCss(oldStr, newStr, callback) {
  6184.     return cssDiff.diff(oldStr, newStr, callback);
  6185.   }
  6186.  
  6187.   function _typeof(obj) {
  6188.     if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
  6189.       _typeof = function (obj) {
  6190.         return typeof obj;
  6191.       };
  6192.     } else {
  6193.       _typeof = function (obj) {
  6194.         return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
  6195.       };
  6196.     }
  6197.  
  6198.     return _typeof(obj);
  6199.   }
  6200.  
  6201.   function _toConsumableArray(arr) {
  6202.     return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
  6203.   }
  6204.  
  6205.   function _arrayWithoutHoles(arr) {
  6206.     if (Array.isArray(arr)) {
  6207.       for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
  6208.  
  6209.       return arr2;
  6210.     }
  6211.   }
  6212.  
  6213.   function _iterableToArray(iter) {
  6214.     if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
  6215.   }
  6216.  
  6217.   function _nonIterableSpread() {
  6218.     throw new TypeError("Invalid attempt to spread non-iterable instance");
  6219.   }
  6220.  
  6221.   var objectPrototypeToString = Object.prototype.toString;
  6222.   var jsonDiff = new Diff(); // Discriminate between two lines of pretty-printed, serialized JSON where one of them has a
  6223.   // dangling comma and the other doesn't. Turns out including the dangling comma yields the nicest output:
  6224.  
  6225.   jsonDiff.useLongestToken = true;
  6226.   jsonDiff.tokenize = lineDiff.tokenize;
  6227.  
  6228.   jsonDiff.castInput = function (value) {
  6229.     var _this$options = this.options,
  6230.         undefinedReplacement = _this$options.undefinedReplacement,
  6231.         _this$options$stringi = _this$options.stringifyReplacer,
  6232.         stringifyReplacer = _this$options$stringi === void 0 ? function (k, v) {
  6233.       return typeof v === 'undefined' ? undefinedReplacement : v;
  6234.     } : _this$options$stringi;
  6235.     return typeof value === 'string' ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, '  ');
  6236.   };
  6237.  
  6238.   jsonDiff.equals = function (left, right) {
  6239.     return Diff.prototype.equals.call(jsonDiff, left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1'));
  6240.   };
  6241.  
  6242.   function diffJson(oldObj, newObj, options) {
  6243.     return jsonDiff.diff(oldObj, newObj, options);
  6244.   } // This function handles the presence of circular references by bailing out when encountering an
  6245.   // object that is already on the "stack" of items being processed. Accepts an optional replacer
  6246.  
  6247.   function canonicalize(obj, stack, replacementStack, replacer, key) {
  6248.     stack = stack || [];
  6249.     replacementStack = replacementStack || [];
  6250.  
  6251.     if (replacer) {
  6252.       obj = replacer(key, obj);
  6253.     }
  6254.  
  6255.     var i;
  6256.  
  6257.     for (i = 0; i < stack.length; i += 1) {
  6258.       if (stack[i] === obj) {
  6259.         return replacementStack[i];
  6260.       }
  6261.     }
  6262.  
  6263.     var canonicalizedObj;
  6264.  
  6265.     if ('[object Array]' === objectPrototypeToString.call(obj)) {
  6266.       stack.push(obj);
  6267.       canonicalizedObj = new Array(obj.length);
  6268.       replacementStack.push(canonicalizedObj);
  6269.  
  6270.       for (i = 0; i < obj.length; i += 1) {
  6271.         canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, key);
  6272.       }
  6273.  
  6274.       stack.pop();
  6275.       replacementStack.pop();
  6276.       return canonicalizedObj;
  6277.     }
  6278.  
  6279.     if (obj && obj.toJSON) {
  6280.       obj = obj.toJSON();
  6281.     }
  6282.  
  6283.     if (_typeof(obj) === 'object' && obj !== null) {
  6284.       stack.push(obj);
  6285.       canonicalizedObj = {};
  6286.       replacementStack.push(canonicalizedObj);
  6287.  
  6288.       var sortedKeys = [],
  6289.           _key;
  6290.  
  6291.       for (_key in obj) {
  6292.         /* istanbul ignore else */
  6293.         if (obj.hasOwnProperty(_key)) {
  6294.           sortedKeys.push(_key);
  6295.         }
  6296.       }
  6297.  
  6298.       sortedKeys.sort();
  6299.  
  6300.       for (i = 0; i < sortedKeys.length; i += 1) {
  6301.         _key = sortedKeys[i];
  6302.         canonicalizedObj[_key] = canonicalize(obj[_key], stack, replacementStack, replacer, _key);
  6303.       }
  6304.  
  6305.       stack.pop();
  6306.       replacementStack.pop();
  6307.     } else {
  6308.       canonicalizedObj = obj;
  6309.     }
  6310.  
  6311.     return canonicalizedObj;
  6312.   }
  6313.  
  6314.   var arrayDiff = new Diff();
  6315.  
  6316.   arrayDiff.tokenize = function (value) {
  6317.     return value.slice();
  6318.   };
  6319.  
  6320.   arrayDiff.join = arrayDiff.removeEmpty = function (value) {
  6321.     return value;
  6322.   };
  6323.  
  6324.   function diffArrays(oldArr, newArr, callback) {
  6325.     return arrayDiff.diff(oldArr, newArr, callback);
  6326.   }
  6327.  
  6328.   function parsePatch(uniDiff) {
  6329.     var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  6330.     var diffstr = uniDiff.split(/\r\n|[\n\v\f\r\x85]/),
  6331.         delimiters = uniDiff.match(/\r\n|[\n\v\f\r\x85]/g) || [],
  6332.         list = [],
  6333.         i = 0;
  6334.  
  6335.     function parseIndex() {
  6336.       var index = {};
  6337.       list.push(index); // Parse diff metadata
  6338.  
  6339.       while (i < diffstr.length) {
  6340.         var line = diffstr[i]; // File header found, end parsing diff metadata
  6341.  
  6342.         if (/^(\-\-\-|\+\+\+|@@)\s/.test(line)) {
  6343.           break;
  6344.         } // Diff index
  6345.  
  6346.  
  6347.         var header = /^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(line);
  6348.  
  6349.         if (header) {
  6350.           index.index = header[1];
  6351.         }
  6352.  
  6353.         i++;
  6354.       } // Parse file headers if they are defined. Unified diff requires them, but
  6355.       // there's no technical issues to have an isolated hunk without file header
  6356.  
  6357.  
  6358.       parseFileHeader(index);
  6359.       parseFileHeader(index); // Parse hunks
  6360.  
  6361.       index.hunks = [];
  6362.  
  6363.       while (i < diffstr.length) {
  6364.         var _line = diffstr[i];
  6365.  
  6366.         if (/^(Index:|diff|\-\-\-|\+\+\+)\s/.test(_line)) {
  6367.           break;
  6368.         } else if (/^@@/.test(_line)) {
  6369.           index.hunks.push(parseHunk());
  6370.         } else if (_line && options.strict) {
  6371.           // Ignore unexpected content unless in strict mode
  6372.           throw new Error('Unknown line ' + (i + 1) + ' ' + JSON.stringify(_line));
  6373.         } else {
  6374.           i++;
  6375.         }
  6376.       }
  6377.     } // Parses the --- and +++ headers, if none are found, no lines
  6378.     // are consumed.
  6379.  
  6380.  
  6381.     function parseFileHeader(index) {
  6382.       var fileHeader = /^(---|\+\+\+)\s+(.*)$/.exec(diffstr[i]);
  6383.  
  6384.       if (fileHeader) {
  6385.         var keyPrefix = fileHeader[1] === '---' ? 'old' : 'new';
  6386.         var data = fileHeader[2].split('\t', 2);
  6387.         var fileName = data[0].replace(/\\\\/g, '\\');
  6388.  
  6389.         if (/^".*"$/.test(fileName)) {
  6390.           fileName = fileName.substr(1, fileName.length - 2);
  6391.         }
  6392.  
  6393.         index[keyPrefix + 'FileName'] = fileName;
  6394.         index[keyPrefix + 'Header'] = (data[1] || '').trim();
  6395.         i++;
  6396.       }
  6397.     } // Parses a hunk
  6398.     // This assumes that we are at the start of a hunk.
  6399.  
  6400.  
  6401.     function parseHunk() {
  6402.       var chunkHeaderIndex = i,
  6403.           chunkHeaderLine = diffstr[i++],
  6404.           chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
  6405.       var hunk = {
  6406.         oldStart: +chunkHeader[1],
  6407.         oldLines: +chunkHeader[2] || 1,
  6408.         newStart: +chunkHeader[3],
  6409.         newLines: +chunkHeader[4] || 1,
  6410.         lines: [],
  6411.         linedelimiters: []
  6412.       };
  6413.       var addCount = 0,
  6414.           removeCount = 0;
  6415.  
  6416.       for (; i < diffstr.length; i++) {
  6417.         // Lines starting with '---' could be mistaken for the "remove line" operation
  6418.         // But they could be the header for the next file. Therefore prune such cases out.
  6419.         if (diffstr[i].indexOf('--- ') === 0 && i + 2 < diffstr.length && diffstr[i + 1].indexOf('+++ ') === 0 && diffstr[i + 2].indexOf('@@') === 0) {
  6420.           break;
  6421.         }
  6422.  
  6423.         var operation = diffstr[i].length == 0 && i != diffstr.length - 1 ? ' ' : diffstr[i][0];
  6424.  
  6425.         if (operation === '+' || operation === '-' || operation === ' ' || operation === '\\') {
  6426.           hunk.lines.push(diffstr[i]);
  6427.           hunk.linedelimiters.push(delimiters[i] || '\n');
  6428.  
  6429.           if (operation === '+') {
  6430.             addCount++;
  6431.           } else if (operation === '-') {
  6432.             removeCount++;
  6433.           } else if (operation === ' ') {
  6434.             addCount++;
  6435.             removeCount++;
  6436.           }
  6437.         } else {
  6438.           break;
  6439.         }
  6440.       } // Handle the empty block count case
  6441.  
  6442.  
  6443.       if (!addCount && hunk.newLines === 1) {
  6444.         hunk.newLines = 0;
  6445.       }
  6446.  
  6447.       if (!removeCount && hunk.oldLines === 1) {
  6448.         hunk.oldLines = 0;
  6449.       } // Perform optional sanity checking
  6450.  
  6451.  
  6452.       if (options.strict) {
  6453.         if (addCount !== hunk.newLines) {
  6454.           throw new Error('Added line count did not match for hunk at line ' + (chunkHeaderIndex + 1));
  6455.         }
  6456.  
  6457.         if (removeCount !== hunk.oldLines) {
  6458.           throw new Error('Removed line count did not match for hunk at line ' + (chunkHeaderIndex + 1));
  6459.         }
  6460.       }
  6461.  
  6462.       return hunk;
  6463.     }
  6464.  
  6465.     while (i < diffstr.length) {
  6466.       parseIndex();
  6467.     }
  6468.  
  6469.     return list;
  6470.   }
  6471.  
  6472.   // Iterator that traverses in the range of [min, max], stepping
  6473.   // by distance from a given start position. I.e. for [0, 4], with
  6474.   // start of 2, this will iterate 2, 3, 1, 4, 0.
  6475.   function distanceIterator (start, minLine, maxLine) {
  6476.     var wantForward = true,
  6477.         backwardExhausted = false,
  6478.         forwardExhausted = false,
  6479.         localOffset = 1;
  6480.     return function iterator() {
  6481.       if (wantForward && !forwardExhausted) {
  6482.         if (backwardExhausted) {
  6483.           localOffset++;
  6484.         } else {
  6485.           wantForward = false;
  6486.         } // Check if trying to fit beyond text length, and if not, check it fits
  6487.         // after offset location (or desired location on first iteration)
  6488.  
  6489.  
  6490.         if (start + localOffset <= maxLine) {
  6491.           return localOffset;
  6492.         }
  6493.  
  6494.         forwardExhausted = true;
  6495.       }
  6496.  
  6497.       if (!backwardExhausted) {
  6498.         if (!forwardExhausted) {
  6499.           wantForward = true;
  6500.         } // Check if trying to fit before text beginning, and if not, check it fits
  6501.         // before offset location
  6502.  
  6503.  
  6504.         if (minLine <= start - localOffset) {
  6505.           return -localOffset++;
  6506.         }
  6507.  
  6508.         backwardExhausted = true;
  6509.         return iterator();
  6510.       } // We tried to fit hunk before text beginning and beyond text length, then
  6511.       // hunk can't fit on the text. Return undefined
  6512.  
  6513.     };
  6514.   }
  6515.  
  6516.   function applyPatch(source, uniDiff) {
  6517.     var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
  6518.  
  6519.     if (typeof uniDiff === 'string') {
  6520.       uniDiff = parsePatch(uniDiff);
  6521.     }
  6522.  
  6523.     if (Array.isArray(uniDiff)) {
  6524.       if (uniDiff.length > 1) {
  6525.         throw new Error('applyPatch only works with a single input.');
  6526.       }
  6527.  
  6528.       uniDiff = uniDiff[0];
  6529.     } // Apply the diff to the input
  6530.  
  6531.  
  6532.     var lines = source.split(/\r\n|[\n\v\f\r\x85]/),
  6533.         delimiters = source.match(/\r\n|[\n\v\f\r\x85]/g) || [],
  6534.         hunks = uniDiff.hunks,
  6535.         compareLine = options.compareLine || function (lineNumber, line, operation, patchContent) {
  6536.       return line === patchContent;
  6537.     },
  6538.         errorCount = 0,
  6539.         fuzzFactor = options.fuzzFactor || 0,
  6540.         minLine = 0,
  6541.         offset = 0,
  6542.         removeEOFNL,
  6543.         addEOFNL;
  6544.     /**
  6545.      * Checks if the hunk exactly fits on the provided location
  6546.      */
  6547.  
  6548.  
  6549.     function hunkFits(hunk, toPos) {
  6550.       for (var j = 0; j < hunk.lines.length; j++) {
  6551.         var line = hunk.lines[j],
  6552.             operation = line.length > 0 ? line[0] : ' ',
  6553.             content = line.length > 0 ? line.substr(1) : line;
  6554.  
  6555.         if (operation === ' ' || operation === '-') {
  6556.           // Context sanity check
  6557.           if (!compareLine(toPos + 1, lines[toPos], operation, content)) {
  6558.             errorCount++;
  6559.  
  6560.             if (errorCount > fuzzFactor) {
  6561.               return false;
  6562.             }
  6563.           }
  6564.  
  6565.           toPos++;
  6566.         }
  6567.       }
  6568.  
  6569.       return true;
  6570.     } // Search best fit offsets for each hunk based on the previous ones
  6571.  
  6572.  
  6573.     for (var i = 0; i < hunks.length; i++) {
  6574.       var hunk = hunks[i],
  6575.           maxLine = lines.length - hunk.oldLines,
  6576.           localOffset = 0,
  6577.           toPos = offset + hunk.oldStart - 1;
  6578.       var iterator = distanceIterator(toPos, minLine, maxLine);
  6579.  
  6580.       for (; localOffset !== undefined; localOffset = iterator()) {
  6581.         if (hunkFits(hunk, toPos + localOffset)) {
  6582.           hunk.offset = offset += localOffset;
  6583.           break;
  6584.         }
  6585.       }
  6586.  
  6587.       if (localOffset === undefined) {
  6588.         return false;
  6589.       } // Set lower text limit to end of the current hunk, so next ones don't try
  6590.       // to fit over already patched text
  6591.  
  6592.  
  6593.       minLine = hunk.offset + hunk.oldStart + hunk.oldLines;
  6594.     } // Apply patch hunks
  6595.  
  6596.  
  6597.     var diffOffset = 0;
  6598.  
  6599.     for (var _i = 0; _i < hunks.length; _i++) {
  6600.       var _hunk = hunks[_i],
  6601.           _toPos = _hunk.oldStart + _hunk.offset + diffOffset - 1;
  6602.  
  6603.       diffOffset += _hunk.newLines - _hunk.oldLines;
  6604.  
  6605.       if (_toPos < 0) {
  6606.         // Creating a new file
  6607.         _toPos = 0;
  6608.       }
  6609.  
  6610.       for (var j = 0; j < _hunk.lines.length; j++) {
  6611.         var line = _hunk.lines[j],
  6612.             operation = line.length > 0 ? line[0] : ' ',
  6613.             content = line.length > 0 ? line.substr(1) : line,
  6614.             delimiter = _hunk.linedelimiters[j];
  6615.  
  6616.         if (operation === ' ') {
  6617.           _toPos++;
  6618.         } else if (operation === '-') {
  6619.           lines.splice(_toPos, 1);
  6620.           delimiters.splice(_toPos, 1);
  6621.           /* istanbul ignore else */
  6622.         } else if (operation === '+') {
  6623.           lines.splice(_toPos, 0, content);
  6624.           delimiters.splice(_toPos, 0, delimiter);
  6625.           _toPos++;
  6626.         } else if (operation === '\\') {
  6627.           var previousOperation = _hunk.lines[j - 1] ? _hunk.lines[j - 1][0] : null;
  6628.  
  6629.           if (previousOperation === '+') {
  6630.             removeEOFNL = true;
  6631.           } else if (previousOperation === '-') {
  6632.             addEOFNL = true;
  6633.           }
  6634.         }
  6635.       }
  6636.     } // Handle EOFNL insertion/removal
  6637.  
  6638.  
  6639.     if (removeEOFNL) {
  6640.       while (!lines[lines.length - 1]) {
  6641.         lines.pop();
  6642.         delimiters.pop();
  6643.       }
  6644.     } else if (addEOFNL) {
  6645.       lines.push('');
  6646.       delimiters.push('\n');
  6647.     }
  6648.  
  6649.     for (var _k = 0; _k < lines.length - 1; _k++) {
  6650.       lines[_k] = lines[_k] + delimiters[_k];
  6651.     }
  6652.  
  6653.     return lines.join('');
  6654.   } // Wrapper that supports multiple file patches via callbacks.
  6655.  
  6656.   function applyPatches(uniDiff, options) {
  6657.     if (typeof uniDiff === 'string') {
  6658.       uniDiff = parsePatch(uniDiff);
  6659.     }
  6660.  
  6661.     var currentIndex = 0;
  6662.  
  6663.     function processIndex() {
  6664.       var index = uniDiff[currentIndex++];
  6665.  
  6666.       if (!index) {
  6667.         return options.complete();
  6668.       }
  6669.  
  6670.       options.loadFile(index, function (err, data) {
  6671.         if (err) {
  6672.           return options.complete(err);
  6673.         }
  6674.  
  6675.         var updatedContent = applyPatch(data, index, options);
  6676.         options.patched(index, updatedContent, function (err) {
  6677.           if (err) {
  6678.             return options.complete(err);
  6679.           }
  6680.  
  6681.           processIndex();
  6682.         });
  6683.       });
  6684.     }
  6685.  
  6686.     processIndex();
  6687.   }
  6688.  
  6689.   function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
  6690.     if (!options) {
  6691.       options = {};
  6692.     }
  6693.  
  6694.     if (typeof options.context === 'undefined') {
  6695.       options.context = 4;
  6696.     }
  6697.  
  6698.     var diff = diffLines(oldStr, newStr, options);
  6699.     diff.push({
  6700.       value: '',
  6701.       lines: []
  6702.     }); // Append an empty value to make cleanup easier
  6703.  
  6704.     function contextLines(lines) {
  6705.       return lines.map(function (entry) {
  6706.         return ' ' + entry;
  6707.       });
  6708.     }
  6709.  
  6710.     var hunks = [];
  6711.     var oldRangeStart = 0,
  6712.         newRangeStart = 0,
  6713.         curRange = [],
  6714.         oldLine = 1,
  6715.         newLine = 1;
  6716.  
  6717.     var _loop = function _loop(i) {
  6718.       var current = diff[i],
  6719.           lines = current.lines || current.value.replace(/\n$/, '').split('\n');
  6720.       current.lines = lines;
  6721.  
  6722.       if (current.added || current.removed) {
  6723.         var _curRange;
  6724.  
  6725.         // If we have previous context, start with that
  6726.         if (!oldRangeStart) {
  6727.           var prev = diff[i - 1];
  6728.           oldRangeStart = oldLine;
  6729.           newRangeStart = newLine;
  6730.  
  6731.           if (prev) {
  6732.             curRange = options.context > 0 ? contextLines(prev.lines.slice(-options.context)) : [];
  6733.             oldRangeStart -= curRange.length;
  6734.             newRangeStart -= curRange.length;
  6735.           }
  6736.         } // Output our changes
  6737.  
  6738.  
  6739.         (_curRange = curRange).push.apply(_curRange, _toConsumableArray(lines.map(function (entry) {
  6740.           return (current.added ? '+' : '-') + entry;
  6741.         }))); // Track the updated file position
  6742.  
  6743.  
  6744.         if (current.added) {
  6745.           newLine += lines.length;
  6746.         } else {
  6747.           oldLine += lines.length;
  6748.         }
  6749.       } else {
  6750.         // Identical context lines. Track line changes
  6751.         if (oldRangeStart) {
  6752.           // Close out any changes that have been output (or join overlapping)
  6753.           if (lines.length <= options.context * 2 && i < diff.length - 2) {
  6754.             var _curRange2;
  6755.  
  6756.             // Overlapping
  6757.             (_curRange2 = curRange).push.apply(_curRange2, _toConsumableArray(contextLines(lines)));
  6758.           } else {
  6759.             var _curRange3;
  6760.  
  6761.             // end the range and output
  6762.             var contextSize = Math.min(lines.length, options.context);
  6763.  
  6764.             (_curRange3 = curRange).push.apply(_curRange3, _toConsumableArray(contextLines(lines.slice(0, contextSize))));
  6765.  
  6766.             var hunk = {
  6767.               oldStart: oldRangeStart,
  6768.               oldLines: oldLine - oldRangeStart + contextSize,
  6769.               newStart: newRangeStart,
  6770.               newLines: newLine - newRangeStart + contextSize,
  6771.               lines: curRange
  6772.             };
  6773.  
  6774.             if (i >= diff.length - 2 && lines.length <= options.context) {
  6775.               // EOF is inside this hunk
  6776.               var oldEOFNewline = /\n$/.test(oldStr);
  6777.               var newEOFNewline = /\n$/.test(newStr);
  6778.               var noNlBeforeAdds = lines.length == 0 && curRange.length > hunk.oldLines;
  6779.  
  6780.               if (!oldEOFNewline && noNlBeforeAdds) {
  6781.                 // special case: old has no eol and no trailing context; no-nl can end up before adds
  6782.                 curRange.splice(hunk.oldLines, 0, '\\ No newline at end of file');
  6783.               }
  6784.  
  6785.               if (!oldEOFNewline && !noNlBeforeAdds || !newEOFNewline) {
  6786.                 curRange.push('\\ No newline at end of file');
  6787.               }
  6788.             }
  6789.  
  6790.             hunks.push(hunk);
  6791.             oldRangeStart = 0;
  6792.             newRangeStart = 0;
  6793.             curRange = [];
  6794.           }
  6795.         }
  6796.  
  6797.         oldLine += lines.length;
  6798.         newLine += lines.length;
  6799.       }
  6800.     };
  6801.  
  6802.     for (var i = 0; i < diff.length; i++) {
  6803.       _loop(i);
  6804.     }
  6805.  
  6806.     return {
  6807.       oldFileName: oldFileName,
  6808.       newFileName: newFileName,
  6809.       oldHeader: oldHeader,
  6810.       newHeader: newHeader,
  6811.       hunks: hunks
  6812.     };
  6813.   }
  6814.   function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
  6815.     var diff = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
  6816.     var ret = [];
  6817.  
  6818.     if (oldFileName == newFileName) {
  6819.       ret.push('Index: ' + oldFileName);
  6820.     }
  6821.  
  6822.     ret.push('===================================================================');
  6823.     ret.push('--- ' + diff.oldFileName + (typeof diff.oldHeader === 'undefined' ? '' : '\t' + diff.oldHeader));
  6824.     ret.push('+++ ' + diff.newFileName + (typeof diff.newHeader === 'undefined' ? '' : '\t' + diff.newHeader));
  6825.  
  6826.     for (var i = 0; i < diff.hunks.length; i++) {
  6827.       var hunk = diff.hunks[i];
  6828.       ret.push('@@ -' + hunk.oldStart + ',' + hunk.oldLines + ' +' + hunk.newStart + ',' + hunk.newLines + ' @@');
  6829.       ret.push.apply(ret, hunk.lines);
  6830.     }
  6831.  
  6832.     return ret.join('\n') + '\n';
  6833.   }
  6834.   function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {
  6835.     return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options);
  6836.   }
  6837.  
  6838.   function arrayEqual(a, b) {
  6839.     if (a.length !== b.length) {
  6840.       return false;
  6841.     }
  6842.  
  6843.     return arrayStartsWith(a, b);
  6844.   }
  6845.   function arrayStartsWith(array, start) {
  6846.     if (start.length > array.length) {
  6847.       return false;
  6848.     }
  6849.  
  6850.     for (var i = 0; i < start.length; i++) {
  6851.       if (start[i] !== array[i]) {
  6852.         return false;
  6853.       }
  6854.     }
  6855.  
  6856.     return true;
  6857.   }
  6858.  
  6859.   function calcLineCount(hunk) {
  6860.     var _calcOldNewLineCount = calcOldNewLineCount(hunk.lines),
  6861.         oldLines = _calcOldNewLineCount.oldLines,
  6862.         newLines = _calcOldNewLineCount.newLines;
  6863.  
  6864.     if (oldLines !== undefined) {
  6865.       hunk.oldLines = oldLines;
  6866.     } else {
  6867.       delete hunk.oldLines;
  6868.     }
  6869.  
  6870.     if (newLines !== undefined) {
  6871.       hunk.newLines = newLines;
  6872.     } else {
  6873.       delete hunk.newLines;
  6874.     }
  6875.   }
  6876.   function merge(mine, theirs, base) {
  6877.     mine = loadPatch(mine, base);
  6878.     theirs = loadPatch(theirs, base);
  6879.     var ret = {}; // For index we just let it pass through as it doesn't have any necessary meaning.
  6880.     // Leaving sanity checks on this to the API consumer that may know more about the
  6881.     // meaning in their own context.
  6882.  
  6883.     if (mine.index || theirs.index) {
  6884.       ret.index = mine.index || theirs.index;
  6885.     }
  6886.  
  6887.     if (mine.newFileName || theirs.newFileName) {
  6888.       if (!fileNameChanged(mine)) {
  6889.         // No header or no change in ours, use theirs (and ours if theirs does not exist)
  6890.         ret.oldFileName = theirs.oldFileName || mine.oldFileName;
  6891.         ret.newFileName = theirs.newFileName || mine.newFileName;
  6892.         ret.oldHeader = theirs.oldHeader || mine.oldHeader;
  6893.         ret.newHeader = theirs.newHeader || mine.newHeader;
  6894.       } else if (!fileNameChanged(theirs)) {
  6895.         // No header or no change in theirs, use ours
  6896.         ret.oldFileName = mine.oldFileName;
  6897.         ret.newFileName = mine.newFileName;
  6898.         ret.oldHeader = mine.oldHeader;
  6899.         ret.newHeader = mine.newHeader;
  6900.       } else {
  6901.         // Both changed... figure it out
  6902.         ret.oldFileName = selectField(ret, mine.oldFileName, theirs.oldFileName);
  6903.         ret.newFileName = selectField(ret, mine.newFileName, theirs.newFileName);
  6904.         ret.oldHeader = selectField(ret, mine.oldHeader, theirs.oldHeader);
  6905.         ret.newHeader = selectField(ret, mine.newHeader, theirs.newHeader);
  6906.       }
  6907.     }
  6908.  
  6909.     ret.hunks = [];
  6910.     var mineIndex = 0,
  6911.         theirsIndex = 0,
  6912.         mineOffset = 0,
  6913.         theirsOffset = 0;
  6914.  
  6915.     while (mineIndex < mine.hunks.length || theirsIndex < theirs.hunks.length) {
  6916.       var mineCurrent = mine.hunks[mineIndex] || {
  6917.         oldStart: Infinity
  6918.       },
  6919.           theirsCurrent = theirs.hunks[theirsIndex] || {
  6920.         oldStart: Infinity
  6921.       };
  6922.  
  6923.       if (hunkBefore(mineCurrent, theirsCurrent)) {
  6924.         // This patch does not overlap with any of the others, yay.
  6925.         ret.hunks.push(cloneHunk(mineCurrent, mineOffset));
  6926.         mineIndex++;
  6927.         theirsOffset += mineCurrent.newLines - mineCurrent.oldLines;
  6928.       } else if (hunkBefore(theirsCurrent, mineCurrent)) {
  6929.         // This patch does not overlap with any of the others, yay.
  6930.         ret.hunks.push(cloneHunk(theirsCurrent, theirsOffset));
  6931.         theirsIndex++;
  6932.         mineOffset += theirsCurrent.newLines - theirsCurrent.oldLines;
  6933.       } else {
  6934.         // Overlap, merge as best we can
  6935.         var mergedHunk = {
  6936.           oldStart: Math.min(mineCurrent.oldStart, theirsCurrent.oldStart),
  6937.           oldLines: 0,
  6938.           newStart: Math.min(mineCurrent.newStart + mineOffset, theirsCurrent.oldStart + theirsOffset),
  6939.           newLines: 0,
  6940.           lines: []
  6941.         };
  6942.         mergeLines(mergedHunk, mineCurrent.oldStart, mineCurrent.lines, theirsCurrent.oldStart, theirsCurrent.lines);
  6943.         theirsIndex++;
  6944.         mineIndex++;
  6945.         ret.hunks.push(mergedHunk);
  6946.       }
  6947.     }
  6948.  
  6949.     return ret;
  6950.   }
  6951.  
  6952.   function loadPatch(param, base) {
  6953.     if (typeof param === 'string') {
  6954.       if (/^@@/m.test(param) || /^Index:/m.test(param)) {
  6955.         return parsePatch(param)[0];
  6956.       }
  6957.  
  6958.       if (!base) {
  6959.         throw new Error('Must provide a base reference or pass in a patch');
  6960.       }
  6961.  
  6962.       return structuredPatch(undefined, undefined, base, param);
  6963.     }
  6964.  
  6965.     return param;
  6966.   }
  6967.  
  6968.   function fileNameChanged(patch) {
  6969.     return patch.newFileName && patch.newFileName !== patch.oldFileName;
  6970.   }
  6971.  
  6972.   function selectField(index, mine, theirs) {
  6973.     if (mine === theirs) {
  6974.       return mine;
  6975.     } else {
  6976.       index.conflict = true;
  6977.       return {
  6978.         mine: mine,
  6979.         theirs: theirs
  6980.       };
  6981.     }
  6982.   }
  6983.  
  6984.   function hunkBefore(test, check) {
  6985.     return test.oldStart < check.oldStart && test.oldStart + test.oldLines < check.oldStart;
  6986.   }
  6987.  
  6988.   function cloneHunk(hunk, offset) {
  6989.     return {
  6990.       oldStart: hunk.oldStart,
  6991.       oldLines: hunk.oldLines,
  6992.       newStart: hunk.newStart + offset,
  6993.       newLines: hunk.newLines,
  6994.       lines: hunk.lines
  6995.     };
  6996.   }
  6997.  
  6998.   function mergeLines(hunk, mineOffset, mineLines, theirOffset, theirLines) {
  6999.     // This will generally result in a conflicted hunk, but there are cases where the context
  7000.     // is the only overlap where we can successfully merge the content here.
  7001.     var mine = {
  7002.       offset: mineOffset,
  7003.       lines: mineLines,
  7004.       index: 0
  7005.     },
  7006.         their = {
  7007.       offset: theirOffset,
  7008.       lines: theirLines,
  7009.       index: 0
  7010.     }; // Handle any leading content
  7011.  
  7012.     insertLeading(hunk, mine, their);
  7013.     insertLeading(hunk, their, mine); // Now in the overlap content. Scan through and select the best changes from each.
  7014.  
  7015.     while (mine.index < mine.lines.length && their.index < their.lines.length) {
  7016.       var mineCurrent = mine.lines[mine.index],
  7017.           theirCurrent = their.lines[their.index];
  7018.  
  7019.       if ((mineCurrent[0] === '-' || mineCurrent[0] === '+') && (theirCurrent[0] === '-' || theirCurrent[0] === '+')) {
  7020.         // Both modified ...
  7021.         mutualChange(hunk, mine, their);
  7022.       } else if (mineCurrent[0] === '+' && theirCurrent[0] === ' ') {
  7023.         var _hunk$lines;
  7024.  
  7025.         // Mine inserted
  7026.         (_hunk$lines = hunk.lines).push.apply(_hunk$lines, _toConsumableArray(collectChange(mine)));
  7027.       } else if (theirCurrent[0] === '+' && mineCurrent[0] === ' ') {
  7028.         var _hunk$lines2;
  7029.  
  7030.         // Theirs inserted
  7031.         (_hunk$lines2 = hunk.lines).push.apply(_hunk$lines2, _toConsumableArray(collectChange(their)));
  7032.       } else if (mineCurrent[0] === '-' && theirCurrent[0] === ' ') {
  7033.         // Mine removed or edited
  7034.         removal(hunk, mine, their);
  7035.       } else if (theirCurrent[0] === '-' && mineCurrent[0] === ' ') {
  7036.         // Their removed or edited
  7037.         removal(hunk, their, mine, true);
  7038.       } else if (mineCurrent === theirCurrent) {
  7039.         // Context identity
  7040.         hunk.lines.push(mineCurrent);
  7041.         mine.index++;
  7042.         their.index++;
  7043.       } else {
  7044.         // Context mismatch
  7045.         conflict(hunk, collectChange(mine), collectChange(their));
  7046.       }
  7047.     } // Now push anything that may be remaining
  7048.  
  7049.  
  7050.     insertTrailing(hunk, mine);
  7051.     insertTrailing(hunk, their);
  7052.     calcLineCount(hunk);
  7053.   }
  7054.  
  7055.   function mutualChange(hunk, mine, their) {
  7056.     var myChanges = collectChange(mine),
  7057.         theirChanges = collectChange(their);
  7058.  
  7059.     if (allRemoves(myChanges) && allRemoves(theirChanges)) {
  7060.       // Special case for remove changes that are supersets of one another
  7061.       if (arrayStartsWith(myChanges, theirChanges) && skipRemoveSuperset(their, myChanges, myChanges.length - theirChanges.length)) {
  7062.         var _hunk$lines3;
  7063.  
  7064.         (_hunk$lines3 = hunk.lines).push.apply(_hunk$lines3, _toConsumableArray(myChanges));
  7065.  
  7066.         return;
  7067.       } else if (arrayStartsWith(theirChanges, myChanges) && skipRemoveSuperset(mine, theirChanges, theirChanges.length - myChanges.length)) {
  7068.         var _hunk$lines4;
  7069.  
  7070.         (_hunk$lines4 = hunk.lines).push.apply(_hunk$lines4, _toConsumableArray(theirChanges));
  7071.  
  7072.         return;
  7073.       }
  7074.     } else if (arrayEqual(myChanges, theirChanges)) {
  7075.       var _hunk$lines5;
  7076.  
  7077.       (_hunk$lines5 = hunk.lines).push.apply(_hunk$lines5, _toConsumableArray(myChanges));
  7078.  
  7079.       return;
  7080.     }
  7081.  
  7082.     conflict(hunk, myChanges, theirChanges);
  7083.   }
  7084.  
  7085.   function removal(hunk, mine, their, swap) {
  7086.     var myChanges = collectChange(mine),
  7087.         theirChanges = collectContext(their, myChanges);
  7088.  
  7089.     if (theirChanges.merged) {
  7090.       var _hunk$lines6;
  7091.  
  7092.       (_hunk$lines6 = hunk.lines).push.apply(_hunk$lines6, _toConsumableArray(theirChanges.merged));
  7093.     } else {
  7094.       conflict(hunk, swap ? theirChanges : myChanges, swap ? myChanges : theirChanges);
  7095.     }
  7096.   }
  7097.  
  7098.   function conflict(hunk, mine, their) {
  7099.     hunk.conflict = true;
  7100.     hunk.lines.push({
  7101.       conflict: true,
  7102.       mine: mine,
  7103.       theirs: their
  7104.     });
  7105.   }
  7106.  
  7107.   function insertLeading(hunk, insert, their) {
  7108.     while (insert.offset < their.offset && insert.index < insert.lines.length) {
  7109.       var line = insert.lines[insert.index++];
  7110.       hunk.lines.push(line);
  7111.       insert.offset++;
  7112.     }
  7113.   }
  7114.  
  7115.   function insertTrailing(hunk, insert) {
  7116.     while (insert.index < insert.lines.length) {
  7117.       var line = insert.lines[insert.index++];
  7118.       hunk.lines.push(line);
  7119.     }
  7120.   }
  7121.  
  7122.   function collectChange(state) {
  7123.     var ret = [],
  7124.         operation = state.lines[state.index][0];
  7125.  
  7126.     while (state.index < state.lines.length) {
  7127.       var line = state.lines[state.index]; // Group additions that are immediately after subtractions and treat them as one "atomic" modify change.
  7128.  
  7129.       if (operation === '-' && line[0] === '+') {
  7130.         operation = '+';
  7131.       }
  7132.  
  7133.       if (operation === line[0]) {
  7134.         ret.push(line);
  7135.         state.index++;
  7136.       } else {
  7137.         break;
  7138.       }
  7139.     }
  7140.  
  7141.     return ret;
  7142.   }
  7143.  
  7144.   function collectContext(state, matchChanges) {
  7145.     var changes = [],
  7146.         merged = [],
  7147.         matchIndex = 0,
  7148.         contextChanges = false,
  7149.         conflicted = false;
  7150.  
  7151.     while (matchIndex < matchChanges.length && state.index < state.lines.length) {
  7152.       var change = state.lines[state.index],
  7153.           match = matchChanges[matchIndex]; // Once we've hit our add, then we are done
  7154.  
  7155.       if (match[0] === '+') {
  7156.         break;
  7157.       }
  7158.  
  7159.       contextChanges = contextChanges || change[0] !== ' ';
  7160.       merged.push(match);
  7161.       matchIndex++; // Consume any additions in the other block as a conflict to attempt
  7162.       // to pull in the remaining context after this
  7163.  
  7164.       if (change[0] === '+') {
  7165.         conflicted = true;
  7166.  
  7167.         while (change[0] === '+') {
  7168.           changes.push(change);
  7169.           change = state.lines[++state.index];
  7170.         }
  7171.       }
  7172.  
  7173.       if (match.substr(1) === change.substr(1)) {
  7174.         changes.push(change);
  7175.         state.index++;
  7176.       } else {
  7177.         conflicted = true;
  7178.       }
  7179.     }
  7180.  
  7181.     if ((matchChanges[matchIndex] || '')[0] === '+' && contextChanges) {
  7182.       conflicted = true;
  7183.     }
  7184.  
  7185.     if (conflicted) {
  7186.       return changes;
  7187.     }
  7188.  
  7189.     while (matchIndex < matchChanges.length) {
  7190.       merged.push(matchChanges[matchIndex++]);
  7191.     }
  7192.  
  7193.     return {
  7194.       merged: merged,
  7195.       changes: changes
  7196.     };
  7197.   }
  7198.  
  7199.   function allRemoves(changes) {
  7200.     return changes.reduce(function (prev, change) {
  7201.       return prev && change[0] === '-';
  7202.     }, true);
  7203.   }
  7204.  
  7205.   function skipRemoveSuperset(state, removeChanges, delta) {
  7206.     for (var i = 0; i < delta; i++) {
  7207.       var changeContent = removeChanges[removeChanges.length - delta + i].substr(1);
  7208.  
  7209.       if (state.lines[state.index + i] !== ' ' + changeContent) {
  7210.         return false;
  7211.       }
  7212.     }
  7213.  
  7214.     state.index += delta;
  7215.     return true;
  7216.   }
  7217.  
  7218.   function calcOldNewLineCount(lines) {
  7219.     var oldLines = 0;
  7220.     var newLines = 0;
  7221.     lines.forEach(function (line) {
  7222.       if (typeof line !== 'string') {
  7223.         var myCount = calcOldNewLineCount(line.mine);
  7224.         var theirCount = calcOldNewLineCount(line.theirs);
  7225.  
  7226.         if (oldLines !== undefined) {
  7227.           if (myCount.oldLines === theirCount.oldLines) {
  7228.             oldLines += myCount.oldLines;
  7229.           } else {
  7230.             oldLines = undefined;
  7231.           }
  7232.         }
  7233.  
  7234.         if (newLines !== undefined) {
  7235.           if (myCount.newLines === theirCount.newLines) {
  7236.             newLines += myCount.newLines;
  7237.           } else {
  7238.             newLines = undefined;
  7239.           }
  7240.         }
  7241.       } else {
  7242.         if (newLines !== undefined && (line[0] === '+' || line[0] === ' ')) {
  7243.           newLines++;
  7244.         }
  7245.  
  7246.         if (oldLines !== undefined && (line[0] === '-' || line[0] === ' ')) {
  7247.           oldLines++;
  7248.         }
  7249.       }
  7250.     });
  7251.     return {
  7252.       oldLines: oldLines,
  7253.       newLines: newLines
  7254.     };
  7255.   }
  7256.  
  7257.   // See: http://code.google.com/p/google-diff-match-patch/wiki/API
  7258.   function convertChangesToDMP(changes) {
  7259.     var ret = [],
  7260.         change,
  7261.         operation;
  7262.  
  7263.     for (var i = 0; i < changes.length; i++) {
  7264.       change = changes[i];
  7265.  
  7266.       if (change.added) {
  7267.         operation = 1;
  7268.       } else if (change.removed) {
  7269.         operation = -1;
  7270.       } else {
  7271.         operation = 0;
  7272.       }
  7273.  
  7274.       ret.push([operation, change.value]);
  7275.     }
  7276.  
  7277.     return ret;
  7278.   }
  7279.  
  7280.   function convertChangesToXML(changes) {
  7281.     var ret = [];
  7282.  
  7283.     for (var i = 0; i < changes.length; i++) {
  7284.       var change = changes[i];
  7285.  
  7286.       if (change.added) {
  7287.         ret.push('<ins>');
  7288.       } else if (change.removed) {
  7289.         ret.push('<del>');
  7290.       }
  7291.  
  7292.       ret.push(escapeHTML(change.value));
  7293.  
  7294.       if (change.added) {
  7295.         ret.push('</ins>');
  7296.       } else if (change.removed) {
  7297.         ret.push('</del>');
  7298.       }
  7299.     }
  7300.  
  7301.     return ret.join('');
  7302.   }
  7303.  
  7304.   function escapeHTML(s) {
  7305.     var n = s;
  7306.     n = n.replace(/&/g, '&amp;');
  7307.     n = n.replace(/</g, '&lt;');
  7308.     n = n.replace(/>/g, '&gt;');
  7309.     n = n.replace(/"/g, '&quot;');
  7310.     return n;
  7311.   }
  7312.  
  7313.   /* See LICENSE file for terms of use */
  7314.  
  7315.   exports.Diff = Diff;
  7316.   exports.diffChars = diffChars;
  7317.   exports.diffWords = diffWords;
  7318.   exports.diffWordsWithSpace = diffWordsWithSpace;
  7319.   exports.diffLines = diffLines;
  7320.   exports.diffTrimmedLines = diffTrimmedLines;
  7321.   exports.diffSentences = diffSentences;
  7322.   exports.diffCss = diffCss;
  7323.   exports.diffJson = diffJson;
  7324.   exports.diffArrays = diffArrays;
  7325.   exports.structuredPatch = structuredPatch;
  7326.   exports.createTwoFilesPatch = createTwoFilesPatch;
  7327.   exports.createPatch = createPatch;
  7328.   exports.applyPatch = applyPatch;
  7329.   exports.applyPatches = applyPatches;
  7330.   exports.parsePatch = parsePatch;
  7331.   exports.merge = merge;
  7332.   exports.convertChangesToDMP = convertChangesToDMP;
  7333.   exports.convertChangesToXML = convertChangesToXML;
  7334.   exports.canonicalize = canonicalize;
  7335.  
  7336.   Object.defineProperty(exports, '__esModule', { value: true });
  7337.  
  7338. }));
  7339.  
  7340.  
  7341. /***/ }),
  7342.  
  7343. /***/ "xeH2":
  7344. /***/ (function(module, exports) {
  7345.  
  7346. module.exports = $;
  7347.  
  7348. /***/ }),
  7349.  
  7350. /***/ "yLpj":
  7351. /***/ (function(module, exports) {
  7352.  
  7353. var g;
  7354.  
  7355. // This works in non-strict mode
  7356. g = (function() {
  7357. 	return this;
  7358. })();
  7359.  
  7360. try {
  7361. 	// This works if eval is allowed (see CSP)
  7362. 	g = g || new Function("return this")();
  7363. } catch (e) {
  7364. 	// This works if the window reference is available
  7365. 	if (typeof window === "object") g = window;
  7366. }
  7367.  
  7368. // g can still be undefined, but nothing to do about it...
  7369. // We return undefined, instead of nothing here, so it's
  7370. // easier to handle this case. if(!global) { ...}
  7371.  
  7372. module.exports = g;
  7373.  
  7374.  
  7375. /***/ })
  7376.  
  7377. /******/ });