Rietveld Code Review Tool
Help | Bug tracker | Discussion group | Source code

Unified Diff: static/dist/js/vendor/bowser.js

Issue 29624561: Issue 6104 - Minified code in help center repository (Closed) Base URL: https://hg.adblockplus.org/help.eyeo.com
Patch Set: Move all requires to top of gulpfile.js Created Dec. 4, 2017, 2:10 p.m.
Use n/p to move between diff chunks; N/P to move between comments.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: static/dist/js/vendor/bowser.js
===================================================================
new file mode 100644
--- /dev/null
+++ b/static/dist/js/vendor/bowser.js
@@ -0,0 +1,602 @@
+/*!
+ * Bowser - a browser detector
+ * https://github.com/ded/bowser
+ * MIT License | (c) Dustin Diaz 2015
+ */
+
+!function (root, name, definition) {
+ if (typeof module != 'undefined' && module.exports) module.exports = definition()
+ else if (typeof define == 'function' && define.amd) define(name, definition)
+ else root[name] = definition()
+}(this, 'bowser', function () {
+ /**
+ * See useragents.js for examples of navigator.userAgent
+ */
+
+ var t = true
+
+ function detect(ua) {
+
+ function getFirstMatch(regex) {
+ var match = ua.match(regex);
+ return (match && match.length > 1 && match[1]) || '';
+ }
+
+ function getSecondMatch(regex) {
+ var match = ua.match(regex);
+ return (match && match.length > 1 && match[2]) || '';
+ }
+
+ var iosdevice = getFirstMatch(/(ipod|iphone|ipad)/i).toLowerCase()
+ , likeAndroid = /like android/i.test(ua)
+ , android = !likeAndroid && /android/i.test(ua)
+ , nexusMobile = /nexus\s*[0-6]\s*/i.test(ua)
+ , nexusTablet = !nexusMobile && /nexus\s*[0-9]+/i.test(ua)
+ , chromeos = /CrOS/.test(ua)
+ , silk = /silk/i.test(ua)
+ , sailfish = /sailfish/i.test(ua)
+ , tizen = /tizen/i.test(ua)
+ , webos = /(web|hpw)os/i.test(ua)
+ , windowsphone = /windows phone/i.test(ua)
+ , samsungBrowser = /SamsungBrowser/i.test(ua)
+ , windows = !windowsphone && /windows/i.test(ua)
+ , mac = !iosdevice && !silk && /macintosh/i.test(ua)
+ , linux = !android && !sailfish && !tizen && !webos && /linux/i.test(ua)
+ , edgeVersion = getFirstMatch(/edge\/(\d+(\.\d+)?)/i)
+ , versionIdentifier = getFirstMatch(/version\/(\d+(\.\d+)?)/i)
+ , tablet = /tablet/i.test(ua) && !/tablet pc/i.test(ua)
+ , mobile = !tablet && /[^-]mobi/i.test(ua)
+ , xbox = /xbox/i.test(ua)
+ , result
+
+ if (/opera/i.test(ua)) {
+ // an old Opera
+ result = {
+ name: 'Opera'
+ , opera: t
+ , version: versionIdentifier || getFirstMatch(/(?:opera|opr|opios)[\s\/](\d+(\.\d+)?)/i)
+ }
+ } else if (/opr\/|opios/i.test(ua)) {
+ // a new Opera
+ result = {
+ name: 'Opera'
+ , opera: t
+ , version: getFirstMatch(/(?:opr|opios)[\s\/](\d+(\.\d+)?)/i) || versionIdentifier
+ }
+ }
+ else if (/SamsungBrowser/i.test(ua)) {
+ result = {
+ name: 'Samsung Internet for Android'
+ , samsungBrowser: t
+ , version: versionIdentifier || getFirstMatch(/(?:SamsungBrowser)[\s\/](\d+(\.\d+)?)/i)
+ }
+ }
+ else if (/coast/i.test(ua)) {
+ result = {
+ name: 'Opera Coast'
+ , coast: t
+ , version: versionIdentifier || getFirstMatch(/(?:coast)[\s\/](\d+(\.\d+)?)/i)
+ }
+ }
+ else if (/yabrowser/i.test(ua)) {
+ result = {
+ name: 'Yandex Browser'
+ , yandexbrowser: t
+ , version: versionIdentifier || getFirstMatch(/(?:yabrowser)[\s\/](\d+(\.\d+)?)/i)
+ }
+ }
+ else if (/ucbrowser/i.test(ua)) {
+ result = {
+ name: 'UC Browser'
+ , ucbrowser: t
+ , version: getFirstMatch(/(?:ucbrowser)[\s\/](\d+(?:\.\d+)+)/i)
+ }
+ }
+ else if (/mxios/i.test(ua)) {
+ result = {
+ name: 'Maxthon'
+ , maxthon: t
+ , version: getFirstMatch(/(?:mxios)[\s\/](\d+(?:\.\d+)+)/i)
+ }
+ }
+ else if (/epiphany/i.test(ua)) {
+ result = {
+ name: 'Epiphany'
+ , epiphany: t
+ , version: getFirstMatch(/(?:epiphany)[\s\/](\d+(?:\.\d+)+)/i)
+ }
+ }
+ else if (/puffin/i.test(ua)) {
+ result = {
+ name: 'Puffin'
+ , puffin: t
+ , version: getFirstMatch(/(?:puffin)[\s\/](\d+(?:\.\d+)?)/i)
+ }
+ }
+ else if (/sleipnir/i.test(ua)) {
+ result = {
+ name: 'Sleipnir'
+ , sleipnir: t
+ , version: getFirstMatch(/(?:sleipnir)[\s\/](\d+(?:\.\d+)+)/i)
+ }
+ }
+ else if (/k-meleon/i.test(ua)) {
+ result = {
+ name: 'K-Meleon'
+ , kMeleon: t
+ , version: getFirstMatch(/(?:k-meleon)[\s\/](\d+(?:\.\d+)+)/i)
+ }
+ }
+ else if (windowsphone) {
+ result = {
+ name: 'Windows Phone'
+ , windowsphone: t
+ }
+ if (edgeVersion) {
+ result.msedge = t
+ result.version = edgeVersion
+ }
+ else {
+ result.msie = t
+ result.version = getFirstMatch(/iemobile\/(\d+(\.\d+)?)/i)
+ }
+ }
+ else if (/msie|trident/i.test(ua)) {
+ result = {
+ name: 'Internet Explorer'
+ , msie: t
+ , version: getFirstMatch(/(?:msie |rv:)(\d+(\.\d+)?)/i)
+ }
+ } else if (chromeos) {
+ result = {
+ name: 'Chrome'
+ , chromeos: t
+ , chromeBook: t
+ , chrome: t
+ , version: getFirstMatch(/(?:chrome|crios|crmo)\/(\d+(\.\d+)?)/i)
+ }
+ } else if (/chrome.+? edge/i.test(ua)) {
+ result = {
+ name: 'Microsoft Edge'
+ , msedge: t
+ , version: edgeVersion
+ }
+ }
+ else if (/vivaldi/i.test(ua)) {
+ result = {
+ name: 'Vivaldi'
+ , vivaldi: t
+ , version: getFirstMatch(/vivaldi\/(\d+(\.\d+)?)/i) || versionIdentifier
+ }
+ }
+ else if (sailfish) {
+ result = {
+ name: 'Sailfish'
+ , sailfish: t
+ , version: getFirstMatch(/sailfish\s?browser\/(\d+(\.\d+)?)/i)
+ }
+ }
+ else if (/seamonkey\//i.test(ua)) {
+ result = {
+ name: 'SeaMonkey'
+ , seamonkey: t
+ , version: getFirstMatch(/seamonkey\/(\d+(\.\d+)?)/i)
+ }
+ }
+ else if (/firefox|iceweasel|fxios/i.test(ua)) {
+ result = {
+ name: 'Firefox'
+ , firefox: t
+ , version: getFirstMatch(/(?:firefox|iceweasel|fxios)[ \/](\d+(\.\d+)?)/i)
+ }
+ if (/\((mobile|tablet);[^\)]*rv:[\d\.]+\)/i.test(ua)) {
+ result.firefoxos = t
+ }
+ }
+ else if (silk) {
+ result = {
+ name: 'Amazon Silk'
+ , silk: t
+ , version : getFirstMatch(/silk\/(\d+(\.\d+)?)/i)
+ }
+ }
+ else if (/phantom/i.test(ua)) {
+ result = {
+ name: 'PhantomJS'
+ , phantom: t
+ , version: getFirstMatch(/phantomjs\/(\d+(\.\d+)?)/i)
+ }
+ }
+ else if (/slimerjs/i.test(ua)) {
+ result = {
+ name: 'SlimerJS'
+ , slimer: t
+ , version: getFirstMatch(/slimerjs\/(\d+(\.\d+)?)/i)
+ }
+ }
+ else if (/blackberry|\bbb\d+/i.test(ua) || /rim\stablet/i.test(ua)) {
+ result = {
+ name: 'BlackBerry'
+ , blackberry: t
+ , version: versionIdentifier || getFirstMatch(/blackberry[\d]+\/(\d+(\.\d+)?)/i)
+ }
+ }
+ else if (webos) {
+ result = {
+ name: 'WebOS'
+ , webos: t
+ , version: versionIdentifier || getFirstMatch(/w(?:eb)?osbrowser\/(\d+(\.\d+)?)/i)
+ };
+ /touchpad\//i.test(ua) && (result.touchpad = t)
+ }
+ else if (/bada/i.test(ua)) {
+ result = {
+ name: 'Bada'
+ , bada: t
+ , version: getFirstMatch(/dolfin\/(\d+(\.\d+)?)/i)
+ };
+ }
+ else if (tizen) {
+ result = {
+ name: 'Tizen'
+ , tizen: t
+ , version: getFirstMatch(/(?:tizen\s?)?browser\/(\d+(\.\d+)?)/i) || versionIdentifier
+ };
+ }
+ else if (/qupzilla/i.test(ua)) {
+ result = {
+ name: 'QupZilla'
+ , qupzilla: t
+ , version: getFirstMatch(/(?:qupzilla)[\s\/](\d+(?:\.\d+)+)/i) || versionIdentifier
+ }
+ }
+ else if (/chromium/i.test(ua)) {
+ result = {
+ name: 'Chromium'
+ , chromium: t
+ , version: getFirstMatch(/(?:chromium)[\s\/](\d+(?:\.\d+)?)/i) || versionIdentifier
+ }
+ }
+ else if (/chrome|crios|crmo/i.test(ua)) {
+ result = {
+ name: 'Chrome'
+ , chrome: t
+ , version: getFirstMatch(/(?:chrome|crios|crmo)\/(\d+(\.\d+)?)/i)
+ }
+ }
+ else if (android) {
+ result = {
+ name: 'Android'
+ , version: versionIdentifier
+ }
+ }
+ else if (/safari|applewebkit/i.test(ua)) {
+ result = {
+ name: 'Safari'
+ , safari: t
+ }
+ if (versionIdentifier) {
+ result.version = versionIdentifier
+ }
+ }
+ else if (iosdevice) {
+ result = {
+ name : iosdevice == 'iphone' ? 'iPhone' : iosdevice == 'ipad' ? 'iPad' : 'iPod'
+ }
+ // WTF: version is not part of user agent in web apps
+ if (versionIdentifier) {
+ result.version = versionIdentifier
+ }
+ }
+ else if(/googlebot/i.test(ua)) {
+ result = {
+ name: 'Googlebot'
+ , googlebot: t
+ , version: getFirstMatch(/googlebot\/(\d+(\.\d+))/i) || versionIdentifier
+ }
+ }
+ else {
+ result = {
+ name: getFirstMatch(/^(.*)\/(.*) /),
+ version: getSecondMatch(/^(.*)\/(.*) /)
+ };
+ }
+
+ // set webkit or gecko flag for browsers based on these engines
+ if (!result.msedge && /(apple)?webkit/i.test(ua)) {
+ if (/(apple)?webkit\/537\.36/i.test(ua)) {
+ result.name = result.name || "Blink"
+ result.blink = t
+ } else {
+ result.name = result.name || "Webkit"
+ result.webkit = t
+ }
+ if (!result.version && versionIdentifier) {
+ result.version = versionIdentifier
+ }
+ } else if (!result.opera && /gecko\//i.test(ua)) {
+ result.name = result.name || "Gecko"
+ result.gecko = t
+ result.version = result.version || getFirstMatch(/gecko\/(\d+(\.\d+)?)/i)
+ }
+
+ // set OS flags for platforms that have multiple browsers
+ if (!result.windowsphone && !result.msedge && (android || result.silk)) {
+ result.android = t
+ } else if (!result.windowsphone && !result.msedge && iosdevice) {
+ result[iosdevice] = t
+ result.ios = t
+ } else if (mac) {
+ result.mac = t
+ } else if (xbox) {
+ result.xbox = t
+ } else if (windows) {
+ result.windows = t
+ } else if (linux) {
+ result.linux = t
+ }
+
+ function getWindowsVersion (s) {
+ switch (s) {
+ case 'NT': return 'NT'
+ case 'XP': return 'XP'
+ case 'NT 5.0': return '2000'
+ case 'NT 5.1': return 'XP'
+ case 'NT 5.2': return '2003'
+ case 'NT 6.0': return 'Vista'
+ case 'NT 6.1': return '7'
+ case 'NT 6.2': return '8'
+ case 'NT 6.3': return '8.1'
+ case 'NT 10.0': return '10'
+ default: return undefined
+ }
+ }
+
+ // OS version extraction
+ var osVersion = '';
+ if (result.windows) {
+ osVersion = getWindowsVersion(getFirstMatch(/Windows ((NT|XP)( \d\d?.\d)?)/i))
+ } else if (result.windowsphone) {
+ osVersion = getFirstMatch(/windows phone (?:os)?\s?(\d+(\.\d+)*)/i);
+ } else if (result.mac) {
+ osVersion = getFirstMatch(/Mac OS X (\d+([_\.\s]\d+)*)/i);
+ osVersion = osVersion.replace(/[_\s]/g, '.');
+ } else if (iosdevice) {
+ osVersion = getFirstMatch(/os (\d+([_\s]\d+)*) like mac os x/i);
+ osVersion = osVersion.replace(/[_\s]/g, '.');
+ } else if (android) {
+ osVersion = getFirstMatch(/android[ \/-](\d+(\.\d+)*)/i);
+ } else if (result.webos) {
+ osVersion = getFirstMatch(/(?:web|hpw)os\/(\d+(\.\d+)*)/i);
+ } else if (result.blackberry) {
+ osVersion = getFirstMatch(/rim\stablet\sos\s(\d+(\.\d+)*)/i);
+ } else if (result.bada) {
+ osVersion = getFirstMatch(/bada\/(\d+(\.\d+)*)/i);
+ } else if (result.tizen) {
+ osVersion = getFirstMatch(/tizen[\/\s](\d+(\.\d+)*)/i);
+ }
+ if (osVersion) {
+ result.osversion = osVersion;
+ }
+
+ // device type extraction
+ var osMajorVersion = !result.windows && osVersion.split('.')[0];
+ if (
+ tablet
+ || nexusTablet
+ || iosdevice == 'ipad'
+ || (android && (osMajorVersion == 3 || (osMajorVersion >= 4 && !mobile)))
+ || result.silk
+ ) {
+ result.tablet = t
+ } else if (
+ mobile
+ || iosdevice == 'iphone'
+ || iosdevice == 'ipod'
+ || android
+ || nexusMobile
+ || result.blackberry
+ || result.webos
+ || result.bada
+ ) {
+ result.mobile = t
+ }
+
+ // Graded Browser Support
+ // http://developer.yahoo.com/yui/articles/gbs
+ if (result.msedge ||
+ (result.msie && result.version >= 10) ||
+ (result.yandexbrowser && result.version >= 15) ||
+ (result.vivaldi && result.version >= 1.0) ||
+ (result.chrome && result.version >= 20) ||
+ (result.samsungBrowser && result.version >= 4) ||
+ (result.firefox && result.version >= 20.0) ||
+ (result.safari && result.version >= 6) ||
+ (result.opera && result.version >= 10.0) ||
+ (result.ios && result.osversion && result.osversion.split(".")[0] >= 6) ||
+ (result.blackberry && result.version >= 10.1)
+ || (result.chromium && result.version >= 20)
+ ) {
+ result.a = t;
+ }
+ else if ((result.msie && result.version < 10) ||
+ (result.chrome && result.version < 20) ||
+ (result.firefox && result.version < 20.0) ||
+ (result.safari && result.version < 6) ||
+ (result.opera && result.version < 10.0) ||
+ (result.ios && result.osversion && result.osversion.split(".")[0] < 6)
+ || (result.chromium && result.version < 20)
+ ) {
+ result.c = t
+ } else result.x = t
+
+ return result
+ }
+
+ var bowser = detect(typeof navigator !== 'undefined' ? navigator.userAgent || '' : '')
+
+ bowser.test = function (browserList) {
+ for (var i = 0; i < browserList.length; ++i) {
+ var browserItem = browserList[i];
+ if (typeof browserItem=== 'string') {
+ if (browserItem in bowser) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Get version precisions count
+ *
+ * @example
+ * getVersionPrecision("1.10.3") // 3
+ *
+ * @param {string} version
+ * @return {number}
+ */
+ function getVersionPrecision(version) {
+ return version.split(".").length;
+ }
+
+ /**
+ * Array::map polyfill
+ *
+ * @param {Array} arr
+ * @param {Function} iterator
+ * @return {Array}
+ */
+ function map(arr, iterator) {
+ var result = [], i;
+ if (Array.prototype.map) {
+ return Array.prototype.map.call(arr, iterator);
+ }
+ for (i = 0; i < arr.length; i++) {
+ result.push(iterator(arr[i]));
+ }
+ return result;
+ }
+
+ /**
+ * Calculate browser version weight
+ *
+ * @example
+ * compareVersions(['1.10.2.1', '1.8.2.1.90']) // 1
+ * compareVersions(['1.010.2.1', '1.09.2.1.90']); // 1
+ * compareVersions(['1.10.2.1', '1.10.2.1']); // 0
+ * compareVersions(['1.10.2.1', '1.0800.2']); // -1
+ *
+ * @param {Array<String>} versions versions to compare
+ * @return {Number} comparison result
+ */
+ function compareVersions(versions) {
+ // 1) get common precision for both versions, for example for "10.0" and "9" it should be 2
+ var precision = Math.max(getVersionPrecision(versions[0]), getVersionPrecision(versions[1]));
+ var chunks = map(versions, function (version) {
+ var delta = precision - getVersionPrecision(version);
+
+ // 2) "9" -> "9.0" (for precision = 2)
+ version = version + new Array(delta + 1).join(".0");
+
+ // 3) "9.0" -> ["000000000"", "000000009"]
+ return map(version.split("."), function (chunk) {
+ return new Array(20 - chunk.length).join("0") + chunk;
+ }).reverse();
+ });
+
+ // iterate in reverse order by reversed chunks array
+ while (--precision >= 0) {
+ // 4) compare: "000000009" > "000000010" = false (but "9" > "10" = true)
+ if (chunks[0][precision] > chunks[1][precision]) {
+ return 1;
+ }
+ else if (chunks[0][precision] === chunks[1][precision]) {
+ if (precision === 0) {
+ // all version chunks are same
+ return 0;
+ }
+ }
+ else {
+ return -1;
+ }
+ }
+ }
+
+ /**
+ * Check if browser is unsupported
+ *
+ * @example
+ * bowser.isUnsupportedBrowser({
+ * msie: "10",
+ * firefox: "23",
+ * chrome: "29",
+ * safari: "5.1",
+ * opera: "16",
+ * phantom: "534"
+ * });
+ *
+ * @param {Object} minVersions map of minimal version to browser
+ * @param {Boolean} [strictMode = false] flag to return false if browser wasn't found in map
+ * @param {String} [ua] user agent string
+ * @return {Boolean}
+ */
+ function isUnsupportedBrowser(minVersions, strictMode, ua) {
+ var _bowser = bowser;
+
+ // make strictMode param optional with ua param usage
+ if (typeof strictMode === 'string') {
+ ua = strictMode;
+ strictMode = void(0);
+ }
+
+ if (strictMode === void(0)) {
+ strictMode = false;
+ }
+ if (ua) {
+ _bowser = detect(ua);
+ }
+
+ var version = "" + _bowser.version;
+ for (var browser in minVersions) {
+ if (minVersions.hasOwnProperty(browser)) {
+ if (_bowser[browser]) {
+ if (typeof minVersions[browser] !== 'string') {
+ throw new Error('Browser version in the minVersion map should be a string: ' + browser + ': ' + String(minVersions));
+ }
+
+ // browser version and min supported version.
+ return compareVersions([version, minVersions[browser]]) < 0;
+ }
+ }
+ }
+
+ return strictMode; // not found
+ }
+
+ /**
+ * Check if browser is supported
+ *
+ * @param {Object} minVersions map of minimal version to browser
+ * @param {Boolean} [strictMode = false] flag to return false if browser wasn't found in map
+ * @param {String} [ua] user agent string
+ * @return {Boolean}
+ */
+ function check(minVersions, strictMode, ua) {
+ return !isUnsupportedBrowser(minVersions, strictMode, ua);
+ }
+
+ bowser.isUnsupportedBrowser = isUnsupportedBrowser;
+ bowser.compareVersions = compareVersions;
+ bowser.check = check;
+
+ /*
+ * Set our detect method to the main bowser object so we can
+ * reuse it to test other user agents.
+ * This is needed to implement future tests.
+ */
+ bowser._detect = detect;
+
+ return bowser
+});
+//# sourceMappingURL=bowser.js.map

Powered by Google App Engine
This is Rietveld