Update to MediaWiki 1.25.1

1 files changed, 317 insertions, 0 deletions

diff --git a/resources/lib/jquery.client/jquery.client.js b/resources/lib/jquery.client/jquery.client.js
new file mode 100644
index 00000000..1560c7d2
--- /dev/null
+++ b/resources/lib/jquery.client/jquery.client.js
@@ -0,0 +1,317 @@
+/*!
+ * jQuery Client v1.0.0
+ * https://www.mediawiki.org/wiki/JQuery_Client
+ *
+ * Copyright 2010-2015 jquery-client maintainers and other contributors.
+ * Released under the MIT license
+ * http://jquery-client.mit-license.org
+ */
+
+/**
+ * User-agent detection
+ *
+ * @class jQuery.client
+ * @singleton
+ */
+( function ( $ ) {
+
+	/**
+	 * @private
+	 * @property {Object} profileCache Keyed by userAgent string,
+	 * value is the parsed $.client.profile object for that user agent.
+	 */
+	var profileCache = {};
+
+	$.client = {
+
+		/**
+		 * Get an object containing information about the client.
+		 *
+		 * @param {Object} [nav] An object with a 'userAgent' and 'platform' property.
+		 *  Defaults to the global `navigator` object.
+		 * @return {Object} The resulting client object will be in the following format:
+		 *
+		 *     {
+		 *         'name': 'firefox',
+		 *         'layout': 'gecko',
+		 *         'layoutVersion': 20101026,
+		 *         'platform': 'linux'
+		 *         'version': '3.5.1',
+		 *         'versionBase': '3',
+		 *         'versionNumber': 3.5,
+		 *     }
+		 */
+		profile: function ( nav ) {
+			/*jshint boss:true */
+
+			if ( nav === undefined ) {
+				nav = window.navigator;
+			}
+
+			// Use the cached version if possible
+			if ( profileCache[ nav.userAgent + '|' + nav.platform ] !== undefined ) {
+				return profileCache[ nav.userAgent + '|' + nav.platform ];
+			}
+
+			var
+				versionNumber,
+				key = nav.userAgent + '|' + nav.platform,
+
+				// Configuration
+
+				// Name of browsers or layout engines we don't recognize
+				uk = 'unknown',
+				// Generic version digit
+				x = 'x',
+				// Strings found in user agent strings that need to be conformed
+				wildUserAgents = ['Opera', 'Navigator', 'Minefield', 'KHTML', 'Chrome', 'PLAYSTATION 3', 'Iceweasel'],
+				// Translations for conforming user agent strings
+				userAgentTranslations = [
+					// Tons of browsers lie about being something they are not
+					[/(Firefox|MSIE|KHTML,?\slike\sGecko|Konqueror)/, ''],
+					// Chrome lives in the shadow of Safari still
+					['Chrome Safari', 'Chrome'],
+					// KHTML is the layout engine not the browser - LIES!
+					['KHTML', 'Konqueror'],
+					// Firefox nightly builds
+					['Minefield', 'Firefox'],
+					// This helps keep different versions consistent
+					['Navigator', 'Netscape'],
+					// This prevents version extraction issues, otherwise translation would happen later
+					['PLAYSTATION 3', 'PS3']
+				],
+				// Strings which precede a version number in a user agent string - combined and used as
+				// match 1 in version detection
+				versionPrefixes = [
+					'camino', 'chrome', 'firefox', 'iceweasel', 'netscape', 'netscape6', 'opera', 'version', 'konqueror',
+					'lynx', 'msie', 'safari', 'ps3', 'android'
+				],
+				// Used as matches 2, 3 and 4 in version extraction - 3 is used as actual version number
+				versionSuffix = '(\\/|\\;?\\s|)([a-z0-9\\.\\+]*?)(\\;|dev|rel|\\)|\\s|$)',
+				// Names of known browsers
+				names = [
+					'camino', 'chrome', 'firefox', 'iceweasel', 'netscape', 'konqueror', 'lynx', 'msie', 'opera',
+					'safari', 'ipod', 'iphone', 'blackberry', 'ps3', 'rekonq', 'android'
+				],
+				// Tanslations for conforming browser names
+				nameTranslations = [],
+				// Names of known layout engines
+				layouts = ['gecko', 'konqueror', 'msie', 'trident', 'edge', 'opera', 'webkit'],
+				// Translations for conforming layout names
+				layoutTranslations = [ ['konqueror', 'khtml'], ['msie', 'trident'], ['opera', 'presto'] ],
+				// Names of supported layout engines for version number
+				layoutVersions = ['applewebkit', 'gecko', 'trident', 'edge'],
+				// Names of known operating systems
+				platforms = ['win', 'wow64', 'mac', 'linux', 'sunos', 'solaris', 'iphone'],
+				// Translations for conforming operating system names
+				platformTranslations = [ ['sunos', 'solaris'], ['wow64', 'win'] ],
+
+				/**
+				 * Performs multiple replacements on a string
+				 * @ignore
+				 */
+				translate = function ( source, translations ) {
+					var i;
+					for ( i = 0; i < translations.length; i++ ) {
+						source = source.replace( translations[i][0], translations[i][1] );
+					}
+					return source;
+				},
+
+				// Pre-processing
+
+				ua = nav.userAgent,
+				match,
+				name = uk,
+				layout = uk,
+				layoutversion = uk,
+				platform = uk,
+				version = x;
+
+			if ( match = new RegExp( '(' + wildUserAgents.join( '|' ) + ')' ).exec( ua ) ) {
+				// Takes a userAgent string and translates given text into something we can more easily work with
+				ua = translate( ua, userAgentTranslations );
+			}
+			// Everything will be in lowercase from now on
+			ua = ua.toLowerCase();
+
+			// Extraction
+
+			if ( match = new RegExp( '(' + names.join( '|' ) + ')' ).exec( ua ) ) {
+				name = translate( match[1], nameTranslations );
+			}
+			if ( match = new RegExp( '(' + layouts.join( '|' ) + ')' ).exec( ua ) ) {
+				layout = translate( match[1], layoutTranslations );
+			}
+			if ( match = new RegExp( '(' + layoutVersions.join( '|' ) + ')\\\/(\\d+)').exec( ua ) ) {
+				layoutversion = parseInt( match[2], 10 );
+			}
+			if ( match = new RegExp( '(' + platforms.join( '|' ) + ')' ).exec( nav.platform.toLowerCase() ) ) {
+				platform = translate( match[1], platformTranslations );
+			}
+			if ( match = new RegExp( '(' + versionPrefixes.join( '|' ) + ')' + versionSuffix ).exec( ua ) ) {
+				version = match[3];
+			}
+
+			// Edge Cases -- did I mention about how user agent string lie?
+
+			// Decode Safari's crazy 400+ version numbers
+			if ( name === 'safari' && version > 400 ) {
+				version = '2.0';
+			}
+			// Expose Opera 10's lies about being Opera 9.8
+			if ( name === 'opera' && version >= 9.8 ) {
+				match = ua.match( /\bversion\/([0-9\.]*)/ );
+				if ( match && match[1] ) {
+					version = match[1];
+				} else {
+					version = '10';
+				}
+			}
+			// And Opera 15's lies about being Chrome
+			if ( name === 'chrome' && ( match = ua.match( /\bopr\/([0-9\.]*)/ ) ) ) {
+				if ( match[1] ) {
+					name = 'opera';
+					version = match[1];
+				}
+			}
+			// And IE 11's lies about being not being IE
+			if ( layout === 'trident' && layoutversion >= 7 && ( match = ua.match( /\brv[ :\/]([0-9\.]*)/ ) ) ) {
+				if ( match[1] ) {
+					name = 'msie';
+					version = match[1];
+				}
+			}
+			// And IE 12's different lies about not being IE
+			if ( name === 'chrome' && ( match = ua.match( /\bedge\/([0-9\.]*)/ ) ) ) {
+				name = 'msie';
+				version = match[1];
+				layout = 'edge';
+				layoutversion = parseInt( match[1], 10 );
+			}
+			// And Amazon Silk's lies about being Android on mobile or Safari on desktop
+			if ( match = ua.match( /\bsilk\/([0-9.\-_]*)/ ) ) {
+				if ( match[1] ) {
+					name = 'silk';
+					version = match[1];
+				}
+			}
+
+			versionNumber = parseFloat( version, 10 ) || 0.0;
+
+			// Caching
+
+			return profileCache[ key  ] = {
+				name: name,
+				layout: layout,
+				layoutVersion: layoutversion,
+				platform: platform,
+				version: version,
+				versionBase: ( version !== x ? Math.floor( versionNumber ).toString() : x ),
+				versionNumber: versionNumber
+			};
+		},
+
+		/**
+		 * Checks the current browser against a support map object.
+		 *
+		 * Version numbers passed as numeric values will be compared like numbers (1.2 > 1.11).
+		 * Version numbers passed as string values will be compared using a simple component-wise
+		 * algorithm, similar to PHP's version_compare ('1.2' < '1.11').
+		 *
+		 * A browser map is in the following format:
+		 *
+		 *     {
+		 *         // Multiple rules with configurable operators
+		 *         'msie': [['>=', 7], ['!=', 9]],
+		 *         // Match no versions
+		 *         'iphone': false,
+		 *         // Match any version
+		 *         'android': null
+		 *     }
+		 *
+		 * It can optionally be split into ltr/rtl sections:
+		 *
+		 *     {
+		 *         'ltr': {
+		 *             'android': null,
+		 *             'iphone': false
+		 *         },
+		 *         'rtl': {
+		 *             'android': false,
+		 *             // rules are not inherited from ltr
+		 *             'iphone': false
+		 *         }
+		 *     }
+		 *
+		 * @param {Object} map Browser support map
+		 * @param {Object} [profile] A client-profile object
+		 * @param {boolean} [exactMatchOnly=false] Only return true if the browser is matched, otherwise
+		 * returns true if the browser is not found.
+		 *
+		 * @return {boolean} The current browser is in the support map
+		 */
+		test: function ( map, profile, exactMatchOnly ) {
+			/*jshint evil:true */
+
+			var conditions, dir, i, op, val, j, pieceVersion, pieceVal, compare;
+			profile = $.isPlainObject( profile ) ? profile : $.client.profile();
+			if ( map.ltr && map.rtl ) {
+				dir = $( 'body' ).is( '.rtl' ) ? 'rtl' : 'ltr';
+				map = map[dir];
+			}
+			// Check over each browser condition to determine if we are running in a compatible client
+			if ( typeof map !== 'object' || map[profile.name] === undefined ) {
+				// Not found, return true if exactMatchOnly not set, false otherwise
+				return !exactMatchOnly;
+			}
+			conditions = map[profile.name];
+			if ( conditions === false ) {
+				// Match no versions
+				return false;
+			}
+			if ( conditions === null ) {
+				// Match all versions
+				return true;
+			}
+			for ( i = 0; i < conditions.length; i++ ) {
+				op = conditions[i][0];
+				val = conditions[i][1];
+				if ( typeof val === 'string' ) {
+					// Perform a component-wise comparison of versions, similar to PHP's version_compare
+					// but simpler. '1.11' is larger than '1.2'.
+					pieceVersion = profile.version.toString().split( '.' );
+					pieceVal = val.split( '.' );
+					// Extend with zeroes to equal length
+					while ( pieceVersion.length < pieceVal.length ) {
+						pieceVersion.push( '0' );
+					}
+					while ( pieceVal.length < pieceVersion.length ) {
+						pieceVal.push( '0' );
+					}
+					// Compare components
+					compare = 0;
+					for ( j = 0; j < pieceVersion.length; j++ ) {
+						if ( Number( pieceVersion[j] ) < Number( pieceVal[j] ) ) {
+							compare = -1;
+							break;
+						} else if ( Number( pieceVersion[j] ) > Number( pieceVal[j] ) ) {
+							compare = 1;
+							break;
+						}
+					}
+					// compare will be -1, 0 or 1, depending on comparison result
+					if ( !( eval( String( compare + op + '0' ) ) ) ) {
+						return false;
+					}
+				} else if ( typeof val === 'number' ) {
+					if ( !( eval( 'profile.versionNumber' + op + val ) ) ) {
+						return false;
+					}
+				}
+			}
+
+			return true;
+		}
+	};
+}( jQuery ) );