ecomp-portal-FE/client/bower_components_external/bowser/bowser.js

   1 /*!
   2  * Bowser - a browser detector
   3  * https://github.com/ded/bowser
   4  * MIT License | (c) Dustin Diaz 2015
   5  */
   6
   7 !function (name, definition) {
   8   if (typeof module != 'undefined' && module.exports) module.exports = definition()
   9   else if (typeof define == 'function' && define.amd) define(definition)
  10   else this[name] = definition()
  11 }('bowser', function () {
  12   /**
  13     * See useragents.js for examples of navigator.userAgent
  14     */
  15
  16   var t = true
  17
  18   function detect(ua) {
  19
  20     function getFirstMatch(regex) {
  21       var match = ua.match(regex);
  22       return (match && match.length > 1 && match[1]) || '';
  23     }
  24
  25     function getSecondMatch(regex) {
  26       var match = ua.match(regex);
  27       return (match && match.length > 1 && match[2]) || '';
  28     }
  29
  30     var iosdevice = getFirstMatch(/(ipod|iphone|ipad)/i).toLowerCase()
  31       , likeAndroid = /like android/i.test(ua)
  32       , android = !likeAndroid && /android/i.test(ua)
  33       , nexusMobile = /nexus\s*[0-6]\s*/i.test(ua)
  34       , nexusTablet = !nexusMobile && /nexus\s*[0-9]+/i.test(ua)
  35       , chromeos = /CrOS/.test(ua)
  36       , silk = /silk/i.test(ua)
  37       , sailfish = /sailfish/i.test(ua)
  38       , tizen = /tizen/i.test(ua)
  39       , webos = /(web|hpw)os/i.test(ua)
  40       , windowsphone = /windows phone/i.test(ua)
  41       , windows = !windowsphone && /windows/i.test(ua)
  42       , mac = !iosdevice && !silk && /macintosh/i.test(ua)
  43       , linux = !android && !sailfish && !tizen && !webos && /linux/i.test(ua)
  44       , edgeVersion = getFirstMatch(/edge\/(\d+(\.\d+)?)/i)
  45       , versionIdentifier = getFirstMatch(/version\/(\d+(\.\d+)?)/i)
  46       , tablet = /tablet/i.test(ua)
  47       , mobile = !tablet && /[^-]mobi/i.test(ua)
  48       , xbox = /xbox/i.test(ua)
  49       , result
  50
  51     if (/opera|opr|opios/i.test(ua)) {
  52       result = {
  53         name: 'Opera'
  54       , opera: t
  55       , version: versionIdentifier || getFirstMatch(/(?:opera|opr|opios)[\s\/](\d+(\.\d+)?)/i)
  56       }
  57     }
  58     else if (/coast/i.test(ua)) {
  59       result = {
  60         name: 'Opera Coast'
  61         , coast: t
  62         , version: versionIdentifier || getFirstMatch(/(?:coast)[\s\/](\d+(\.\d+)?)/i)
  63       }
  64     }
  65     else if (/yabrowser/i.test(ua)) {
  66       result = {
  67         name: 'Yandex Browser'
  68       , yandexbrowser: t
  69       , version: versionIdentifier || getFirstMatch(/(?:yabrowser)[\s\/](\d+(\.\d+)?)/i)
  70       }
  71     }
  72     else if (/ucbrowser/i.test(ua)) {
  73       result = {
  74           name: 'UC Browser'
  75         , ucbrowser: t
  76         , version: getFirstMatch(/(?:ucbrowser)[\s\/](\d+(?:\.\d+)+)/i)
  77       }
  78     }
  79     else if (/mxios/i.test(ua)) {
  80       result = {
  81         name: 'Maxthon'
  82         , maxthon: t
  83         , version: getFirstMatch(/(?:mxios)[\s\/](\d+(?:\.\d+)+)/i)
  84       }
  85     }
  86     else if (/epiphany/i.test(ua)) {
  87       result = {
  88         name: 'Epiphany'
  89         , epiphany: t
  90         , version: getFirstMatch(/(?:epiphany)[\s\/](\d+(?:\.\d+)+)/i)
  91       }
  92     }
  93     else if (/puffin/i.test(ua)) {
  94       result = {
  95         name: 'Puffin'
  96         , puffin: t
  97         , version: getFirstMatch(/(?:puffin)[\s\/](\d+(?:\.\d+)?)/i)
  98       }
  99     }
 100     else if (/sleipnir/i.test(ua)) {
 101       result = {
 102         name: 'Sleipnir'
 103         , sleipnir: t
 104         , version: getFirstMatch(/(?:sleipnir)[\s\/](\d+(?:\.\d+)+)/i)
 105       }
 106     }
 107     else if (/k-meleon/i.test(ua)) {
 108       result = {
 109         name: 'K-Meleon'
 110         , kMeleon: t
 111         , version: getFirstMatch(/(?:k-meleon)[\s\/](\d+(?:\.\d+)+)/i)
 112       }
 113     }
 114     else if (windowsphone) {
 115       result = {
 116         name: 'Windows Phone'
 117       , windowsphone: t
 118       }
 119       if (edgeVersion) {
 120         result.msedge = t
 121         result.version = edgeVersion
 122       }
 123       else {
 124         result.msie = t
 125         result.version = getFirstMatch(/iemobile\/(\d+(\.\d+)?)/i)
 126       }
 127     }
 128     else if (/msie|trident/i.test(ua)) {
 129       result = {
 130         name: 'Internet Explorer'
 131       , msie: t
 132       , version: getFirstMatch(/(?:msie |rv:)(\d+(\.\d+)?)/i)
 133       }
 134     } else if (chromeos) {
 135       result = {
 136         name: 'Chrome'
 137       , chromeos: t
 138       , chromeBook: t
 139       , chrome: t
 140       , version: getFirstMatch(/(?:chrome|crios|crmo)\/(\d+(\.\d+)?)/i)
 141       }
 142     } else if (/chrome.+? edge/i.test(ua)) {
 143       result = {
 144         name: 'Microsoft Edge'
 145       , msedge: t
 146       , version: edgeVersion
 147       }
 148     }
 149     else if (/vivaldi/i.test(ua)) {
 150       result = {
 151         name: 'Vivaldi'
 152         , vivaldi: t
 153         , version: getFirstMatch(/vivaldi\/(\d+(\.\d+)?)/i) || versionIdentifier
 154       }
 155     }
 156     else if (sailfish) {
 157       result = {
 158         name: 'Sailfish'
 159       , sailfish: t
 160       , version: getFirstMatch(/sailfish\s?browser\/(\d+(\.\d+)?)/i)
 161       }
 162     }
 163     else if (/seamonkey\//i.test(ua)) {
 164       result = {
 165         name: 'SeaMonkey'
 166       , seamonkey: t
 167       , version: getFirstMatch(/seamonkey\/(\d+(\.\d+)?)/i)
 168       }
 169     }
 170     else if (/firefox|iceweasel|fxios/i.test(ua)) {
 171       result = {
 172         name: 'Firefox'
 173       , firefox: t
 174       , version: getFirstMatch(/(?:firefox|iceweasel|fxios)[ \/](\d+(\.\d+)?)/i)
 175       }
 176       if (/\((mobile|tablet);[^\)]*rv:[\d\.]+\)/i.test(ua)) {
 177         result.firefoxos = t
 178       }
 179     }
 180     else if (silk) {
 181       result =  {
 182         name: 'Amazon Silk'
 183       , silk: t
 184       , version : getFirstMatch(/silk\/(\d+(\.\d+)?)/i)
 185       }
 186     }
 187     else if (/phantom/i.test(ua)) {
 188       result = {
 189         name: 'PhantomJS'
 190       , phantom: t
 191       , version: getFirstMatch(/phantomjs\/(\d+(\.\d+)?)/i)
 192       }
 193     }
 194     else if (/slimerjs/i.test(ua)) {
 195       result = {
 196         name: 'SlimerJS'
 197         , slimer: t
 198         , version: getFirstMatch(/slimerjs\/(\d+(\.\d+)?)/i)
 199       }
 200     }
 201     else if (/blackberry|\bbb\d+/i.test(ua) || /rim\stablet/i.test(ua)) {
 202       result = {
 203         name: 'BlackBerry'
 204       , blackberry: t
 205       , version: versionIdentifier || getFirstMatch(/blackberry[\d]+\/(\d+(\.\d+)?)/i)
 206       }
 207     }
 208     else if (webos) {
 209       result = {
 210         name: 'WebOS'
 211       , webos: t
 212       , version: versionIdentifier || getFirstMatch(/w(?:eb)?osbrowser\/(\d+(\.\d+)?)/i)
 213       };
 214       /touchpad\//i.test(ua) && (result.touchpad = t)
 215     }
 216     else if (/bada/i.test(ua)) {
 217       result = {
 218         name: 'Bada'
 219       , bada: t
 220       , version: getFirstMatch(/dolfin\/(\d+(\.\d+)?)/i)
 221       };
 222     }
 223     else if (tizen) {
 224       result = {
 225         name: 'Tizen'
 226       , tizen: t
 227       , version: getFirstMatch(/(?:tizen\s?)?browser\/(\d+(\.\d+)?)/i) || versionIdentifier
 228       };
 229     }
 230     else if (/qupzilla/i.test(ua)) {
 231       result = {
 232         name: 'QupZilla'
 233         , qupzilla: t
 234         , version: getFirstMatch(/(?:qupzilla)[\s\/](\d+(?:\.\d+)+)/i) || versionIdentifier
 235       }
 236     }
 237     else if (/chromium/i.test(ua)) {
 238       result = {
 239         name: 'Chromium'
 240         , chromium: t
 241         , version: getFirstMatch(/(?:chromium)[\s\/](\d+(?:\.\d+)?)/i) || versionIdentifier
 242       }
 243     }
 244     else if (/chrome|crios|crmo/i.test(ua)) {
 245       result = {
 246         name: 'Chrome'
 247         , chrome: t
 248         , version: getFirstMatch(/(?:chrome|crios|crmo)\/(\d+(\.\d+)?)/i)
 249       }
 250     }
 251     else if (android) {
 252       result = {
 253         name: 'Android'
 254         , version: versionIdentifier
 255       }
 256     }
 257     else if (/safari|applewebkit/i.test(ua)) {
 258       result = {
 259         name: 'Safari'
 260       , safari: t
 261       }
 262       if (versionIdentifier) {
 263         result.version = versionIdentifier
 264       }
 265     }
 266     else if (iosdevice) {
 267       result = {
 268         name : iosdevice == 'iphone' ? 'iPhone' : iosdevice == 'ipad' ? 'iPad' : 'iPod'
 269       }
 270       // WTF: version is not part of user agent in web apps
 271       if (versionIdentifier) {
 272         result.version = versionIdentifier
 273       }
 274     }
 275     else if(/googlebot/i.test(ua)) {
 276       result = {
 277         name: 'Googlebot'
 278       , googlebot: t
 279       , version: getFirstMatch(/googlebot\/(\d+(\.\d+))/i) || versionIdentifier
 280       }
 281     }
 282     else {
 283       result = {
 284         name: getFirstMatch(/^(.*)\/(.*) /),
 285         version: getSecondMatch(/^(.*)\/(.*) /)
 286      };
 287    }
 288
 289     // set webkit or gecko flag for browsers based on these engines
 290     if (!result.msedge && /(apple)?webkit/i.test(ua)) {
 291       if (/(apple)?webkit\/537\.36/i.test(ua)) {
 292         result.name = result.name || "Blink"
 293         result.blink = t
 294       } else {
 295         result.name = result.name || "Webkit"
 296         result.webkit = t
 297       }
 298       if (!result.version && versionIdentifier) {
 299         result.version = versionIdentifier
 300       }
 301     } else if (!result.opera && /gecko\//i.test(ua)) {
 302       result.name = result.name || "Gecko"
 303       result.gecko = t
 304       result.version = result.version || getFirstMatch(/gecko\/(\d+(\.\d+)?)/i)
 305     }
 306
 307     // set OS flags for platforms that have multiple browsers
 308     if (!result.msedge && (android || result.silk)) {
 309       result.android = t
 310     } else if (iosdevice) {
 311       result[iosdevice] = t
 312       result.ios = t
 313     } else if (mac) {
 314       result.mac = t
 315     } else if (xbox) {
 316       result.xbox = t
 317     } else if (windows) {
 318       result.windows = t
 319     } else if (linux) {
 320       result.linux = t
 321     }
 322
 323     // OS version extraction
 324     var osVersion = '';
 325     if (result.windowsphone) {
 326       osVersion = getFirstMatch(/windows phone (?:os)?\s?(\d+(\.\d+)*)/i);
 327     } else if (iosdevice) {
 328       osVersion = getFirstMatch(/os (\d+([_\s]\d+)*) like mac os x/i);
 329       osVersion = osVersion.replace(/[_\s]/g, '.');
 330     } else if (android) {
 331       osVersion = getFirstMatch(/android[ \/-](\d+(\.\d+)*)/i);
 332     } else if (result.webos) {
 333       osVersion = getFirstMatch(/(?:web|hpw)os\/(\d+(\.\d+)*)/i);
 334     } else if (result.blackberry) {
 335       osVersion = getFirstMatch(/rim\stablet\sos\s(\d+(\.\d+)*)/i);
 336     } else if (result.bada) {
 337       osVersion = getFirstMatch(/bada\/(\d+(\.\d+)*)/i);
 338     } else if (result.tizen) {
 339       osVersion = getFirstMatch(/tizen[\/\s](\d+(\.\d+)*)/i);
 340     }
 341     if (osVersion) {
 342       result.osversion = osVersion;
 343     }
 344
 345     // device type extraction
 346     var osMajorVersion = osVersion.split('.')[0];
 347     if (
 348          tablet
 349       || nexusTablet
 350       || iosdevice == 'ipad'
 351       || (android && (osMajorVersion == 3 || (osMajorVersion >= 4 && !mobile)))
 352       || result.silk
 353     ) {
 354       result.tablet = t
 355     } else if (
 356          mobile
 357       || iosdevice == 'iphone'
 358       || iosdevice == 'ipod'
 359       || android
 360       || nexusMobile
 361       || result.blackberry
 362       || result.webos
 363       || result.bada
 364     ) {
 365       result.mobile = t
 366     }
 367
 368     // Graded Browser Support
 369     // http://developer.yahoo.com/yui/articles/gbs
 370     if (result.msedge ||
 371         (result.msie && result.version >= 10) ||
 372         (result.yandexbrowser && result.version >= 15) ||
 373                     (result.vivaldi && result.version >= 1.0) ||
 374         (result.chrome && result.version >= 20) ||
 375         (result.firefox && result.version >= 20.0) ||
 376         (result.safari && result.version >= 6) ||
 377         (result.opera && result.version >= 10.0) ||
 378         (result.ios && result.osversion && result.osversion.split(".")[0] >= 6) ||
 379         (result.blackberry && result.version >= 10.1)
 380         || (result.chromium && result.version >= 20)
 381         ) {
 382       result.a = t;
 383     }
 384     else if ((result.msie && result.version < 10) ||
 385         (result.chrome && result.version < 20) ||
 386         (result.firefox && result.version < 20.0) ||
 387         (result.safari && result.version < 6) ||
 388         (result.opera && result.version < 10.0) ||
 389         (result.ios && result.osversion && result.osversion.split(".")[0] < 6)
 390         || (result.chromium && result.version < 20)
 391         ) {
 392       result.c = t
 393     } else result.x = t
 394
 395     return result
 396   }
 397
 398   var bowser = detect(typeof navigator !== 'undefined' ? navigator.userAgent : '')
 399
 400   bowser.test = function (browserList) {
 401     for (var i = 0; i < browserList.length; ++i) {
 402       var browserItem = browserList[i];
 403       if (typeof browserItem=== 'string') {
 404         if (browserItem in bowser) {
 405           return true;
 406         }
 407       }
 408     }
 409     return false;
 410   }
 411
 412   /**
 413    * Get version precisions count
 414    *
 415    * @example
 416    *   getVersionPrecision("1.10.3") // 3
 417    *
 418    * @param  {string} version
 419    * @return {number}
 420    */
 421   function getVersionPrecision(version) {
 422     return version.split(".").length;
 423   }
 424
 425   /**
 426    * Array::map polyfill
 427    *
 428    * @param  {Array} arr
 429    * @param  {Function} iterator
 430    * @return {Array}
 431    */
 432   function map(arr, iterator) {
 433     var result = [], i;
 434     if (Array.prototype.map) {
 435       return Array.prototype.map.call(arr, iterator);
 436     }
 437     for (i = 0; i < arr.length; i++) {
 438       result.push(iterator(arr[i]));
 439     }
 440     return result;
 441   }
 442
 443   /**
 444    * Calculate browser version weight
 445    *
 446    * @example
 447    *   compareVersions(['1.10.2.1',  '1.8.2.1.90'])    // 1
 448    *   compareVersions(['1.010.2.1', '1.09.2.1.90']);  // 1
 449    *   compareVersions(['1.10.2.1',  '1.10.2.1']);     // 0
 450    *   compareVersions(['1.10.2.1',  '1.0800.2']);     // -1
 451    *
 452    * @param  {Array<String>} versions versions to compare
 453    * @return {Number} comparison result
 454    */
 455   function compareVersions(versions) {
 456     // 1) get common precision for both versions, for example for "10.0" and "9" it should be 2
 457     var precision = Math.max(getVersionPrecision(versions[0]), getVersionPrecision(versions[1]));
 458     var chunks = map(versions, function (version) {
 459       var delta = precision - getVersionPrecision(version);
 460
 461       // 2) "9" -> "9.0" (for precision = 2)
 462       version = version + new Array(delta + 1).join(".0");
 463
 464       // 3) "9.0" -> ["000000000"", "000000009"]
 465       return map(version.split("."), function (chunk) {
 466         return new Array(20 - chunk.length).join("0") + chunk;
 467       }).reverse();
 468     });
 469
 470     // iterate in reverse order by reversed chunks array
 471     while (--precision >= 0) {
 472       // 4) compare: "000000009" > "000000010" = false (but "9" > "10" = true)
 473       if (chunks[0][precision] > chunks[1][precision]) {
 474         return 1;
 475       }
 476       else if (chunks[0][precision] === chunks[1][precision]) {
 477         if (precision === 0) {
 478           // all version chunks are same
 479           return 0;
 480         }
 481       }
 482       else {
 483         return -1;
 484       }
 485     }
 486   }
 487
 488   /**
 489    * Check if browser is unsupported
 490    *
 491    * @example
 492    *   bowser.isUnsupportedBrowser({
 493    *     msie: "10",
 494    *     firefox: "23",
 495    *     chrome: "29",
 496    *     safari: "5.1",
 497    *     opera: "16",
 498    *     phantom: "534"
 499    *   });
 500    *
 501    * @param  {Object}  minVersions map of minimal version to browser
 502    * @param  {Boolean} [strictMode = false] flag to return false if browser wasn't found in map
 503    * @param  {String}  [ua] user agent string
 504    * @return {Boolean}
 505    */
 506   function isUnsupportedBrowser(minVersions, strictMode, ua) {
 507     var _bowser = bowser;
 508
 509     // make strictMode param optional with ua param usage
 510     if (typeof strictMode === 'string') {
 511       ua = strictMode;
 512       strictMode = void(0);
 513     }
 514
 515     if (strictMode === void(0)) {
 516       strictMode = false;
 517     }
 518     if (ua) {
 519       _bowser = detect(ua);
 520     }
 521
 522     var version = "" + _bowser.version;
 523     for (var browser in minVersions) {
 524       if (minVersions.hasOwnProperty(browser)) {
 525         if (_bowser[browser]) {
 526           // browser version and min supported version.
 527           return compareVersions([version, minVersions[browser]]) < 0;
 528         }
 529       }
 530     }
 531
 532     return strictMode; // not found
 533   }
 534
 535   /**
 536    * Check if browser is supported
 537    *
 538    * @param  {Object} minVersions map of minimal version to browser
 539    * @param  {Boolean} [strictMode = false] flag to return false if browser wasn't found in map
 540    * @param  {String}  [ua] user agent string
 541    * @return {Boolean}
 542    */
 543   function check(minVersions, strictMode, ua) {
 544     return !isUnsupportedBrowser(minVersions, strictMode, ua);
 545   }
 546
 547   bowser.isUnsupportedBrowser = isUnsupportedBrowser;
 548   bowser.compareVersions = compareVersions;
 549   bowser.check = check;
 550
 551   /*
 552    * Set our detect method to the main bowser object so we can
 553    * reuse it to test other user agents.
 554    * This is needed to implement future tests.
 555    */
 556   bowser._detect = detect;
 557
 558   return bowser
 559 });