text: /*!
   * Bowser - a browser detector
   * https://github.com/ded/bowser
   * MIT License | (c) Dustin Diaz 2015
   */
  
  !function (name, definition) {
    if (typeof module != 'undefined' && module.exports) module.exports = definition()
    else if (typeof define == 'function' && define.amd) define(definition)
    else this[name] = definition()
  }('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)
        , 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)
        , mobile = !tablet && /[^-]mobi/i.test(ua)
        , xbox = /xbox/i.test(ua)
        , result
  
      if (/opera|opr|opios/i.test(ua)) {
        result = {
          name: 'Opera'
        , opera: t
        , version: versionIdentifier || getFirstMatch(/(?:opera|opr|opios)[\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 (/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 (/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.msedge && (android || result.silk)) {
        result.android = t
      } else if (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
      }
  
      // OS version extraction
      var osVersion = '';
      if (result.windowsphone) {
        osVersion = getFirstMatch(/windows phone (?:os)?\s?(\d+(\.\d+)*)/i);
      } 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 = 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.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.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.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;
    }
  
    /*
     * 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
  });
  