| blob | 84873ae576dc5d86085715f0a83af12e2fb18e5a |
1 /*!
2 * QUnit 1.22.0
3 * https://qunitjs.com/
4 *
5 * Copyright jQuery Foundation and other contributors
6 * Released under the MIT license
7 * https://jquery.org/license
8 *
9 * Date: 2016-02-23T15:57Z
10 */
19 };
24 // Store a local window from the global to allow direct references.
38 }
39 }() )
40 };
42 var fileName = ( sourceFromStacktrace( 0 ) || "" ).replace( /(:\d+)+\)?/, "" ).replace( /.+\//, "" );
49 // returns a new Array with the elements that are in a but not in b
58 i--;
60 }
61 }
62 }
64 }
66 // from jquery.js
70 }
75 }
76 }
79 }
81 /**
82 * Makes a clone of an object using only Array or Object as base,
83 * and copies over the own enumerable properties.
84 *
85 * @param {Object} obj
86 * @return {Object} New object with only the own properties (recursively).
87 */
95 }
96 }
98 }
104 // Avoid "Member not found" error in IE8 caused by messing with window.constructor
105 // This block runs on every environment, so `global` is being used instead of `window`
106 // to avoid errors on node.
112 }
113 }
114 }
115 }
118 }
123 }
125 // Consider: typeof null === object
128 }
137 }
149 }
152 }
153 }
155 // Safe object type checking
158 }
172 // allow just a key to turn on a flag, e.g., test.html?noglobals
179 }
180 }
181 }
184 };
186 // Doesn't support IE6 to IE9, it will return undefined on these browsers
187 // See also https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error/Stack
197 }
199 include = [];
203 }
205 }
208 }
209 }
212 // Support: Safari <=6 only
215 // exclude useless self-reference for generated Error objects
218 }
220 // for actual exceptions, this is useful
222 }
223 }
228 // Support: Safari <=7 only, IE <=10 - 11 only
229 // Not all browsers generate the `stack` property for `new Error()`, see also #636
235 }
236 }
239 }
241 /**
242 * Config object: Maintain internal state
243 * Later exposed as QUnit.config
244 * `config` initialized at top of scope
245 */
247 // The queue of tests to run
248 queue: [],
250 // block until document ready
253 // by default, run previously failed tests first
254 // very useful in combination with "Hide passed tests" checked
257 // by default, modify document.title when suite is done
260 // HTML Reporter: collapse every test except the first failing test
261 // If false, all failing tests will be expanded
264 // by default, scroll to top of the page when suite is done
267 // depth up-to which object will be dumped
270 // when enabled, all tests must call expect()
273 // add checkboxes that are persisted in the query-string
274 // when enabled, the id is set to `true` as a `QUnit.config` property
275 urlConfig: [
276 {
280 },
281 {
285 "global object (`window` in Browsers). Stored as query-strings."
286 },
287 {
291 "exceptions in IE reasonable. Stored as query-strings."
292 }
293 ],
295 // Set of all modules.
296 modules: [],
298 // Stack of nested modules
299 moduleStack: [],
301 // The first unnamed module
302 currentModule: {
304 tests: []
305 },
307 callbacks: {}
308 };
312 // Push a loose unnamed module to the modules collection
317 }
319 // String search anywhere in moduleName+testName
324 // Ensure that urlParams.testId is an array
328 }
329 }
333 // Register logging callbacks
343 "QUnit logging methods require a callback function as their first parameters."
344 );
345 }
348 };
350 // DEPRECATED: This will be removed on QUnit 2.0.0+
351 // Stores the registered functions allowing restoring
352 // at verifyLoggingCallbacks() if modified
356 }
361 // Initialize key collection of logging callback
364 }
367 }
368 }
376 }
377 }
379 // DEPRECATED: This will be removed on 2.0.0+
380 // This function verifies if the loggingCallbacks were modified by the user
381 // If so, it will restore it, assign the given callback and print a console warning
390 // Restore the callback function
393 // Assign the deprecated given callback
400 "Reference: https://api.qunitjs.com/category/callbacks/"
401 );
402 }
403 }
404 }
405 }
410 }
412 // `onErrorFnPrev` initialized at top of scope
413 // Preserve other handlers
416 // Cover uncaught exceptions
417 // Returning true will suppress the default browser handler,
418 // returning false will let it run.
423 }
425 // Treat return value as window.onerror itself does,
426 // Only do our handling if not suppressed.
431 }
437 }
439 }
442 };
443 } )();
447 // Figure out if we're running the tests from a server or not
450 // Expose the current QUnit version
455 // call on start of module test to prepend name to all tests
464 }
465 }
467 // DEPRECATED: handles setup/teardown functions,
468 // beforeEach and afterEach should be used instead
472 }
476 }
480 moduleFns = {
483 };
491 }
503 tests: []
504 };
511 }
517 }
521 }
523 },
525 // DEPRECATED: QUnit.asyncTest() will be removed in QUnit 2.0.
534 // DEPRECATED: The functionality of QUnit.start() will be altered in QUnit 2.0.
535 // In QUnit 2.0, invoking it will ONLY affect the `QUnit.config.autostart` blocking behavior.
551 // The page isn't completely loaded yet, so bail out and let `QUnit.load` handle it
554 }
557 // If a test is running, adjust its semaphore
560 // If semaphore is non-numeric, throw error
567 );
569 }
571 // Don't start until equal number of stop-calls
574 }
576 // throw an Error if start is called more often than stop
583 );
585 }
586 }
589 },
591 // DEPRECATED: QUnit.stop() will be removed in QUnit 2.0.
594 // If there isn't a test running, don't allow QUnit.stop() to be called
597 }
599 // If a test is running, adjust its semaphore
603 },
616 // Initialize the configuration options
630 }
631 },
636 }
637 });
643 modulesLog = [];
645 // If the test run hasn't officially begun yet
648 // Record the time of the test run's beginning
653 // Delete the loose unnamed module if unused.
656 }
658 // Avoid unnecessary information by not logging modules' test environments
663 });
664 }
666 // The test run is officially beginning now
669 modules: modulesLog
670 });
671 }
675 }
680 }
689 // Reset async tracking for each phase of the Test lifecycle
691 }
696 }
697 }
701 }
702 }
715 }
718 }
719 }
724 // A slight delay to allow this iteration of the event loop to finish (more assertions, etc.)
729 }
732 }
738 }
739 }
746 // Log the last module results
755 });
756 }
766 runtime: runtime
767 });
768 }
773 }
777 };
778 }
795 // Register unique strings
799 }
800 }
807 });
811 // Skipped tests will fully ignore any sent callback
817 }
818 }
826 // Emit moduleStart when we're switching from one module to another
829 // They could be equal (both undefined) but if the previousModule property doesn't
830 // yet exist it means this is the first test in a suite that isn't wrapped in a
831 // module, in which case we'll just emit a moduleStart event for 'undefined'.
832 // Without this, reporters can get testStart before moduleStart which is a problem.
834 ) {
843 });
844 }
850 });
851 }
858 }
866 });
870 }
871 },
880 }
887 }
895 // else next test will carry the responsibility
898 // Restart the tests if they're blocking
901 }
902 }
907 }
908 },
912 },
922 }
928 }
933 }
934 };
935 },
937 // Currently only used for module level hooks, can be used to add global level ones
944 }
948 }
949 }
951 // Hooks are ignored on skipped tests
954 }
956 },
969 }
980 bad++;
983 }
984 }
995 // HTML Reporter use
999 // Source of Test
1002 // DEPRECATED: this property will be removed in 2.0.0, use runtime instead
1004 });
1006 // QUnit.reset() is deprecated and will be replaced for a new
1007 // fixture reset function on QUnit 2.0/2.1.
1008 // It's still called here for backwards compatibility handling
1012 },
1020 }
1024 // each of these can by async
1028 },
1033 },
1039 },
1042 }
1043 ]);
1044 }
1046 // Prioritize previously failed tests, detected from sessionStorage
1051 },
1055 // resultInfo = { result, actual, expected, message, negative }
1057 details = {
1067 };
1074 }
1075 }
1082 });
1083 },
1089 }
1099 };
1103 }
1109 message: message
1110 });
1111 },
1121 promise,
1129 // else next test will carry the responsibility
1132 // Unblock
1134 }
1135 );
1136 }
1137 }
1138 },
1154 }
1155 }
1157 // Internally-generated tests are always valid
1160 }
1164 }
1168 }
1172 }
1177 },
1184 },
1193 }
1195 // If the filter matches, we need to honour include
1198 }
1200 // Otherwise, do the opposite
1202 }
1203 };
1205 // Resets the test setup. Useful for tests that modify the DOM.
1206 /*
1207 DEPRECATED: Use multiple tests instead of resetting inside a test.
1208 Use testStart or testDone for custom cleanup.
1209 This method will throw an error in 2.0, and will be removed in 2.1
1210 */
1213 // Return on non-browser environments
1214 // This is necessary to not break on node tests
1217 }
1224 }
1225 };
1231 }
1233 // Gets current test obj
1237 };
1239 // Based on Java's String.hashCode, a simple but not
1240 // rigorously collision resistant hashing function
1251 }
1253 // Convert the possibly negative integer hash code into an 8 character hex string, which isn't
1254 // strictly necessary but increases user understanding that the id is a SHA-like hash
1258 }
1261 }
1269 }
1271 }
1277 }
1281 }
1282 }
1291 // in Opera sometimes DOM element ids show up here, ignore them
1294 }
1296 }
1297 }
1298 }
1299 }
1303 deletedGlobals,
1311 }
1316 }
1317 }
1319 // Will be exposed as QUnit.asyncTest
1324 }
1327 }
1329 // Will be exposed as QUnit.test
1338 }
1344 callback: callback
1345 });
1348 }
1350 // Will be exposed as QUnit.skip
1357 });
1360 }
1362 // Will be exposed as QUnit.only
1374 }
1380 callback: callback
1381 });
1384 }
1388 }
1390 // Assert helpers
1393 // Specify the number of expected assertions to guarantee that failed test
1394 // (no assertions are run at all) don't slip through.
1400 }
1401 },
1403 // Increment this Test's semaphore counter, then return a function that
1404 // decrements that counter a maximum of once.
1412 }
1424 }
1428 }
1433 };
1434 },
1436 // Exports test.push() to the user API
1437 // Alias of pushResult.
1445 negative: negative
1446 } );
1447 },
1451 // resultInfo = { result, actual, expected, message, negative }
1455 // Backwards compatibility fix.
1456 // Allows the direct use of global exported assertions and QUnit.assert.*
1457 // Although, it's use is not recommended as it can leak assertions
1458 // to other tests from async tests, because we only get a reference to the current test,
1459 // not exactly the test where assertion were intended to be called.
1462 }
1468 // Allow this assertion to continue running anyway...
1469 }
1473 }
1476 },
1485 message: message
1486 } );
1487 },
1496 message: message
1497 } );
1498 },
1501 /*jshint eqeqeq:false */
1506 message: message
1507 } );
1508 },
1511 /*jshint eqeqeq:false */
1518 } );
1519 },
1528 message: message
1529 } );
1530 },
1541 } );
1542 },
1549 message: message
1550 } );
1551 },
1560 } );
1561 },
1568 message: message
1569 } );
1570 },
1579 } );
1580 },
1588 // 'expected' is optional unless doing string comparison
1592 }
1599 }
1605 // we don't want to validate thrown error
1610 // expected is a regexp
1614 // expected is a string
1618 // expected is a constructor, maybe an Error constructor
1622 // expected is an Error object
1628 // expected is a validation function which returns true if validation passed
1632 }
1633 }
1639 message: message
1640 } );
1641 }
1642 };
1644 // Provide an alternative to assert.throws(), for environments that consider throws a reserved word
1645 // Known to us are: Closure Compiler, Narwhal
1647 /*jshint sub:true */
1649 }());
1665 }
1668 }
1669 }
1671 // Test for equality any JavaScript type.
1672 // Author: Philippe Rathé <prathe@gmail.com>
1675 // Stack to decide between skip/abort functions
1678 // Stack to avoiding loops from circular referencing
1684 /*jshint proto: true */
1686 };
1690 // To catch short annotation VS 'new' annotation of a declaration. e.g.:
1691 // `var i = 1;`
1692 // `var j = new Number(1);`
1695 }
1698 }
1701 }
1707 // Comparing constructors is more strict than using `instanceof`
1710 }
1712 // Ref #851
1713 // If the obj prototype descends from a null constructor, treat it
1714 // as a null prototype.
1717 }
1720 }
1722 // Allow objects with no prototype to be equivalent to
1723 // objects with Object as their constructor.
1727 }
1730 }
1734 }
1747 },
1752 // Include flags in the comparison
1754 },
1756 // - skip when the property is a method of an instance (OOP)
1757 // - abort otherwise,
1758 // initial === would have catch identical references anyway
1762 },
1769 // safe and faster
1771 }
1773 // Track reference to avoid circular references
1788 }
1789 }
1790 }
1795 }
1796 }
1800 },
1805 aArray = [];
1808 });
1809 bArray = [];
1812 });
1815 },
1820 aArray = [];
1823 });
1824 bArray = [];
1827 });
1830 },
1835 // Default to true
1842 }
1844 // Stack constructor before traversing properties
1847 // Track reference to avoid circular references
1851 // Be strict: don't ensure hasOwnProperty and go deep
1863 }
1864 }
1865 }
1870 }
1871 }
1876 // Unstack, we are done
1881 // Collect b's properties
1883 }
1885 // Ensures identical properties name
1887 }
1888 };
1893 }
1895 // The real equiv function
1898 // We're done when there's nothing more to compare
1901 }
1903 // Require type-specific equality
1906 // ...across all consecutive argument pairs
1908 }
1911 }());
1913 // Based on jsDump by Ariel Flesler
1914 // http://flesler.blogspot.com/2008/05/jsdump-pretty-dump-of-any-javascript.html
1918 }
1919 function literal( o ) {
1921 }
1922 function join( pre, arr, post ) {
1923 var s = dump.separator(),
1924 base = dump.indent(),
1925 inner = dump.indent( 1 );
1926 if ( arr.join ) {
1928 }
1929 if ( !arr ) {
1930 return pre + post;
1931 }
1932 return [ pre, inner + arr, base + post ].join( s );
1933 }
1934 function array( arr, stack ) {
1935 var i = arr.length,
1936 ret = new Array( i );
1938 if ( dump.maxDepth && dump.depth > dump.maxDepth ) {
1940 }
1942 this.up();
1943 while ( i-- ) {
1944 ret[ i ] = this.parse( arr[ i ], undefined, stack );
1945 }
1946 this.down();
1948 }
1950 var reName = /^function (\w+)/,
1951 dump = {
1953 // objType is used mostly internally, you can fix a (custom) type in advance
1954 parse: function( obj, objType, stack ) {
1955 stack = stack || [];
1956 var res, parser, parserType,
1957 inStack = inArray( obj, stack );
1959 if ( inStack !== -1 ) {
1961 }
1963 objType = objType || this.typeOf( obj );
1964 parser = this.parsers[ objType ];
1965 parserType = typeof parser;
1968 stack.push( obj );
1969 res = parser.call( this, obj, stack );
1970 stack.pop();
1971 return res;
1972 }
1974 },
1975 typeOf: function( obj ) {
1976 var type;
1977 if ( obj === null ) {
1987 } else if ( obj.setInterval !== undefined &&
1988 obj.document !== undefined &&
1989 obj.nodeType === undefined ) {
1991 } else if ( obj.nodeType === 9 ) {
1993 } else if ( obj.nodeType ) {
1995 } else if (
1997 // native arrays
2000 // NodeList objects
2002 ( obj.length ? obj.item( 0 ) === obj[ 0 ] : ( obj.item( 0 ) === null &&
2003 obj[ 0 ] === undefined ) ) )
2004 ) {
2006 } else if ( obj.constructor === Error.prototype.constructor ) {
2008 } else {
2009 type = typeof obj;
2010 }
2011 return type;
2012 },
2013 separator: function() {
2015 },
2016 // extra can be a number, shortcut for increasing-calling-decreasing
2017 indent: function( extra ) {
2018 if ( !this.multiline ) {
2020 }
2021 var chr = this.indentChar;
2022 if ( this.HTML ) {
2024 }
2025 return new Array( this.depth + ( extra || 0 ) ).join( chr );
2026 },
2027 up: function( a ) {
2028 this.depth += a || 1;
2029 },
2030 down: function( a ) {
2031 this.depth -= a || 1;
2032 },
2033 setParser: function( name, parser ) {
2034 this.parsers[ name ] = parser;
2035 },
2036 // The next 3 are exposed so you can use them
2037 quote: quote,
2038 literal: literal,
2039 join: join,
2040 //
2041 depth: 1,
2042 maxDepth: QUnit.config.maxDepth,
2044 // This is the list of parsers, to modify them, use dump.setParser
2045 parsers: {
2048 error: function( error ) {
2050 },
2057 // functions never have name in IE
2060 if ( name ) {
2062 }
2067 },
2068 array: array,
2069 nodelist: array,
2071 object: function( map, stack ) {
2072 var keys, key, val, i, nonEnumerableProperties,
2073 ret = [];
2075 if ( dump.maxDepth && dump.depth > dump.maxDepth ) {
2077 }
2079 dump.up();
2080 keys = [];
2081 for ( key in map ) {
2082 keys.push( key );
2083 }
2085 // Some properties are not always enumerable on Error objects.
2087 for ( i in nonEnumerableProperties ) {
2088 key = nonEnumerableProperties[ i ];
2089 if ( key in map && inArray( key, keys ) < 0 ) {
2090 keys.push( key );
2091 }
2092 }
2093 keys.sort();
2094 for ( i = 0; i < keys.length; i++ ) {
2095 key = keys[ i ];
2096 val = map[ key ];
2098 dump.parse( val, undefined, stack ) );
2099 }
2100 dump.down();
2102 },
2103 node: function( node ) {
2104 var len, i, val,
2107 tag = node.nodeName.toLowerCase(),
2108 ret = open + tag,
2109 attrs = node.attributes;
2111 if ( attrs ) {
2112 for ( i = 0, len = attrs.length; i < len; i++ ) {
2113 val = attrs[ i ].nodeValue;
2115 // IE6 includes all attributes in .attributes, even ones not explicitly
2121 }
2122 }
2123 }
2124 ret += close;
2126 // Show content of TextNode or CDATASection
2127 if ( node.nodeType === 3 || node.nodeType === 4 ) {
2128 ret += node.nodeValue;
2129 }
2132 },
2134 // function calls it internally, it's the arguments part of the function
2135 functionArgs: function( fn ) {
2136 var args,
2137 l = fn.length;
2139 if ( !l ) {
2141 }
2143 args = new Array( l );
2144 while ( l-- ) {
2146 // 97 is 'a'
2147 args[ l ] = String.fromCharCode( 97 + l );
2148 }
2150 },
2151 // object calls it internally, the key part of an item in a map
2152 key: quote,
2153 // function calls it internally, it's the content of the function
2155 // node calls it internally, it's a html attribute value
2156 attribute: quote,
2157 string: quote,
2158 date: quote,
2159 regexp: literal,
2160 number: literal,
2162 },
2164 HTML: false,
2165 // indentation unit
2168 multiline: true
2169 };
2171 return dump;
2172 }());
2174 // back compat
2175 QUnit.jsDump = QUnit.dump;
2177 // Deprecated
2178 // Extend assert methods to QUnit for Backwards compatibility
2179 (function() {
2180 var i,
2181 assertions = Assert.prototype;
2183 function applyCurrent( current ) {
2184 return function() {
2185 var assert = new Assert( QUnit.config.current );
2186 current.apply( assert, arguments );
2187 };
2188 }
2190 for ( i in assertions ) {
2191 QUnit[ i ] = applyCurrent( assertions[ i ] );
2192 }
2193 })();
2195 // For browser, export only select globals
2196 if ( defined.document ) {
2198 (function() {
2199 var i, l,
2200 keys = [
2219 ];
2221 for ( i = 0, l = keys.length; i < l; i++ ) {
2222 window[ keys[ i ] ] = QUnit[ keys[ i ] ];
2223 }
2224 })();
2226 window.QUnit = QUnit;
2227 }
2229 // For nodejs
2231 module.exports = QUnit;
2233 // For consistency with CommonJS environments' exports
2234 module.exports.QUnit = QUnit;
2235 }
2237 // For CommonJS with exports, but without module.exports, like Rhino
2239 exports.QUnit = QUnit;
2240 }
2243 define( function() {
2244 return QUnit;
2245 } );
2246 QUnit.config.autostart = false;
2247 }
2249 /*
2250 * This file is a modified version of google-diff-match-patch's JavaScript implementation
2251 * (https://code.google.com/p/google-diff-match-patch/source/browse/trunk/javascript/diff_match_patch_uncompressed.js),
2252 * modifications are licensed as more fully set forth in LICENSE.txt.
2253 *
2254 * The original source of google-diff-match-patch is attributable and licensed as follows:
2255 *
2256 * Copyright 2006 Google Inc.
2257 * https://code.google.com/p/google-diff-match-patch/
2258 *
2260 * you may not use this file except in compliance with the License.
2261 * You may obtain a copy of the License at
2262 *
2263 * https://www.apache.org/licenses/LICENSE-2.0
2264 *
2265 * Unless required by applicable law or agreed to in writing, software
2267 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2268 * See the License for the specific language governing permissions and
2269 * limitations under the License.
2270 *
2271 * More Info:
2272 * https://code.google.com/p/google-diff-match-patch/
2273 *
2274 * Usage: QUnit.diff(expected, actual)
2275 *
2276 */
2277 QUnit.diff = ( function() {
2278 function DiffMatchPatch() {
2279 }
2281 // DIFF FUNCTIONS
2283 /**
2284 * The data structure representing a diff is an array of tuples:
2285 * [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]
2286 * which means: delete 'Hello', add 'Goodbye' and keep ' world.'
2287 */
2288 var DIFF_DELETE = -1,
2289 DIFF_INSERT = 1,
2290 DIFF_EQUAL = 0;
2292 /**
2293 * Find the differences between two texts. Simplifies the problem by stripping
2294 * any common prefix or suffix off the texts before diffing.
2295 * @param {string} text1 Old string to be diffed.
2296 * @param {string} text2 New string to be diffed.
2297 * @param {boolean=} optChecklines Optional speedup flag. If present and false,
2298 * then don't run a line-level diff first to identify the changed areas.
2299 * Defaults to true, which does a faster, slightly less optimal diff.
2300 * @return {!Array.<!DiffMatchPatch.Diff>} Array of diff tuples.
2301 */
2302 DiffMatchPatch.prototype.DiffMain = function( text1, text2, optChecklines ) {
2303 var deadline, checklines, commonlength,
2304 commonprefix, commonsuffix, diffs;
2306 // The diff must be complete in up to 1 second.
2307 deadline = ( new Date() ).getTime() + 1000;
2309 // Check for null inputs.
2310 if ( text1 === null || text2 === null ) {
2312 }
2314 // Check for equality (speedup).
2315 if ( text1 === text2 ) {
2316 if ( text1 ) {
2317 return [
2318 [ DIFF_EQUAL, text1 ]
2319 ];
2320 }
2321 return [];
2322 }
2325 optChecklines = true;
2326 }
2328 checklines = optChecklines;
2330 // Trim off common prefix (speedup).
2331 commonlength = this.diffCommonPrefix( text1, text2 );
2332 commonprefix = text1.substring( 0, commonlength );
2333 text1 = text1.substring( commonlength );
2334 text2 = text2.substring( commonlength );
2336 // Trim off common suffix (speedup).
2337 commonlength = this.diffCommonSuffix( text1, text2 );
2338 commonsuffix = text1.substring( text1.length - commonlength );
2339 text1 = text1.substring( 0, text1.length - commonlength );
2340 text2 = text2.substring( 0, text2.length - commonlength );
2342 // Compute the diff on the middle block.
2343 diffs = this.diffCompute( text1, text2, checklines, deadline );
2345 // Restore the prefix and suffix.
2346 if ( commonprefix ) {
2347 diffs.unshift( [ DIFF_EQUAL, commonprefix ] );
2348 }
2349 if ( commonsuffix ) {
2350 diffs.push( [ DIFF_EQUAL, commonsuffix ] );
2351 }
2352 this.diffCleanupMerge( diffs );
2353 return diffs;
2354 };
2356 /**
2357 * Reduce the number of edits by eliminating operationally trivial equalities.
2358 * @param {!Array.<!DiffMatchPatch.Diff>} diffs Array of diff tuples.
2359 */
2360 DiffMatchPatch.prototype.diffCleanupEfficiency = function( diffs ) {
2361 var changes, equalities, equalitiesLength, lastequality,
2362 pointer, preIns, preDel, postIns, postDel;
2363 changes = false;
2364 equalities = []; // Stack of indices where equalities are found.
2365 equalitiesLength = 0; // Keeping our own length var is faster in JS.
2366 /** @type {?string} */
2367 lastequality = null;
2368 // Always equal to diffs[equalities[equalitiesLength - 1]][1]
2369 pointer = 0; // Index of current position.
2370 // Is there an insertion operation before the last equality.
2371 preIns = false;
2372 // Is there a deletion operation before the last equality.
2373 preDel = false;
2374 // Is there an insertion operation after the last equality.
2375 postIns = false;
2376 // Is there a deletion operation after the last equality.
2377 postDel = false;
2378 while ( pointer < diffs.length ) {
2380 // Equality found.
2381 if ( diffs[ pointer ][ 0 ] === DIFF_EQUAL ) {
2382 if ( diffs[ pointer ][ 1 ].length < 4 && ( postIns || postDel ) ) {
2384 // Candidate found.
2385 equalities[ equalitiesLength++ ] = pointer;
2386 preIns = postIns;
2387 preDel = postDel;
2388 lastequality = diffs[ pointer ][ 1 ];
2389 } else {
2391 // Not a candidate, and can never become one.
2392 equalitiesLength = 0;
2393 lastequality = null;
2394 }
2395 postIns = postDel = false;
2397 // An insertion or deletion.
2398 } else {
2400 if ( diffs[ pointer ][ 0 ] === DIFF_DELETE ) {
2401 postDel = true;
2402 } else {
2403 postIns = true;
2404 }
2406 /*
2407 * Five types to be split:
2408 * <ins>A</ins><del>B</del>XY<ins>C</ins><del>D</del>
2409 * <ins>A</ins>X<ins>C</ins><del>D</del>
2410 * <ins>A</ins><del>B</del>X<ins>C</ins>
2411 * <ins>A</del>X<ins>C</ins><del>D</del>
2412 * <ins>A</ins><del>B</del>X<del>C</del>
2413 */
2414 if ( lastequality && ( ( preIns && preDel && postIns && postDel ) ||
2415 ( ( lastequality.length < 2 ) &&
2416 ( preIns + preDel + postIns + postDel ) === 3 ) ) ) {
2418 // Duplicate record.
2419 diffs.splice(
2420 equalities[ equalitiesLength - 1 ],
2421 0,
2422 [ DIFF_DELETE, lastequality ]
2423 );
2425 // Change second copy to insert.
2426 diffs[ equalities[ equalitiesLength - 1 ] + 1 ][ 0 ] = DIFF_INSERT;
2427 equalitiesLength--; // Throw away the equality we just deleted;
2428 lastequality = null;
2429 if ( preIns && preDel ) {
2430 // No changes made which could affect previous entry, keep going.
2431 postIns = postDel = true;
2432 equalitiesLength = 0;
2433 } else {
2434 equalitiesLength--; // Throw away the previous equality.
2435 pointer = equalitiesLength > 0 ? equalities[ equalitiesLength - 1 ] : -1;
2436 postIns = postDel = false;
2437 }
2438 changes = true;
2439 }
2440 }
2441 pointer++;
2442 }
2444 if ( changes ) {
2445 this.diffCleanupMerge( diffs );
2446 }
2447 };
2449 /**
2450 * Convert a diff array into a pretty HTML report.
2451 * @param {!Array.<!DiffMatchPatch.Diff>} diffs Array of diff tuples.
2452 * @param {integer} string to be beautified.
2453 * @return {string} HTML representation.
2454 */
2455 DiffMatchPatch.prototype.diffPrettyHtml = function( diffs ) {
2456 var op, data, x,
2457 html = [];
2458 for ( x = 0; x < diffs.length; x++ ) {
2459 op = diffs[ x ][ 0 ]; // Operation (insert, delete, equal)
2460 data = diffs[ x ][ 1 ]; // Text of change.
2461 switch ( op ) {
2462 case DIFF_INSERT:
2464 break;
2465 case DIFF_DELETE:
2467 break;
2468 case DIFF_EQUAL:
2470 break;
2471 }
2472 }
2474 };
2476 /**
2477 * Determine the common prefix of two strings.
2478 * @param {string} text1 First string.
2479 * @param {string} text2 Second string.
2480 * @return {number} The number of characters common to the start of each
2481 * string.
2482 */
2483 DiffMatchPatch.prototype.diffCommonPrefix = function( text1, text2 ) {
2484 var pointermid, pointermax, pointermin, pointerstart;
2485 // Quick check for common null cases.
2486 if ( !text1 || !text2 || text1.charAt( 0 ) !== text2.charAt( 0 ) ) {
2487 return 0;
2488 }
2489 // Binary search.
2490 // Performance analysis: https://neil.fraser.name/news/2007/10/09/
2491 pointermin = 0;
2492 pointermax = Math.min( text1.length, text2.length );
2493 pointermid = pointermax;
2494 pointerstart = 0;
2495 while ( pointermin < pointermid ) {
2496 if ( text1.substring( pointerstart, pointermid ) ===
2497 text2.substring( pointerstart, pointermid ) ) {
2498 pointermin = pointermid;
2499 pointerstart = pointermin;
2500 } else {
2501 pointermax = pointermid;
2502 }
2503 pointermid = Math.floor( ( pointermax - pointermin ) / 2 + pointermin );
2504 }
2505 return pointermid;
2506 };
2508 /**
2509 * Determine the common suffix of two strings.
2510 * @param {string} text1 First string.
2511 * @param {string} text2 Second string.
2512 * @return {number} The number of characters common to the end of each string.
2513 */
2514 DiffMatchPatch.prototype.diffCommonSuffix = function( text1, text2 ) {
2515 var pointermid, pointermax, pointermin, pointerend;
2516 // Quick check for common null cases.
2517 if ( !text1 ||
2518 !text2 ||
2519 text1.charAt( text1.length - 1 ) !== text2.charAt( text2.length - 1 ) ) {
2520 return 0;
2521 }
2522 // Binary search.
2523 // Performance analysis: https://neil.fraser.name/news/2007/10/09/
2524 pointermin = 0;
2525 pointermax = Math.min( text1.length, text2.length );
2526 pointermid = pointermax;
2527 pointerend = 0;
2528 while ( pointermin < pointermid ) {
2529 if ( text1.substring( text1.length - pointermid, text1.length - pointerend ) ===
2530 text2.substring( text2.length - pointermid, text2.length - pointerend ) ) {
2531 pointermin = pointermid;
2532 pointerend = pointermin;
2533 } else {
2534 pointermax = pointermid;
2535 }
2536 pointermid = Math.floor( ( pointermax - pointermin ) / 2 + pointermin );
2537 }
2538 return pointermid;
2539 };
2541 /**
2542 * Find the differences between two texts. Assumes that the texts do not
2543 * have any common prefix or suffix.
2544 * @param {string} text1 Old string to be diffed.
2545 * @param {string} text2 New string to be diffed.
2546 * @param {boolean} checklines Speedup flag. If false, then don't run a
2547 * line-level diff first to identify the changed areas.
2548 * If true, then run a faster, slightly less optimal diff.
2549 * @param {number} deadline Time when the diff should be complete by.
2550 * @return {!Array.<!DiffMatchPatch.Diff>} Array of diff tuples.
2551 * @private
2552 */
2553 DiffMatchPatch.prototype.diffCompute = function( text1, text2, checklines, deadline ) {
2554 var diffs, longtext, shorttext, i, hm,
2555 text1A, text2A, text1B, text2B,
2556 midCommon, diffsA, diffsB;
2558 if ( !text1 ) {
2559 // Just add some text (speedup).
2560 return [
2561 [ DIFF_INSERT, text2 ]
2562 ];
2563 }
2565 if ( !text2 ) {
2566 // Just delete some text (speedup).
2567 return [
2568 [ DIFF_DELETE, text1 ]
2569 ];
2570 }
2572 longtext = text1.length > text2.length ? text1 : text2;
2573 shorttext = text1.length > text2.length ? text2 : text1;
2574 i = longtext.indexOf( shorttext );
2575 if ( i !== -1 ) {
2576 // Shorter text is inside the longer text (speedup).
2577 diffs = [
2578 [ DIFF_INSERT, longtext.substring( 0, i ) ],
2579 [ DIFF_EQUAL, shorttext ],
2580 [ DIFF_INSERT, longtext.substring( i + shorttext.length ) ]
2581 ];
2582 // Swap insertions for deletions if diff is reversed.
2583 if ( text1.length > text2.length ) {
2584 diffs[ 0 ][ 0 ] = diffs[ 2 ][ 0 ] = DIFF_DELETE;
2585 }
2586 return diffs;
2587 }
2589 if ( shorttext.length === 1 ) {
2590 // Single character string.
2591 // After the previous speedup, the character can't be an equality.
2592 return [
2593 [ DIFF_DELETE, text1 ],
2594 [ DIFF_INSERT, text2 ]
2595 ];
2596 }
2598 // Check to see if the problem can be split in two.
2599 hm = this.diffHalfMatch( text1, text2 );
2600 if ( hm ) {
2601 // A half-match was found, sort out the return data.
2602 text1A = hm[ 0 ];
2603 text1B = hm[ 1 ];
2604 text2A = hm[ 2 ];
2605 text2B = hm[ 3 ];
2606 midCommon = hm[ 4 ];
2607 // Send both pairs off for separate processing.
2608 diffsA = this.DiffMain( text1A, text2A, checklines, deadline );
2609 diffsB = this.DiffMain( text1B, text2B, checklines, deadline );
2610 // Merge the results.
2611 return diffsA.concat( [
2612 [ DIFF_EQUAL, midCommon ]
2613 ], diffsB );
2614 }
2616 if ( checklines && text1.length > 100 && text2.length > 100 ) {
2617 return this.diffLineMode( text1, text2, deadline );
2618 }
2620 return this.diffBisect( text1, text2, deadline );
2621 };
2623 /**
2624 * Do the two texts share a substring which is at least half the length of the
2625 * longer text?
2626 * This speedup can produce non-minimal diffs.
2627 * @param {string} text1 First string.
2628 * @param {string} text2 Second string.
2629 * @return {Array.<string>} Five element Array, containing the prefix of
2630 * text1, the suffix of text1, the prefix of text2, the suffix of
2631 * text2 and the common middle. Or null if there was no match.
2632 * @private
2633 */
2634 DiffMatchPatch.prototype.diffHalfMatch = function( text1, text2 ) {
2635 var longtext, shorttext, dmp,
2636 text1A, text2B, text2A, text1B, midCommon,
2637 hm1, hm2, hm;
2639 longtext = text1.length > text2.length ? text1 : text2;
2640 shorttext = text1.length > text2.length ? text2 : text1;
2641 if ( longtext.length < 4 || shorttext.length * 2 < longtext.length ) {
2642 return null; // Pointless.
2643 }
2644 dmp = this; // 'this' becomes 'window' in a closure.
2646 /**
2647 * Does a substring of shorttext exist within longtext such that the substring
2648 * is at least half the length of longtext?
2649 * Closure, but does not reference any external variables.
2650 * @param {string} longtext Longer string.
2651 * @param {string} shorttext Shorter string.
2652 * @param {number} i Start index of quarter length substring within longtext.
2653 * @return {Array.<string>} Five element Array, containing the prefix of
2654 * longtext, the suffix of longtext, the prefix of shorttext, the suffix
2655 * of shorttext and the common middle. Or null if there was no match.
2656 * @private
2657 */
2658 function diffHalfMatchI( longtext, shorttext, i ) {
2659 var seed, j, bestCommon, prefixLength, suffixLength,
2660 bestLongtextA, bestLongtextB, bestShorttextA, bestShorttextB;
2661 // Start with a 1/4 length substring at position i as a seed.
2662 seed = longtext.substring( i, i + Math.floor( longtext.length / 4 ) );
2663 j = -1;
2665 while ( ( j = shorttext.indexOf( seed, j + 1 ) ) !== -1 ) {
2666 prefixLength = dmp.diffCommonPrefix( longtext.substring( i ),
2667 shorttext.substring( j ) );
2668 suffixLength = dmp.diffCommonSuffix( longtext.substring( 0, i ),
2669 shorttext.substring( 0, j ) );
2670 if ( bestCommon.length < suffixLength + prefixLength ) {
2671 bestCommon = shorttext.substring( j - suffixLength, j ) +
2672 shorttext.substring( j, j + prefixLength );
2673 bestLongtextA = longtext.substring( 0, i - suffixLength );
2674 bestLongtextB = longtext.substring( i + prefixLength );
2675 bestShorttextA = shorttext.substring( 0, j - suffixLength );
2676 bestShorttextB = shorttext.substring( j + prefixLength );
2677 }
2678 }
2679 if ( bestCommon.length * 2 >= longtext.length ) {
2680 return [ bestLongtextA, bestLongtextB,
2681 bestShorttextA, bestShorttextB, bestCommon
2682 ];
2683 } else {
2684 return null;
2685 }
2686 }
2688 // First check if the second quarter is the seed for a half-match.
2689 hm1 = diffHalfMatchI( longtext, shorttext,
2690 Math.ceil( longtext.length / 4 ) );
2691 // Check again based on the third quarter.
2692 hm2 = diffHalfMatchI( longtext, shorttext,
2693 Math.ceil( longtext.length / 2 ) );
2694 if ( !hm1 && !hm2 ) {
2695 return null;
2696 } else if ( !hm2 ) {
2697 hm = hm1;
2698 } else if ( !hm1 ) {
2699 hm = hm2;
2700 } else {
2701 // Both matched. Select the longest.
2702 hm = hm1[ 4 ].length > hm2[ 4 ].length ? hm1 : hm2;
2703 }
2705 // A half-match was found, sort out the return data.
2706 text1A, text1B, text2A, text2B;
2707 if ( text1.length > text2.length ) {
2708 text1A = hm[ 0 ];
2709 text1B = hm[ 1 ];
2710 text2A = hm[ 2 ];
2711 text2B = hm[ 3 ];
2712 } else {
2713 text2A = hm[ 0 ];
2714 text2B = hm[ 1 ];
2715 text1A = hm[ 2 ];
2716 text1B = hm[ 3 ];
2717 }
2718 midCommon = hm[ 4 ];
2719 return [ text1A, text1B, text2A, text2B, midCommon ];
2720 };
2722 /**
2723 * Do a quick line-level diff on both strings, then rediff the parts for
2724 * greater accuracy.
2725 * This speedup can produce non-minimal diffs.
2726 * @param {string} text1 Old string to be diffed.
2727 * @param {string} text2 New string to be diffed.
2728 * @param {number} deadline Time when the diff should be complete by.
2729 * @return {!Array.<!DiffMatchPatch.Diff>} Array of diff tuples.
2730 * @private
2731 */
2732 DiffMatchPatch.prototype.diffLineMode = function( text1, text2, deadline ) {
2733 var a, diffs, linearray, pointer, countInsert,
2734 countDelete, textInsert, textDelete, j;
2735 // Scan the text on a line-by-line basis first.
2736 a = this.diffLinesToChars( text1, text2 );
2737 text1 = a.chars1;
2738 text2 = a.chars2;
2739 linearray = a.lineArray;
2741 diffs = this.DiffMain( text1, text2, false, deadline );
2743 // Convert the diff back to original text.
2744 this.diffCharsToLines( diffs, linearray );
2745 // Eliminate freak matches (e.g. blank lines)
2746 this.diffCleanupSemantic( diffs );
2748 // Rediff any replacement blocks, this time character-by-character.
2749 // Add a dummy entry at the end.
2751 pointer = 0;
2752 countDelete = 0;
2753 countInsert = 0;
2756 while ( pointer < diffs.length ) {
2757 switch ( diffs[ pointer ][ 0 ] ) {
2758 case DIFF_INSERT:
2759 countInsert++;
2760 textInsert += diffs[ pointer ][ 1 ];
2761 break;
2762 case DIFF_DELETE:
2763 countDelete++;
2764 textDelete += diffs[ pointer ][ 1 ];
2765 break;
2766 case DIFF_EQUAL:
2767 // Upon reaching an equality, check for prior redundancies.
2768 if ( countDelete >= 1 && countInsert >= 1 ) {
2769 // Delete the offending records and add the merged ones.
2770 diffs.splice( pointer - countDelete - countInsert,
2771 countDelete + countInsert );
2772 pointer = pointer - countDelete - countInsert;
2773 a = this.DiffMain( textDelete, textInsert, false, deadline );
2774 for ( j = a.length - 1; j >= 0; j-- ) {
2775 diffs.splice( pointer, 0, a[ j ] );
2776 }
2777 pointer = pointer + a.length;
2778 }
2779 countInsert = 0;
2780 countDelete = 0;
2783 break;
2784 }
2785 pointer++;
2786 }
2787 diffs.pop(); // Remove the dummy entry at the end.
2789 return diffs;
2790 };
2792 /**
2793 * Find the 'middle snake' of a diff, split the problem in two
2794 * and return the recursively constructed diff.
2795 * See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations.
2796 * @param {string} text1 Old string to be diffed.
2797 * @param {string} text2 New string to be diffed.
2798 * @param {number} deadline Time at which to bail if not yet complete.
2799 * @return {!Array.<!DiffMatchPatch.Diff>} Array of diff tuples.
2800 * @private
2801 */
2802 DiffMatchPatch.prototype.diffBisect = function( text1, text2, deadline ) {
2803 var text1Length, text2Length, maxD, vOffset, vLength,
2804 v1, v2, x, delta, front, k1start, k1end, k2start,
2805 k2end, k2Offset, k1Offset, x1, x2, y1, y2, d, k1, k2;
2806 // Cache the text lengths to prevent multiple calls.
2807 text1Length = text1.length;
2808 text2Length = text2.length;
2809 maxD = Math.ceil( ( text1Length + text2Length ) / 2 );
2810 vOffset = maxD;
2811 vLength = 2 * maxD;
2812 v1 = new Array( vLength );
2813 v2 = new Array( vLength );
2814 // Setting all elements to -1 is faster in Chrome & Firefox than mixing
2815 // integers and undefined.
2816 for ( x = 0; x < vLength; x++ ) {
2817 v1[ x ] = -1;
2818 v2[ x ] = -1;
2819 }
2820 v1[ vOffset + 1 ] = 0;
2821 v2[ vOffset + 1 ] = 0;
2822 delta = text1Length - text2Length;
2823 // If the total number of characters is odd, then the front path will collide
2824 // with the reverse path.
2825 front = ( delta % 2 !== 0 );
2826 // Offsets for start and end of k loop.
2827 // Prevents mapping of space beyond the grid.
2828 k1start = 0;
2829 k1end = 0;
2830 k2start = 0;
2831 k2end = 0;
2832 for ( d = 0; d < maxD; d++ ) {
2833 // Bail out if deadline is reached.
2834 if ( ( new Date() ).getTime() > deadline ) {
2835 break;
2836 }
2838 // Walk the front path one step.
2839 for ( k1 = -d + k1start; k1 <= d - k1end; k1 += 2 ) {
2840 k1Offset = vOffset + k1;
2841 if ( k1 === -d || ( k1 !== d && v1[ k1Offset - 1 ] < v1[ k1Offset + 1 ] ) ) {
2842 x1 = v1[ k1Offset + 1 ];
2843 } else {
2844 x1 = v1[ k1Offset - 1 ] + 1;
2845 }
2846 y1 = x1 - k1;
2847 while ( x1 < text1Length && y1 < text2Length &&
2848 text1.charAt( x1 ) === text2.charAt( y1 ) ) {
2849 x1++;
2850 y1++;
2851 }
2852 v1[ k1Offset ] = x1;
2853 if ( x1 > text1Length ) {
2854 // Ran off the right of the graph.
2855 k1end += 2;
2856 } else if ( y1 > text2Length ) {
2857 // Ran off the bottom of the graph.
2858 k1start += 2;
2859 } else if ( front ) {
2860 k2Offset = vOffset + delta - k1;
2861 if ( k2Offset >= 0 && k2Offset < vLength && v2[ k2Offset ] !== -1 ) {
2862 // Mirror x2 onto top-left coordinate system.
2863 x2 = text1Length - v2[ k2Offset ];
2864 if ( x1 >= x2 ) {
2865 // Overlap detected.
2866 return this.diffBisectSplit( text1, text2, x1, y1, deadline );
2867 }
2868 }
2869 }
2870 }
2872 // Walk the reverse path one step.
2873 for ( k2 = -d + k2start; k2 <= d - k2end; k2 += 2 ) {
2874 k2Offset = vOffset + k2;
2875 if ( k2 === -d || ( k2 !== d && v2[ k2Offset - 1 ] < v2[ k2Offset + 1 ] ) ) {
2876 x2 = v2[ k2Offset + 1 ];
2877 } else {
2878 x2 = v2[ k2Offset - 1 ] + 1;
2879 }
2880 y2 = x2 - k2;
2881 while ( x2 < text1Length && y2 < text2Length &&
2882 text1.charAt( text1Length - x2 - 1 ) ===
2883 text2.charAt( text2Length - y2 - 1 ) ) {
2884 x2++;
2885 y2++;
2886 }
2887 v2[ k2Offset ] = x2;
2888 if ( x2 > text1Length ) {
2889 // Ran off the left of the graph.
2890 k2end += 2;
2891 } else if ( y2 > text2Length ) {
2892 // Ran off the top of the graph.
2893 k2start += 2;
2894 } else if ( !front ) {
2895 k1Offset = vOffset + delta - k2;
2896 if ( k1Offset >= 0 && k1Offset < vLength && v1[ k1Offset ] !== -1 ) {
2897 x1 = v1[ k1Offset ];
2898 y1 = vOffset + x1 - k1Offset;
2899 // Mirror x2 onto top-left coordinate system.
2900 x2 = text1Length - x2;
2901 if ( x1 >= x2 ) {
2902 // Overlap detected.
2903 return this.diffBisectSplit( text1, text2, x1, y1, deadline );
2904 }
2905 }
2906 }
2907 }
2908 }
2909 // Diff took too long and hit the deadline or
2910 // number of diffs equals number of characters, no commonality at all.
2911 return [
2912 [ DIFF_DELETE, text1 ],
2913 [ DIFF_INSERT, text2 ]
2914 ];
2915 };
2917 /**
2918 * Given the location of the 'middle snake', split the diff in two parts
2919 * and recurse.
2920 * @param {string} text1 Old string to be diffed.
2921 * @param {string} text2 New string to be diffed.
2922 * @param {number} x Index of split point in text1.
2923 * @param {number} y Index of split point in text2.
2924 * @param {number} deadline Time at which to bail if not yet complete.
2925 * @return {!Array.<!DiffMatchPatch.Diff>} Array of diff tuples.
2926 * @private
2927 */
2928 DiffMatchPatch.prototype.diffBisectSplit = function( text1, text2, x, y, deadline ) {
2929 var text1a, text1b, text2a, text2b, diffs, diffsb;
2930 text1a = text1.substring( 0, x );
2931 text2a = text2.substring( 0, y );
2932 text1b = text1.substring( x );
2933 text2b = text2.substring( y );
2935 // Compute both diffs serially.
2936 diffs = this.DiffMain( text1a, text2a, false, deadline );
2937 diffsb = this.DiffMain( text1b, text2b, false, deadline );
2939 return diffs.concat( diffsb );
2940 };
2942 /**
2943 * Reduce the number of edits by eliminating semantically trivial equalities.
2944 * @param {!Array.<!DiffMatchPatch.Diff>} diffs Array of diff tuples.
2945 */
2946 DiffMatchPatch.prototype.diffCleanupSemantic = function( diffs ) {
2947 var changes, equalities, equalitiesLength, lastequality,
2948 pointer, lengthInsertions2, lengthDeletions2, lengthInsertions1,
2949 lengthDeletions1, deletion, insertion, overlapLength1, overlapLength2;
2950 changes = false;
2951 equalities = []; // Stack of indices where equalities are found.
2952 equalitiesLength = 0; // Keeping our own length var is faster in JS.
2953 /** @type {?string} */
2954 lastequality = null;
2955 // Always equal to diffs[equalities[equalitiesLength - 1]][1]
2956 pointer = 0; // Index of current position.
2957 // Number of characters that changed prior to the equality.
2958 lengthInsertions1 = 0;
2959 lengthDeletions1 = 0;
2960 // Number of characters that changed after the equality.
2961 lengthInsertions2 = 0;
2962 lengthDeletions2 = 0;
2963 while ( pointer < diffs.length ) {
2964 if ( diffs[ pointer ][ 0 ] === DIFF_EQUAL ) { // Equality found.
2965 equalities[ equalitiesLength++ ] = pointer;
2966 lengthInsertions1 = lengthInsertions2;
2967 lengthDeletions1 = lengthDeletions2;
2968 lengthInsertions2 = 0;
2969 lengthDeletions2 = 0;
2970 lastequality = diffs[ pointer ][ 1 ];
2971 } else { // An insertion or deletion.
2972 if ( diffs[ pointer ][ 0 ] === DIFF_INSERT ) {
2973 lengthInsertions2 += diffs[ pointer ][ 1 ].length;
2974 } else {
2975 lengthDeletions2 += diffs[ pointer ][ 1 ].length;
2976 }
2977 // Eliminate an equality that is smaller or equal to the edits on both
2978 // sides of it.
2979 if ( lastequality && ( lastequality.length <=
2980 Math.max( lengthInsertions1, lengthDeletions1 ) ) &&
2981 ( lastequality.length <= Math.max( lengthInsertions2,
2982 lengthDeletions2 ) ) ) {
2984 // Duplicate record.
2985 diffs.splice(
2986 equalities[ equalitiesLength - 1 ],
2987 0,
2988 [ DIFF_DELETE, lastequality ]
2989 );
2991 // Change second copy to insert.
2992 diffs[ equalities[ equalitiesLength - 1 ] + 1 ][ 0 ] = DIFF_INSERT;
2994 // Throw away the equality we just deleted.
2995 equalitiesLength--;
2997 // Throw away the previous equality (it needs to be reevaluated).
2998 equalitiesLength--;
2999 pointer = equalitiesLength > 0 ? equalities[ equalitiesLength - 1 ] : -1;
3001 // Reset the counters.
3002 lengthInsertions1 = 0;
3003 lengthDeletions1 = 0;
3004 lengthInsertions2 = 0;
3005 lengthDeletions2 = 0;
3006 lastequality = null;
3007 changes = true;
3008 }
3009 }
3010 pointer++;
3011 }
3013 // Normalize the diff.
3014 if ( changes ) {
3015 this.diffCleanupMerge( diffs );
3016 }
3018 // Find any overlaps between deletions and insertions.
3019 // e.g: <del>abcxxx</del><ins>xxxdef</ins>
3020 // -> <del>abc</del>xxx<ins>def</ins>
3021 // e.g: <del>xxxabc</del><ins>defxxx</ins>
3022 // -> <ins>def</ins>xxx<del>abc</del>
3023 // Only extract an overlap if it is as big as the edit ahead or behind it.
3024 pointer = 1;
3025 while ( pointer < diffs.length ) {
3026 if ( diffs[ pointer - 1 ][ 0 ] === DIFF_DELETE &&
3027 diffs[ pointer ][ 0 ] === DIFF_INSERT ) {
3028 deletion = diffs[ pointer - 1 ][ 1 ];
3029 insertion = diffs[ pointer ][ 1 ];
3030 overlapLength1 = this.diffCommonOverlap( deletion, insertion );
3031 overlapLength2 = this.diffCommonOverlap( insertion, deletion );
3032 if ( overlapLength1 >= overlapLength2 ) {
3033 if ( overlapLength1 >= deletion.length / 2 ||
3034 overlapLength1 >= insertion.length / 2 ) {
3035 // Overlap found. Insert an equality and trim the surrounding edits.
3036 diffs.splice(
3037 pointer,
3038 0,
3039 [ DIFF_EQUAL, insertion.substring( 0, overlapLength1 ) ]
3040 );
3041 diffs[ pointer - 1 ][ 1 ] =
3042 deletion.substring( 0, deletion.length - overlapLength1 );
3043 diffs[ pointer + 1 ][ 1 ] = insertion.substring( overlapLength1 );
3044 pointer++;
3045 }
3046 } else {
3047 if ( overlapLength2 >= deletion.length / 2 ||
3048 overlapLength2 >= insertion.length / 2 ) {
3050 // Reverse overlap found.
3051 // Insert an equality and swap and trim the surrounding edits.
3052 diffs.splice(
3053 pointer,
3054 0,
3055 [ DIFF_EQUAL, deletion.substring( 0, overlapLength2 ) ]
3056 );
3058 diffs[ pointer - 1 ][ 0 ] = DIFF_INSERT;
3059 diffs[ pointer - 1 ][ 1 ] =
3060 insertion.substring( 0, insertion.length - overlapLength2 );
3061 diffs[ pointer + 1 ][ 0 ] = DIFF_DELETE;
3062 diffs[ pointer + 1 ][ 1 ] =
3063 deletion.substring( overlapLength2 );
3064 pointer++;
3065 }
3066 }
3067 pointer++;
3068 }
3069 pointer++;
3070 }
3071 };
3073 /**
3074 * Determine if the suffix of one string is the prefix of another.
3075 * @param {string} text1 First string.
3076 * @param {string} text2 Second string.
3077 * @return {number} The number of characters common to the end of the first
3078 * string and the start of the second string.
3079 * @private
3080 */
3081 DiffMatchPatch.prototype.diffCommonOverlap = function( text1, text2 ) {
3082 var text1Length, text2Length, textLength,
3083 best, length, pattern, found;
3084 // Cache the text lengths to prevent multiple calls.
3085 text1Length = text1.length;
3086 text2Length = text2.length;
3087 // Eliminate the null case.
3088 if ( text1Length === 0 || text2Length === 0 ) {
3089 return 0;
3090 }
3091 // Truncate the longer string.
3092 if ( text1Length > text2Length ) {
3093 text1 = text1.substring( text1Length - text2Length );
3094 } else if ( text1Length < text2Length ) {
3095 text2 = text2.substring( 0, text1Length );
3096 }
3097 textLength = Math.min( text1Length, text2Length );
3098 // Quick check for the worst case.
3099 if ( text1 === text2 ) {
3100 return textLength;
3101 }
3103 // Start by looking for a single character match
3104 // and increase length until no match is found.
3105 // Performance analysis: https://neil.fraser.name/news/2010/11/04/
3106 best = 0;
3107 length = 1;
3108 while ( true ) {
3109 pattern = text1.substring( textLength - length );
3110 found = text2.indexOf( pattern );
3111 if ( found === -1 ) {
3112 return best;
3113 }
3114 length += found;
3115 if ( found === 0 || text1.substring( textLength - length ) ===
3116 text2.substring( 0, length ) ) {
3117 best = length;
3118 length++;
3119 }
3120 }
3121 };
3123 /**
3124 * Split two texts into an array of strings. Reduce the texts to a string of
3125 * hashes where each Unicode character represents one line.
3126 * @param {string} text1 First string.
3127 * @param {string} text2 Second string.
3128 * @return {{chars1: string, chars2: string, lineArray: !Array.<string>}}
3129 * An object containing the encoded text1, the encoded text2 and
3130 * the array of unique strings.
3131 * The zeroth element of the array of unique strings is intentionally blank.
3132 * @private
3133 */
3134 DiffMatchPatch.prototype.diffLinesToChars = function( text1, text2 ) {
3135 var lineArray, lineHash, chars1, chars2;
3140 // So we'll insert a junk entry to avoid generating a null character.
3143 /**
3144 * Split a text into an array of strings. Reduce the texts to a string of
3145 * hashes where each Unicode character represents one line.
3146 * Modifies linearray and linehash through being a closure.
3147 * @param {string} text String to encode.
3148 * @return {string} Encoded string.
3149 * @private
3150 */
3151 function diffLinesToCharsMunge( text ) {
3152 var chars, lineStart, lineEnd, lineArrayLength, line;
3154 // Walk the text, pulling out a substring for each line.
3156 // Modifying text would create many large strings to garbage collect.
3157 lineStart = 0;
3158 lineEnd = -1;
3159 // Keeping our own length variable is faster than looking it up.
3160 lineArrayLength = lineArray.length;
3161 while ( lineEnd < text.length - 1 ) {
3163 if ( lineEnd === -1 ) {
3164 lineEnd = text.length - 1;
3165 }
3166 line = text.substring( lineStart, lineEnd + 1 );
3167 lineStart = lineEnd + 1;
3169 if ( lineHash.hasOwnProperty ? lineHash.hasOwnProperty( line ) :
3170 ( lineHash[ line ] !== undefined ) ) {
3171 chars += String.fromCharCode( lineHash[ line ] );
3172 } else {
3173 chars += String.fromCharCode( lineArrayLength );
3174 lineHash[ line ] = lineArrayLength;
3175 lineArray[ lineArrayLength++ ] = line;
3176 }
3177 }
3178 return chars;
3179 }
3181 chars1 = diffLinesToCharsMunge( text1 );
3182 chars2 = diffLinesToCharsMunge( text2 );
3183 return {
3184 chars1: chars1,
3185 chars2: chars2,
3186 lineArray: lineArray
3187 };
3188 };
3190 /**
3191 * Rehydrate the text in a diff from a string of line hashes to real lines of
3192 * text.
3193 * @param {!Array.<!DiffMatchPatch.Diff>} diffs Array of diff tuples.
3194 * @param {!Array.<string>} lineArray Array of unique strings.
3195 * @private
3196 */
3197 DiffMatchPatch.prototype.diffCharsToLines = function( diffs, lineArray ) {
3198 var x, chars, text, y;
3199 for ( x = 0; x < diffs.length; x++ ) {
3200 chars = diffs[ x ][ 1 ];
3201 text = [];
3202 for ( y = 0; y < chars.length; y++ ) {
3203 text[ y ] = lineArray[ chars.charCodeAt( y ) ];
3204 }
3206 }
3207 };
3209 /**
3210 * Reorder and merge like edit sections. Merge equalities.
3211 * Any edit section can move as long as it doesn't cross an equality.
3212 * @param {!Array.<!DiffMatchPatch.Diff>} diffs Array of diff tuples.
3213 */
3214 DiffMatchPatch.prototype.diffCleanupMerge = function( diffs ) {
3215 var pointer, countDelete, countInsert, textInsert, textDelete,
3216 commonlength, changes, diffPointer, position;
3218 pointer = 0;
3219 countDelete = 0;
3220 countInsert = 0;
3223 commonlength;
3224 while ( pointer < diffs.length ) {
3225 switch ( diffs[ pointer ][ 0 ] ) {
3226 case DIFF_INSERT:
3227 countInsert++;
3228 textInsert += diffs[ pointer ][ 1 ];
3229 pointer++;
3230 break;
3231 case DIFF_DELETE:
3232 countDelete++;
3233 textDelete += diffs[ pointer ][ 1 ];
3234 pointer++;
3235 break;
3236 case DIFF_EQUAL:
3237 // Upon reaching an equality, check for prior redundancies.
3238 if ( countDelete + countInsert > 1 ) {
3239 if ( countDelete !== 0 && countInsert !== 0 ) {
3240 // Factor out any common prefixes.
3241 commonlength = this.diffCommonPrefix( textInsert, textDelete );
3242 if ( commonlength !== 0 ) {
3243 if ( ( pointer - countDelete - countInsert ) > 0 &&
3244 diffs[ pointer - countDelete - countInsert - 1 ][ 0 ] ===
3245 DIFF_EQUAL ) {
3246 diffs[ pointer - countDelete - countInsert - 1 ][ 1 ] +=
3247 textInsert.substring( 0, commonlength );
3248 } else {
3249 diffs.splice( 0, 0, [ DIFF_EQUAL,
3250 textInsert.substring( 0, commonlength )
3251 ] );
3252 pointer++;
3253 }
3254 textInsert = textInsert.substring( commonlength );
3255 textDelete = textDelete.substring( commonlength );
3256 }
3257 // Factor out any common suffixies.
3258 commonlength = this.diffCommonSuffix( textInsert, textDelete );
3259 if ( commonlength !== 0 ) {
3260 diffs[ pointer ][ 1 ] = textInsert.substring( textInsert.length -
3261 commonlength ) + diffs[ pointer ][ 1 ];
3262 textInsert = textInsert.substring( 0, textInsert.length -
3263 commonlength );
3264 textDelete = textDelete.substring( 0, textDelete.length -
3265 commonlength );
3266 }
3267 }
3268 // Delete the offending records and add the merged ones.
3269 if ( countDelete === 0 ) {
3270 diffs.splice( pointer - countInsert,
3271 countDelete + countInsert, [ DIFF_INSERT, textInsert ] );
3272 } else if ( countInsert === 0 ) {
3273 diffs.splice( pointer - countDelete,
3274 countDelete + countInsert, [ DIFF_DELETE, textDelete ] );
3275 } else {
3276 diffs.splice(
3277 pointer - countDelete - countInsert,
3278 countDelete + countInsert,
3279 [ DIFF_DELETE, textDelete ], [ DIFF_INSERT, textInsert ]
3280 );
3281 }
3282 pointer = pointer - countDelete - countInsert +
3283 ( countDelete ? 1 : 0 ) + ( countInsert ? 1 : 0 ) + 1;
3284 } else if ( pointer !== 0 && diffs[ pointer - 1 ][ 0 ] === DIFF_EQUAL ) {
3286 // Merge this equality with the previous one.
3287 diffs[ pointer - 1 ][ 1 ] += diffs[ pointer ][ 1 ];
3288 diffs.splice( pointer, 1 );
3289 } else {
3290 pointer++;
3291 }
3292 countInsert = 0;
3293 countDelete = 0;
3296 break;
3297 }
3298 }
3300 diffs.pop(); // Remove the dummy entry at the end.
3301 }
3303 // Second pass: look for single edits surrounded on both sides by equalities
3304 // which can be shifted sideways to eliminate an equality.
3305 // e.g: A<ins>BA</ins>C -> <ins>AB</ins>AC
3306 changes = false;
3307 pointer = 1;
3309 // Intentionally ignore the first and last element (don't need checking).
3310 while ( pointer < diffs.length - 1 ) {
3311 if ( diffs[ pointer - 1 ][ 0 ] === DIFF_EQUAL &&
3312 diffs[ pointer + 1 ][ 0 ] === DIFF_EQUAL ) {
3314 diffPointer = diffs[ pointer ][ 1 ];
3315 position = diffPointer.substring(
3316 diffPointer.length - diffs[ pointer - 1 ][ 1 ].length
3317 );
3319 // This is a single edit surrounded by equalities.
3320 if ( position === diffs[ pointer - 1 ][ 1 ] ) {
3322 // Shift the edit over the previous equality.
3323 diffs[ pointer ][ 1 ] = diffs[ pointer - 1 ][ 1 ] +
3324 diffs[ pointer ][ 1 ].substring( 0, diffs[ pointer ][ 1 ].length -
3325 diffs[ pointer - 1 ][ 1 ].length );
3326 diffs[ pointer + 1 ][ 1 ] =
3327 diffs[ pointer - 1 ][ 1 ] + diffs[ pointer + 1 ][ 1 ];
3328 diffs.splice( pointer - 1, 1 );
3329 changes = true;
3330 } else if ( diffPointer.substring( 0, diffs[ pointer + 1 ][ 1 ].length ) ===
3331 diffs[ pointer + 1 ][ 1 ] ) {
3333 // Shift the edit over the next equality.
3334 diffs[ pointer - 1 ][ 1 ] += diffs[ pointer + 1 ][ 1 ];
3335 diffs[ pointer ][ 1 ] =
3336 diffs[ pointer ][ 1 ].substring( diffs[ pointer + 1 ][ 1 ].length ) +
3337 diffs[ pointer + 1 ][ 1 ];
3338 diffs.splice( pointer + 1, 1 );
3339 changes = true;
3340 }
3341 }
3342 pointer++;
3343 }
3344 // If shifts were made, the diff needs reordering and another shift sweep.
3345 if ( changes ) {
3346 this.diffCleanupMerge( diffs );
3347 }
3348 };
3350 return function( o, n ) {
3351 var diff, output, text;
3352 diff = new DiffMatchPatch();
3353 output = diff.DiffMain( o, n );
3354 diff.diffCleanupEfficiency( output );
3355 text = diff.diffPrettyHtml( output );
3357 return text;
3358 };
3359 }() );
3361 // Get a reference to the global object, like window in browsers
3362 }( (function() {
3363 return this;
3364 })() ));
3366 (function() {
3368 // Don't load the HTML Reporter on non-Browser environments
3370 return;
3371 }
3373 // Deprecated QUnit.init - Ref #530
3374 // Re-initialize the configuration options
3375 QUnit.init = function() {
3376 var tests, banner, result, qunit,
3377 config = QUnit.config;
3379 config.stats = { all: 0, bad: 0 };
3380 config.moduleStats = { all: 0, bad: 0 };
3381 config.started = 0;
3382 config.updateRate = 1000;
3383 config.blocking = false;
3384 config.autostart = true;
3385 config.autorun = false;
3387 config.queue = [];
3389 // Return on non-browser environments
3390 // This is necessary to not break on node tests
3392 return;
3393 }
3396 if ( qunit ) {
3397 qunit.innerHTML =
3403 }
3409 if ( tests ) {
3411 }
3413 if ( banner ) {
3415 }
3417 if ( result ) {
3418 result.parentNode.removeChild( result );
3419 }
3421 if ( tests ) {
3425 tests.parentNode.insertBefore( result, tests );
3427 }
3428 };
3430 var config = QUnit.config,
3431 collapseNext = false,
3432 hasOwn = Object.prototype.hasOwnProperty,
3433 defined = {
3434 document: window.document !== undefined,
3435 sessionStorage: (function() {
3437 try {
3438 sessionStorage.setItem( x, x );
3439 sessionStorage.removeItem( x );
3440 return true;
3441 } catch ( e ) {
3442 return false;
3443 }
3444 }())
3445 },
3446 modulesList = [];
3448 /**
3449 * Escape text for attribute or text content.
3450 */
3451 function escapeText( s ) {
3452 if ( !s ) {
3454 }
3457 // Both single quotes and double quotes (for attributes)
3470 }
3471 });
3472 }
3474 /**
3475 * @param {HTMLElement} elem
3476 * @param {string} type
3477 * @param {Function} fn
3478 */
3482 // Standards-based browsers
3486 // support: IE <9
3491 }
3494 });
3495 }
3496 }
3498 /**
3499 * @param {Array|NodeList} elems
3500 * @param {string} type
3501 * @param {Function} fn
3502 */
3507 }
3508 }
3512 }
3517 }
3518 }
3525 }
3526 }
3531 // Class name may appear multiple times
3534 }
3536 // trim for prettiness
3537 elem.className = typeof set.trim === "function" ? set.trim() : set.replace( /^\s+|\s+$/g, "" );
3538 }
3542 }
3554 val = {
3556 label: val
3557 };
3558 }
3565 }
3587 }
3595 }
3596 }
3597 }
3602 }
3604 }
3605 }
3608 }
3610 // Handle "click" events on toolbar checkboxes and "change" for select menus.
3611 // Updates the URL with the new state of `config.urlConfig` values.
3615 params = {};
3617 // Detect if field is a select menu or a checkbox
3622 }
3633 }
3635 // It is not necessary to refresh the whole page
3639 }
3640 }
3652 }
3656 }
3658 }
3659 }
3662 }
3677 // Remove testId filter
3679 });
3680 }
3688 // For oldIE support:
3689 // * Add handlers to the individual elements instead of the container
3690 // * Use "click" instead of "change" for checkboxes
3695 }
3723 }
3726 });
3729 }
3737 }
3741 });
3753 }
3757 }
3766 }
3774 }
3782 }
3783 }
3792 }
3793 }
3800 }
3801 }
3809 }
3818 }
3819 }
3825 }
3826 }
3832 }
3838 }
3848 )
3849 );
3850 }
3851 }
3861 }
3867 }
3868 }
3869 }
3877 }
3897 }
3899 // HTML Reporter initialization and load
3903 // Fixture is the only one necessary to run without the #qunit element
3914 }
3926 }
3927 });
3933 html = [
3943 "</span> failed."
3948 }
3952 }
3956 // show ✖ for good, ✔ for bad suite result in title
3957 // use escape sequences in case file gets loaded with non-utf-8-charset
3962 }
3964 // clear own sessionStorage items if all tests passed
3970 }
3971 }
3972 }
3974 // scroll back to top to show results
3977 }
3978 });
3985 }
3990 }
4000 // Report later registered tests
4002 }
4013 }
4015 });
4018 // strip tags, html entity and whitespaces
4020 }
4030 }
4036 // pushFailure doesn't provide details.expected
4037 // when it calls, it's implicit to also not show expected and diff stuff
4038 // Also, we need to check details.expected existence, as it can exist and be undefined
4044 }
4048 expected +
4056 // Don't show diff if actual or expected are booleans
4063 }
4065 // Don't show diff if expected and actual are totally different
4069 }
4078 }
4083 }
4087 // this occurs when pushFailure is set and we have an extracted stack trace
4093 }
4101 });
4110 }
4119 // store result when possible
4125 }
4126 }
4130 // Collapse the passing tests
4134 // Skip collapsing the first failing test
4138 // Collapse remaining tests
4140 }
4142 // testItem.firstChild is the test name
4161 });
4169 }
4171 // Show the source of the test when showing assertions
4178 }
4181 });
4183 }
4184 });
4188 // Avoid readyState issue with phantomjs
4189 // Ref: #818
4198 }
4202 }
4204 })();