☰

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