barsa-novin-ray-core 0.0.2

package/esm2020/lib/device.mjs

@@ -0,0 +1,663 @@
+/* eslint-disable */
+const Device = {};
+// * ******* OS Detection ********
+/**
+ * Contains information about the operating system of the Device.
+ * @name Device.os
+ */
+/**
+ * Enumeration containing the names of known operating systems.
+ * @name Device.os.OS
+ */
+/**
+ * The name of the operating system.
+ * @name Device.os.name
+ * @type String
+ */
+/**
+ * The version of the operating system as <code>string</code>. Might be empty if no version can be determined.
+ * @name Device.os.versionStr
+ * @type String
+ */
+/**
+ * The version of the operating system as <code>float</code>. Might be <code>-1</code> if no version can be determined.
+ * @name Device.os.version
+ * @type float
+ */
+/**
+ * If this flag is set to <code>true</code>, a Windows operating system is used.
+ * @name Device.os.windows
+ * @type boolean
+ */
+/**
+ * If this flag is set to <code>true</code>, a Mac operating system is used.
+ * @name Device.os.macintosh
+ * @type boolean
+ */
+/*
+ * If this flag is set to <code>true</code>, an iOS operating system is used.
+ * @name Device.os.ios
+ * @type boolean
+ */
+/**
+ * If this flag is set to <code>true</code>, an Android operating system is used.
+ * @name Device.os.android
+ * @type boolean
+ */
+/*
+ * Windows operating system name.
+ * @see Device.os.name
+ * @name Device.os.OS.WINDOWS
+ */
+/**
+ * MAC operating system name.
+ * @see Device.os.name
+ * @name Device.os.OS.MACINTOSH
+ */
+/**
+ * iOS operating system name.
+ * @see Device.os.name
+ * @name Device.os.OS.IOS
+ */
+/**
+ * Android operating system name.
+ * @see Device.os.name
+ * @name Device.os.OS.ANDROID
+ */
+const OS = {
+    WINDOWS: 'win',
+    MACINTOSH: 'mac',
+    IOS: 'iOS',
+    ANDROID: 'Android'
+};
+const _getMobileOS = () => {
+    const userAgent = navigator.userAgent;
+    // iOS, Android
+    let rPlatform = /\(([a-zA-Z ]+);\s(?:[U]?[;]?)([\D]+)((?:[\d._]*))(?:.*[)][^\d]*)([\d.]*)\s/;
+    let aMatches = userAgent.match(rPlatform);
+    if (aMatches) {
+        const rAppleDevices = /iPhone|iPad|iPod/;
+        if (aMatches[0].match(rAppleDevices)) {
+            aMatches[3] = aMatches[3].replace(/_/g, '.');
+            return {
+                name: OS.IOS,
+                versionStr: aMatches[3]
+            };
+        }
+        if (aMatches[2].match(/Android/)) {
+            aMatches[2] = aMatches[2].replace(/\s/g, '');
+            return {
+                name: OS.ANDROID,
+                versionStr: aMatches[3]
+            };
+        }
+    }
+    // Firefox on Android
+    rPlatform = /\((Android)[\s]?([\d][.\d]*)?;.*Firefox\/[\d][.\d]*/;
+    aMatches = userAgent.match(rPlatform);
+    if (aMatches) {
+        return {
+            name: OS.ANDROID,
+            versionStr: aMatches.length === 3 ? aMatches[2] : ''
+        };
+    }
+    return {};
+};
+const _getDesktopOS = () => {
+    const sPlatform = navigator.platform;
+    if (sPlatform.indexOf('Win') !== -1) {
+        const rVersion = /Windows NT (\d+).(\d)/i; // userAgent since windows 10: Windows NT 10[...]
+        const uaResult = navigator.userAgent.match(rVersion);
+        return {
+            name: OS.WINDOWS,
+            versionStr: (uaResult && uaResult[1]) || ''
+        };
+    }
+    if (sPlatform.indexOf('Mac') !== -1) {
+        return {
+            name: OS.MACINTOSH,
+            versionStr: ''
+        };
+    }
+    return null;
+};
+const _getOS = () => _getMobileOS() || _getDesktopOS();
+const _setOS = () => {
+    if (Device.os) {
+        return;
+    }
+    Device.os = _getOS() || {};
+    Device.os.OS = OS;
+    Device.os.version = Device.os.versionStr ? parseFloat(Device.os.versionStr) : -1;
+    if (Device.os.name) {
+        Object.keys(OS).forEach((name) => {
+            if (OS[name] === Device.os.name) {
+                Device.os[name.toLowerCase()] = true;
+            }
+        });
+    }
+};
+const getOS = () => {
+    if (!Device.os) {
+        _setOS();
+    }
+    return Device.os;
+};
+const isAndroid = () => {
+    if (!Device.os) {
+        _setOS();
+    }
+    return !!Device.os.android;
+};
+// * ******* Browser Detection ********
+/**
+ * Contains information about the used browser.
+ * @name Device.browser
+ */
+/**
+ * Enumeration containing the names of known browsers.
+ * @name Device.browser.BROWSER
+ *
+ * The name of the browser.
+ * @name Device.browser.name
+ * @type String
+ */
+/**
+ * The version of the browser as <code>string</code>. Might be empty if no version can be determined.
+ * @name Device.browser.versionStr
+ * @type String
+ */
+/**
+ * The version of the browser as <code>float</code>. Might be <code>-1</code> if no version can be determined.
+ * @name Device.browser.version
+ * @type float
+ */
+/**
+ * If this flag is set to <code>true</code>, the mobile variant of the browser is used or
+ * a tablet or phone device is detected. This information might not be available for all browsers.
+ * @name Device.browser.mobile
+ * @type boolean
+ */
+/**
+ * If this flag is set to <code>true</code>, the Microsoft Internet Explorer browser is used.
+ * @name Device.browser.internet_explorer
+ * @type boolean
+ * @deprecated since 1.20, use {@link Device.browser.msie} instead.
+ */
+/**
+ * If this flag is set to <code>true</code>, the Microsoft Internet Explorer browser is used.
+ * @name Device.browser.msie
+ * @type boolean
+ */
+/**
+ * If this flag is set to <code>true</code>, the Microsoft Edge browser is used.
+ * @name Device.browser.edge
+ * @type boolean
+ */
+/**
+ * If this flag is set to <code>true</code>, the Mozilla Firefox browser is used.
+ * @name Device.browser.firefox
+ */
+/**
+ * If this flag is set to <code>true</code>, the Google Chrome browser is used.
+ * @name Device.browser.chrome
+ * @type boolean
+ *
+ * If this flag is set to <code>true</code>, the Apple Safari browser is used.
+ *
+ * <b>Note:</b>
+ * This flag is also <code>true</code> when the standalone (fullscreen) mode or webview is used on iOS devices.
+ * Please also note the flags {@link Device.browser.fullscreen} and {@link Device.browser.webview}.
+ *
+ * @name Device.browser.safari
+ * @type boolean
+ */
+/**
+ * If this flag is set to <code>true</code>, a browser featuring a Webkit engine is used.
+ *
+ * <b>Note:</b>
+ * This flag is also <code>true</code> when the used browser was based on the Webkit engine, but
+ * uses another rendering engine in the meantime. For example the Chrome browser started from version 28 and above
+ * uses the Blink rendering engine.
+ *
+ * @name Device.browser.webkit
+ * @type boolean
+ */
+/**
+ * If this flag is set to <code>true</code>, the Safari browser runs in standalone fullscreen mode on iOS.
+ *
+ * <b>Note:</b> This flag is only available if the Safari browser was detected. Furthermore, if this mode is detected,
+ * technically not a standard Safari is used. There might be slight differences in behavior and detection, e.g.
+ * the availability of {@link Device.browser.version}.
+ *
+ * @name Device.browser.fullscreen
+ * @type boolean
+ */
+/**
+ * If this flag is set to <code>true</code>, the Safari browser runs in webview mode on iOS.
+ *
+ * <b>Note:</b> This flag is only available if the Safari browser was detected. Furthermore, if this mode is detected,
+ * technically not a standard Safari is used. There might be slight differences in behavior and detection, e.g.
+ * the availability of {@link Device.browser.version}.
+ *
+ * @name Device.browser.webview
+ * @type boolean
+ */
+/**
+ * If this flag is set to <code>true</code>, the Phantom JS browser is used.
+ * @name Device.browser.phantomJS
+ * @type boolean
+ */
+/**
+ * The version of the used Webkit engine, if available.
+ * @name Device.browser.webkitVersion
+ * @type String
+ */
+/**
+ * If this flag is set to <code>true</code>, a browser featuring a Mozilla engine is used.
+ * @name Device.browser.mozilla
+ * @type boolean
+ */
+/**
+ * Internet Explorer browser name.
+ * @name Device.browser.BROWSER.INTERNET_EXPLORER
+ */
+/**
+ * Edge browser name.
+ * @name Device.browser.BROWSER.EDGE
+ */
+/**
+ * Firefox browser name.
+ * @name Device.browser.BROWSER.FIREFOX
+ */
+/**
+ * Chrome browser name.
+ * @name Device.browser.BROWSER.CHROME
+ */
+/**
+ * Safari browser name.
+ * @name Device.browser.BROWSER.SAFARI
+ */
+/**
+ * Android stock browser name.
+ * @name Device.browser.BROWSER.ANDROID
+ */
+const BROWSER = {
+    INTERNET_EXPLORER: 'ie',
+    EDGE: 'ed',
+    FIREFOX: 'ff',
+    CHROME: 'cr',
+    SAFARI: 'sf',
+    ANDROID: 'an'
+};
+/* !
+ * Taken from jQuery JavaScript Library v1.7.1
+ * http://jquery.com/
+ *
+ * Copyright 2011, John Resig
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * Includes Sizzle.js
+ * http://sizzlejs.com/
+ * Copyright 2011, The Dojo Foundation
+ * Released under the MIT, BSD, and GPL Licenses.
+ *
+ * Date: Mon Nov 21 21:11:03 2011 -0500
+ */
+const _calcBrowser = () => {
+    const sUserAgent = navigator.userAgent.toLowerCase();
+    const rwebkit = /(webkit)[ /]([\w.]+)/;
+    const rmsie = /(msie) ([\w.]+)/;
+    const rmsie11 = /(trident)\/[\w.]+;.*rv:([\w.]+)/;
+    const redge = /(edge)[ /]([\w.]+)/;
+    const rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/;
+    // WinPhone IE11 and MS Edge userAgents contain "WebKit" and "Mozilla" and therefore must be checked first
+    const browserMatch = redge.exec(sUserAgent) ||
+        rmsie11.exec(sUserAgent) ||
+        rwebkit.exec(sUserAgent) ||
+        rmsie.exec(sUserAgent) ||
+        (sUserAgent.indexOf('compatible') < 0 && rmozilla.exec(sUserAgent)) ||
+        [];
+    const oRes = {
+        browser: browserMatch[1] || '',
+        version: browserMatch[2] || '0'
+    };
+    oRes[oRes.browser] = true;
+    return oRes;
+};
+const _getBrowser = () => {
+    const oBrowser = _calcBrowser();
+    const sUserAgent = navigator.userAgent;
+    const oNavigator = window.navigator;
+    // jQuery checks for user agent strings. We differentiate between browsers
+    let oExpMobile;
+    let oResult;
+    let fVersion;
+    // Mozilla
+    if (oBrowser.mozilla) {
+        oExpMobile = /Mobile/;
+        if (sUserAgent.match(/Firefox\/(\d+\.\d+)/)) {
+            fVersion = parseFloat(RegExp.$1);
+            oResult = {
+                name: BROWSER.FIREFOX,
+                versionStr: `${fVersion}`,
+                version: fVersion,
+                mozilla: true,
+                mobile: oExpMobile.test(sUserAgent)
+            };
+        }
+        else {
+            // unknown mozilla browser
+            oResult = {
+                mobile: oExpMobile.test(sUserAgent),
+                mozilla: true,
+                version: -1
+            };
+        }
+    }
+    else if (oBrowser.webkit) {
+        // webkit version is needed for calculation if the mobile android device is a tablet (calculation of other mobile devices work without)
+        const regExpWebkitVersion = sUserAgent.toLowerCase().match(/webkit[/]([\d.]+)/);
+        let webkitVersion;
+        if (regExpWebkitVersion) {
+            webkitVersion = regExpWebkitVersion[1];
+        }
+        oExpMobile = /Mobile/;
+        const aChromeMatch = sUserAgent.match(/(Chrome|CriOS)\/(\d+\.\d+).\d+/);
+        const aFirefoxMatch = sUserAgent.match(/FxiOS\/(\d+\.\d+)/);
+        const aAndroidMatch = sUserAgent.match(/Android .+ Version\/(\d+\.\d+)/);
+        if (aChromeMatch || aFirefoxMatch || aAndroidMatch) {
+            let sName;
+            let sVersion;
+            let bMobile;
+            if (aChromeMatch) {
+                sName = BROWSER.CHROME;
+                bMobile = oExpMobile.test(sUserAgent);
+                sVersion = parseFloat(aChromeMatch[2]);
+            }
+            else if (aFirefoxMatch) {
+                sName = BROWSER.FIREFOX;
+                bMobile = true;
+                sVersion = parseFloat(aFirefoxMatch[1]);
+            }
+            else if (aAndroidMatch) {
+                sName = BROWSER.ANDROID;
+                bMobile = oExpMobile.test(sUserAgent);
+                sVersion = parseFloat(aAndroidMatch[1]);
+            }
+            oResult = {
+                name: sName,
+                mobile: bMobile,
+                versionStr: `${sVersion}`,
+                version: sVersion,
+                webkit: true,
+                webkitVersion
+            };
+        }
+        else {
+            // Safari might have an issue with sUserAgent.match(...); thus changing
+            const oExp = /(Version|PhantomJS)\/(\d+\.\d+).*Safari/;
+            const bStandalone = oNavigator.standalone;
+            if (oExp.test(sUserAgent)) {
+                const aParts = oExp.exec(sUserAgent);
+                fVersion = parseFloat(aParts[2]);
+                oResult = {
+                    name: BROWSER.SAFARI,
+                    versionStr: `${fVersion}`,
+                    fullscreen: false,
+                    webview: false,
+                    version: fVersion,
+                    mobile: oExpMobile.test(sUserAgent),
+                    webkit: true,
+                    webkitVersion,
+                    phantomJS: aParts[1] === 'PhantomJS'
+                };
+            }
+            else if (/iPhone|iPad|iPod/.test(sUserAgent) &&
+                !/CriOS/.test(sUserAgent) &&
+                !/FxiOS/.test(sUserAgent) &&
+                (bStandalone === true || bStandalone === false)) {
+                // WebView or Standalone mode on iOS
+                oResult = {
+                    name: BROWSER.SAFARI,
+                    version: -1,
+                    fullscreen: bStandalone,
+                    webview: !bStandalone,
+                    mobile: oExpMobile.test(sUserAgent),
+                    webkit: true,
+                    webkitVersion
+                };
+            }
+            else {
+                // other webkit based browser
+                oResult = {
+                    mobile: oExpMobile.test(sUserAgent),
+                    webkit: true,
+                    webkitVersion,
+                    version: -1
+                };
+            }
+        }
+    }
+    else if (oBrowser.msie || oBrowser.trident) {
+        fVersion = parseFloat(oBrowser.version);
+        oResult = {
+            name: BROWSER.INTERNET_EXPLORER,
+            versionStr: `${fVersion}`,
+            version: fVersion,
+            msie: true,
+            mobile: false
+        };
+    }
+    else if (oBrowser.edge) {
+        fVersion = parseFloat(oBrowser.version);
+        oResult = {
+            name: BROWSER.EDGE,
+            versionStr: `${fVersion}`,
+            version: fVersion,
+            edge: true
+        };
+    }
+    else {
+        oResult = {
+            name: '',
+            versionStr: '',
+            version: -1,
+            mobile: false
+        };
+    }
+    return oResult;
+};
+const _setBrowser = () => {
+    Device.browser = _getBrowser();
+    Device.browser.BROWSER = BROWSER;
+    if (Device.browser.name) {
+        Object.keys(BROWSER).forEach((b) => {
+            if (BROWSER[b] === Device.browser.name) {
+                Device.browser[b.toLowerCase()] = true;
+            }
+        });
+    }
+};
+const getBrowser = () => {
+    if (!Device.browser) {
+        _setBrowser();
+    }
+    return Device.browser;
+};
+const isIE = () => {
+    if (!Device.browser) {
+        _setBrowser();
+    }
+    return !!Device.browser.msie;
+};
+const isEdge = () => {
+    if (!Device.browser) {
+        _setBrowser();
+    }
+    return !!Device.browser.edge;
+};
+const isChrome = () => {
+    if (!Device.browser) {
+        _setBrowser();
+    }
+    return !!Device.browser.chrome;
+};
+const isFF = () => {
+    if (!Device.browser) {
+        _setBrowser();
+    }
+    return !!Device.browser.firefox;
+};
+const isSafari = () => {
+    if (!Device.browser) {
+        _setBrowser();
+    }
+    return !!Device.browser.safari;
+};
+// * ******* Support Detection ********
+const _setSupport = () => {
+    if (Device.support) {
+        return;
+    }
+    if (!Device.browser) {
+        _setBrowser();
+    }
+    Device.support = {};
+    Device.support.touch = !!('ontouchstart' in window ||
+        navigator.maxTouchPoints > 0 ||
+        (window.DocumentTouch && document instanceof window.DocumentTouch));
+};
+const supportTouch = () => {
+    if (!Device.support) {
+        _setSupport();
+    }
+    return !!Device.support.touch;
+};
+// * ******* System Detection ********
+/**
+ * Provides a basic categorization of the used device based on various indicators.
+ *
+ * <b>Note:</b> Depending on the capabilities of the device it is also possible that multiple flags are set to <code>true</code>.
+ *
+ * @namespace
+ * @name Device.system
+ */
+/**
+ * If this flag is set to <code>true</code>, the device is recognized as a phone.
+ *
+ * @name Device.system.phone
+ * @type boolean
+ */
+/**
+ * @name Device.system.SYSTEMTYPE
+ * Enumeration containing the names of known types of the devices.
+ */
+const SYSTEMTYPE = {
+    TABLET: 'tablet',
+    PHONE: 'phone',
+    DESKTOP: 'desktop',
+    COMBI: 'combi'
+};
+const _isTablet = () => {
+    const sUserAgent = navigator.userAgent;
+    if (Device.os.name === Device.os.OS.IOS) {
+        return /ipad/i.test(sUserAgent);
+    }
+    // in real mobile device
+    if (supportTouch()) {
+        if (Device.os.windows && Device.os.version >= 8) {
+            return true;
+        }
+        if (Device.browser.chrome && Device.os.android && Device.os.version >= 4.4) {
+            return !/Mobile Safari\/[.0-9]+/.test(sUserAgent);
+        }
+        let densityFactor = window.devicePixelRatio ? window.devicePixelRatio : 1; // may be undefined in Windows Phone devices
+        // On Android sometimes window.screen.width returns the logical CSS pixels, sometimes the physical device pixels;
+        // Tests on multiple devices suggest this depends on the Webkit version.
+        // The Webkit patch which changed the behavior was done here: https://bugs.webkit.org/show_bug.cgi?id=106460
+        // Chrome 27 with Webkit 537.36 returns the logical pixels,
+        // Chrome 18 with Webkit 535.19 returns the physical pixels.
+        // The BlackBerry 10 browser with Webkit 537.10+ returns the physical pixels.
+        // So it appears like somewhere above Webkit 537.10 we do not hve to divide by the devicePixelRatio anymore.
+        if (Device.os.android && Device.browser.webkit && parseFloat(Device.browser.webkitVersion) > 537.1) {
+            densityFactor = 1;
+        }
+        // this is how android distinguishes between tablet and phone
+        // http://android-developers.blogspot.de/2011/07/new-tools-for-managing-screen-sizes.html
+        const bTablet = Math.min(window.screen.width / densityFactor, window.screen.height / densityFactor) >= 600;
+        // special workaround for Nexus 7 where the window.screen.width is 600px or 601px in portrait mode (=> tablet)
+        // but window.screen.height 552px in landscape mode (=> phone), because the browser UI takes some space on top.
+        // So the detected device type depends on the orientation :-(
+        // actually this is a Chrome bug, as "width"/"height" should return the entire screen's dimensions and
+        // "availWidth"/"availHeight" should return the size available after subtracting the browser UI
+        /*
+                 if (isLandscape() &&
+                     (window.screen.height === 552 || window.screen.height === 553) // old/new Nexus 7
+                     &&
+                     (/Nexus 7/i.test(sUserAgent))) {
+                     bTablet = true;
+                 }
+                 */
+        return bTablet;
+    }
+    // This simple android phone detection can be used here because this is the mobile emulation mode in desktop browser
+    const bAndroidPhone = /(?=android)(?=.*mobile)/i.test(sUserAgent);
+    // in desktop browser, it's detected as tablet when
+    // 1. Windows 8 device with a touch screen where "Touch" is contained in the userAgent
+    // 2. Android emulation and it's not an Android phone
+    return (Device.browser.msie && sUserAgent.indexOf('Touch') !== -1) || (Device.os.android && !bAndroidPhone);
+};
+const _getSystem = () => {
+    const bTabletDetected = _isTablet();
+    const isWin8Upwards = Device.os.windows && Device.os.version >= 8;
+    const oSystem = {};
+    oSystem.tablet = !!((Device.support.touch || isWin8Upwards) && bTabletDetected);
+    oSystem.phone = !!((Device.os.windows_phone || Device.support.touch) && !bTabletDetected);
+    oSystem.desktop = !!((!oSystem.tablet && !oSystem.phone) || isWin8Upwards);
+    oSystem.combi = oSystem.desktop && oSystem.tablet;
+    oSystem.SYSTEMTYPE = SYSTEMTYPE;
+    return oSystem;
+};
+const _setSystem = () => {
+    _setSupport();
+    _setOS();
+    Device.system = {};
+    Device.system = _getSystem();
+    if (Device.system.tablet || Device.system.phone) {
+        Device.browser.mobile = true;
+    }
+};
+const getSystem = () => {
+    if (!Device.system) {
+        _setSystem();
+    }
+    return Device.system;
+};
+const isDesktop = () => {
+    if (!Device.system) {
+        _setSystem();
+    }
+    return Device.system.desktop;
+};
+const isTablet = () => {
+    if (!Device.system) {
+        _setSystem();
+    }
+    return Device.system.tablet;
+};
+const isPhone = () => {
+    if (!Device.system) {
+        _setSystem();
+    }
+    return Device.system.phone;
+};
+const isMobile = () => {
+    if (!Device.system) {
+        _setSystem();
+    }
+    return Device.browser.mobile;
+};
+export { isIE, isEdge, isChrome, isFF, isSafari, isMobile, isDesktop, isTablet, isPhone, isAndroid, getOS, getSystem, getBrowser, supportTouch };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"device.js","sourceRoot":"","sources":["../../../../projects/barsa-novin-ray-core/src/lib/device.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable */\r\n\r\nconst Device: { [key: string]: any } = {};\r\n\r\n// * ******* OS Detection ********\r\n\r\n/**\r\n * Contains information about the operating system of the Device.\r\n * @name Device.os\r\n */\r\n\r\n/**\r\n * Enumeration containing the names of known operating systems.\r\n * @name Device.os.OS\r\n */\r\n\r\n/**\r\n * The name of the operating system.\r\n * @name Device.os.name\r\n * @type String\r\n */\r\n\r\n/**\r\n * The version of the operating system as <code>string</code>. Might be empty if no version can be determined.\r\n * @name Device.os.versionStr\r\n * @type String\r\n */\r\n\r\n/**\r\n * The version of the operating system as <code>float</code>. Might be <code>-1</code> if no version can be determined.\r\n * @name Device.os.version\r\n * @type float\r\n */\r\n\r\n/**\r\n * If this flag is set to <code>true</code>, a Windows operating system is used.\r\n * @name Device.os.windows\r\n * @type boolean\r\n */\r\n\r\n/**\r\n * If this flag is set to <code>true</code>, a Mac operating system is used.\r\n * @name Device.os.macintosh\r\n * @type boolean\r\n */\r\n\r\n/*\r\n * If this flag is set to <code>true</code>, an iOS operating system is used.\r\n * @name Device.os.ios\r\n * @type boolean\r\n */\r\n\r\n/**\r\n * If this flag is set to <code>true</code>, an Android operating system is used.\r\n * @name Device.os.android\r\n * @type boolean\r\n */\r\n\r\n/*\r\n * Windows operating system name.\r\n * @see Device.os.name\r\n * @name Device.os.OS.WINDOWS\r\n */\r\n\r\n/**\r\n * MAC operating system name.\r\n * @see Device.os.name\r\n * @name Device.os.OS.MACINTOSH\r\n */\r\n\r\n/**\r\n * iOS operating system name.\r\n * @see Device.os.name\r\n * @name Device.os.OS.IOS\r\n */\r\n\r\n/**\r\n * Android operating system name.\r\n * @see Device.os.name\r\n * @name Device.os.OS.ANDROID\r\n */\r\n\r\nconst OS = {\r\n    WINDOWS: 'win',\r\n    MACINTOSH: 'mac',\r\n    IOS: 'iOS',\r\n    ANDROID: 'Android'\r\n};\r\n\r\nconst _getMobileOS = () => {\r\n    const userAgent = navigator.userAgent;\r\n\r\n    // iOS, Android\r\n    let rPlatform = /\\(([a-zA-Z ]+);\\s(?:[U]?[;]?)([\\D]+)((?:[\\d._]*))(?:.*[)][^\\d]*)([\\d.]*)\\s/;\r\n    let aMatches = userAgent.match(rPlatform);\r\n\r\n    if (aMatches) {\r\n        const rAppleDevices = /iPhone|iPad|iPod/;\r\n\r\n        if (aMatches[0].match(rAppleDevices)) {\r\n            aMatches[3] = aMatches[3].replace(/_/g, '.');\r\n\r\n            return {\r\n                name: OS.IOS,\r\n                versionStr: aMatches[3]\r\n            };\r\n        }\r\n\r\n        if (aMatches[2].match(/Android/)) {\r\n            aMatches[2] = aMatches[2].replace(/\\s/g, '');\r\n            return {\r\n                name: OS.ANDROID,\r\n                versionStr: aMatches[3]\r\n            };\r\n        }\r\n    }\r\n\r\n    // Firefox on Android\r\n    rPlatform = /\\((Android)[\\s]?([\\d][.\\d]*)?;.*Firefox\\/[\\d][.\\d]*/;\r\n    aMatches = userAgent.match(rPlatform);\r\n    if (aMatches) {\r\n        return {\r\n            name: OS.ANDROID,\r\n            versionStr: aMatches.length === 3 ? aMatches[2] : ''\r\n        };\r\n    }\r\n    return {};\r\n};\r\n\r\nconst _getDesktopOS = () => {\r\n    const sPlatform = navigator.platform;\r\n    if (sPlatform.indexOf('Win') !== -1) {\r\n        const rVersion = /Windows NT (\\d+).(\\d)/i; // userAgent since windows 10: Windows NT 10[...]\r\n        const uaResult = navigator.userAgent.match(rVersion);\r\n\r\n        return {\r\n            name: OS.WINDOWS,\r\n            versionStr: (uaResult && uaResult[1]) || ''\r\n        };\r\n    }\r\n\r\n    if (sPlatform.indexOf('Mac') !== -1) {\r\n        return {\r\n            name: OS.MACINTOSH,\r\n            versionStr: ''\r\n        };\r\n    }\r\n\r\n    return null;\r\n};\r\n\r\nconst _getOS = () => _getMobileOS() || _getDesktopOS();\r\n\r\nconst _setOS = () => {\r\n    if (Device.os) {\r\n        return;\r\n    }\r\n\r\n    Device.os = _getOS() || {};\r\n    Device.os.OS = OS;\r\n    Device.os.version = Device.os.versionStr ? parseFloat(Device.os.versionStr) : -1;\r\n\r\n    if (Device.os.name) {\r\n        Object.keys(OS).forEach((name) => {\r\n            if (OS[name] === Device.os.name) {\r\n                Device.os[name.toLowerCase()] = true;\r\n            }\r\n        });\r\n    }\r\n};\r\n\r\nconst getOS = () => {\r\n    if (!Device.os) {\r\n        _setOS();\r\n    }\r\n\r\n    return Device.os;\r\n};\r\n\r\nconst isAndroid = () => {\r\n    if (!Device.os) {\r\n        _setOS();\r\n    }\r\n\r\n    return !!Device.os.android;\r\n};\r\n\r\n// * ******* Browser Detection ********\r\n\r\n/**\r\n * Contains information about the used browser.\r\n * @name Device.browser\r\n */\r\n\r\n/**\r\n * Enumeration containing the names of known browsers.\r\n * @name Device.browser.BROWSER\r\n *\r\n * The name of the browser.\r\n * @name Device.browser.name\r\n * @type String\r\n */\r\n\r\n/**\r\n * The version of the browser as <code>string</code>. Might be empty if no version can be determined.\r\n * @name Device.browser.versionStr\r\n * @type String\r\n */\r\n\r\n/**\r\n * The version of the browser as <code>float</code>. Might be <code>-1</code> if no version can be determined.\r\n * @name Device.browser.version\r\n * @type float\r\n */\r\n\r\n/**\r\n * If this flag is set to <code>true</code>, the mobile variant of the browser is used or\r\n * a tablet or phone device is detected. This information might not be available for all browsers.\r\n * @name Device.browser.mobile\r\n * @type boolean\r\n */\r\n\r\n/**\r\n * If this flag is set to <code>true</code>, the Microsoft Internet Explorer browser is used.\r\n * @name Device.browser.internet_explorer\r\n * @type boolean\r\n * @deprecated since 1.20, use {@link Device.browser.msie} instead.\r\n */\r\n\r\n/**\r\n * If this flag is set to <code>true</code>, the Microsoft Internet Explorer browser is used.\r\n * @name Device.browser.msie\r\n * @type boolean\r\n */\r\n\r\n/**\r\n * If this flag is set to <code>true</code>, the Microsoft Edge browser is used.\r\n * @name Device.browser.edge\r\n * @type boolean\r\n */\r\n\r\n/**\r\n * If this flag is set to <code>true</code>, the Mozilla Firefox browser is used.\r\n * @name Device.browser.firefox\r\n */\r\n\r\n/**\r\n * If this flag is set to <code>true</code>, the Google Chrome browser is used.\r\n * @name Device.browser.chrome\r\n * @type boolean\r\n *\r\n * If this flag is set to <code>true</code>, the Apple Safari browser is used.\r\n *\r\n * <b>Note:</b>\r\n * This flag is also <code>true</code> when the standalone (fullscreen) mode or webview is used on iOS devices.\r\n * Please also note the flags {@link Device.browser.fullscreen} and {@link Device.browser.webview}.\r\n *\r\n * @name Device.browser.safari\r\n * @type boolean\r\n */\r\n\r\n/**\r\n * If this flag is set to <code>true</code>, a browser featuring a Webkit engine is used.\r\n *\r\n * <b>Note:</b>\r\n * This flag is also <code>true</code> when the used browser was based on the Webkit engine, but\r\n * uses another rendering engine in the meantime. For example the Chrome browser started from version 28 and above\r\n * uses the Blink rendering engine.\r\n *\r\n * @name Device.browser.webkit\r\n * @type boolean\r\n */\r\n\r\n/**\r\n * If this flag is set to <code>true</code>, the Safari browser runs in standalone fullscreen mode on iOS.\r\n *\r\n * <b>Note:</b> This flag is only available if the Safari browser was detected. Furthermore, if this mode is detected,\r\n * technically not a standard Safari is used. There might be slight differences in behavior and detection, e.g.\r\n * the availability of {@link Device.browser.version}.\r\n *\r\n * @name Device.browser.fullscreen\r\n * @type boolean\r\n */\r\n\r\n/**\r\n * If this flag is set to <code>true</code>, the Safari browser runs in webview mode on iOS.\r\n *\r\n * <b>Note:</b> This flag is only available if the Safari browser was detected. Furthermore, if this mode is detected,\r\n * technically not a standard Safari is used. There might be slight differences in behavior and detection, e.g.\r\n * the availability of {@link Device.browser.version}.\r\n *\r\n * @name Device.browser.webview\r\n * @type boolean\r\n */\r\n\r\n/**\r\n * If this flag is set to <code>true</code>, the Phantom JS browser is used.\r\n * @name Device.browser.phantomJS\r\n * @type boolean\r\n */\r\n\r\n/**\r\n * The version of the used Webkit engine, if available.\r\n * @name Device.browser.webkitVersion\r\n * @type String\r\n */\r\n\r\n/**\r\n * If this flag is set to <code>true</code>, a browser featuring a Mozilla engine is used.\r\n * @name Device.browser.mozilla\r\n * @type boolean\r\n */\r\n\r\n/**\r\n * Internet Explorer browser name.\r\n * @name Device.browser.BROWSER.INTERNET_EXPLORER\r\n */\r\n\r\n/**\r\n * Edge browser name.\r\n * @name Device.browser.BROWSER.EDGE\r\n */\r\n\r\n/**\r\n * Firefox browser name.\r\n * @name Device.browser.BROWSER.FIREFOX\r\n */\r\n\r\n/**\r\n * Chrome browser name.\r\n * @name Device.browser.BROWSER.CHROME\r\n */\r\n\r\n/**\r\n * Safari browser name.\r\n * @name Device.browser.BROWSER.SAFARI\r\n */\r\n\r\n/**\r\n * Android stock browser name.\r\n * @name Device.browser.BROWSER.ANDROID\r\n */\r\n\r\nconst BROWSER = {\r\n    INTERNET_EXPLORER: 'ie',\r\n    EDGE: 'ed',\r\n    FIREFOX: 'ff',\r\n    CHROME: 'cr',\r\n    SAFARI: 'sf',\r\n    ANDROID: 'an'\r\n};\r\n\r\n/* !\r\n * Taken from jQuery JavaScript Library v1.7.1\r\n * http://jquery.com/\r\n *\r\n * Copyright 2011, John Resig\r\n * Dual licensed under the MIT or GPL Version 2 licenses.\r\n * http://jquery.org/license\r\n *\r\n * Includes Sizzle.js\r\n * http://sizzlejs.com/\r\n * Copyright 2011, The Dojo Foundation\r\n * Released under the MIT, BSD, and GPL Licenses.\r\n *\r\n * Date: Mon Nov 21 21:11:03 2011 -0500\r\n */\r\nconst _calcBrowser = () => {\r\n    const sUserAgent = navigator.userAgent.toLowerCase();\r\n\r\n    const rwebkit = /(webkit)[ /]([\\w.]+)/;\r\n    const rmsie = /(msie) ([\\w.]+)/;\r\n    const rmsie11 = /(trident)\\/[\\w.]+;.*rv:([\\w.]+)/;\r\n    const redge = /(edge)[ /]([\\w.]+)/;\r\n    const rmozilla = /(mozilla)(?:.*? rv:([\\w.]+))?/;\r\n\r\n    // WinPhone IE11 and MS Edge userAgents contain \"WebKit\" and \"Mozilla\" and therefore must be checked first\r\n    const browserMatch =\r\n        redge.exec(sUserAgent) ||\r\n        rmsie11.exec(sUserAgent) ||\r\n        rwebkit.exec(sUserAgent) ||\r\n        rmsie.exec(sUserAgent) ||\r\n        (sUserAgent.indexOf('compatible') < 0 && rmozilla.exec(sUserAgent)) ||\r\n        [];\r\n\r\n    const oRes = {\r\n        browser: browserMatch[1] || '',\r\n        version: browserMatch[2] || '0'\r\n    };\r\n    oRes[oRes.browser] = true;\r\n    return oRes;\r\n};\r\n\r\nconst _getBrowser = () => {\r\n    const oBrowser: { [key: string]: any } = _calcBrowser();\r\n    const sUserAgent = navigator.userAgent;\r\n    const oNavigator: { [key: string]: any } = window.navigator;\r\n\r\n    // jQuery checks for user agent strings. We differentiate between browsers\r\n    let oExpMobile;\r\n    let oResult;\r\n    let fVersion;\r\n\r\n    // Mozilla\r\n    if (oBrowser.mozilla) {\r\n        oExpMobile = /Mobile/;\r\n        if (sUserAgent.match(/Firefox\\/(\\d+\\.\\d+)/)) {\r\n            fVersion = parseFloat(RegExp.$1);\r\n            oResult = {\r\n                name: BROWSER.FIREFOX,\r\n                versionStr: `${fVersion}`,\r\n                version: fVersion,\r\n                mozilla: true,\r\n                mobile: oExpMobile.test(sUserAgent)\r\n            };\r\n        } else {\r\n            // unknown mozilla browser\r\n            oResult = {\r\n                mobile: oExpMobile.test(sUserAgent),\r\n                mozilla: true,\r\n                version: -1\r\n            };\r\n        }\r\n    } else if (oBrowser.webkit) {\r\n        // webkit version is needed for calculation if the mobile android device is a tablet (calculation of other mobile devices work without)\r\n        const regExpWebkitVersion = sUserAgent.toLowerCase().match(/webkit[/]([\\d.]+)/);\r\n        let webkitVersion;\r\n        if (regExpWebkitVersion) {\r\n            webkitVersion = regExpWebkitVersion[1];\r\n        }\r\n        oExpMobile = /Mobile/;\r\n        const aChromeMatch = sUserAgent.match(/(Chrome|CriOS)\\/(\\d+\\.\\d+).\\d+/);\r\n        const aFirefoxMatch = sUserAgent.match(/FxiOS\\/(\\d+\\.\\d+)/);\r\n        const aAndroidMatch = sUserAgent.match(/Android .+ Version\\/(\\d+\\.\\d+)/);\r\n\r\n        if (aChromeMatch || aFirefoxMatch || aAndroidMatch) {\r\n            let sName;\r\n            let sVersion;\r\n            let bMobile;\r\n\r\n            if (aChromeMatch) {\r\n                sName = BROWSER.CHROME;\r\n                bMobile = oExpMobile.test(sUserAgent);\r\n                sVersion = parseFloat(aChromeMatch[2]);\r\n            } else if (aFirefoxMatch) {\r\n                sName = BROWSER.FIREFOX;\r\n                bMobile = true;\r\n                sVersion = parseFloat(aFirefoxMatch[1]);\r\n            } else if (aAndroidMatch) {\r\n                sName = BROWSER.ANDROID;\r\n                bMobile = oExpMobile.test(sUserAgent);\r\n                sVersion = parseFloat(aAndroidMatch[1]);\r\n            }\r\n\r\n            oResult = {\r\n                name: sName,\r\n                mobile: bMobile,\r\n                versionStr: `${sVersion}`,\r\n                version: sVersion,\r\n                webkit: true,\r\n                webkitVersion\r\n            };\r\n        } else {\r\n            // Safari might have an issue with sUserAgent.match(...); thus changing\r\n            const oExp = /(Version|PhantomJS)\\/(\\d+\\.\\d+).*Safari/;\r\n            const bStandalone: any = oNavigator.standalone;\r\n            if (oExp.test(sUserAgent)) {\r\n                const aParts: any = oExp.exec(sUserAgent);\r\n                fVersion = parseFloat(aParts[2]);\r\n                oResult = {\r\n                    name: BROWSER.SAFARI,\r\n                    versionStr: `${fVersion}`,\r\n                    fullscreen: false,\r\n                    webview: false,\r\n                    version: fVersion,\r\n                    mobile: oExpMobile.test(sUserAgent),\r\n                    webkit: true,\r\n                    webkitVersion,\r\n                    phantomJS: aParts[1] === 'PhantomJS'\r\n                };\r\n            } else if (\r\n                /iPhone|iPad|iPod/.test(sUserAgent) &&\r\n                !/CriOS/.test(sUserAgent) &&\r\n                !/FxiOS/.test(sUserAgent) &&\r\n                (bStandalone === true || bStandalone === false)\r\n            ) {\r\n                // WebView or Standalone mode on iOS\r\n                oResult = {\r\n                    name: BROWSER.SAFARI,\r\n                    version: -1,\r\n                    fullscreen: bStandalone,\r\n                    webview: !bStandalone,\r\n                    mobile: oExpMobile.test(sUserAgent),\r\n                    webkit: true,\r\n                    webkitVersion\r\n                };\r\n            } else {\r\n                // other webkit based browser\r\n                oResult = {\r\n                    mobile: oExpMobile.test(sUserAgent),\r\n                    webkit: true,\r\n                    webkitVersion,\r\n                    version: -1\r\n                };\r\n            }\r\n        }\r\n    } else if (oBrowser.msie || oBrowser.trident) {\r\n        fVersion = parseFloat(oBrowser.version);\r\n\r\n        oResult = {\r\n            name: BROWSER.INTERNET_EXPLORER,\r\n            versionStr: `${fVersion}`,\r\n            version: fVersion,\r\n            msie: true,\r\n            mobile: false\r\n        };\r\n    } else if (oBrowser.edge) {\r\n        fVersion = parseFloat(oBrowser.version);\r\n        oResult = {\r\n            name: BROWSER.EDGE,\r\n            versionStr: `${fVersion}`,\r\n            version: fVersion,\r\n            edge: true\r\n        };\r\n    } else {\r\n        oResult = {\r\n            name: '',\r\n            versionStr: '',\r\n            version: -1,\r\n            mobile: false\r\n        };\r\n    }\r\n\r\n    return oResult;\r\n};\r\n\r\nconst _setBrowser = () => {\r\n    Device.browser = _getBrowser();\r\n    Device.browser.BROWSER = BROWSER;\r\n\r\n    if (Device.browser.name) {\r\n        Object.keys(BROWSER).forEach((b) => {\r\n            if (BROWSER[b] === Device.browser.name) {\r\n                Device.browser[b.toLowerCase()] = true;\r\n            }\r\n        });\r\n    }\r\n};\r\n\r\nconst getBrowser = () => {\r\n    if (!Device.browser) {\r\n        _setBrowser();\r\n    }\r\n    return Device.browser;\r\n};\r\n\r\nconst isIE = () => {\r\n    if (!Device.browser) {\r\n        _setBrowser();\r\n    }\r\n    return !!Device.browser.msie;\r\n};\r\n\r\nconst isEdge = () => {\r\n    if (!Device.browser) {\r\n        _setBrowser();\r\n    }\r\n    return !!Device.browser.edge;\r\n};\r\n\r\nconst isChrome = () => {\r\n    if (!Device.browser) {\r\n        _setBrowser();\r\n    }\r\n    return !!Device.browser.chrome;\r\n};\r\n\r\nconst isFF = () => {\r\n    if (!Device.browser) {\r\n        _setBrowser();\r\n    }\r\n    return !!Device.browser.firefox;\r\n};\r\n\r\nconst isSafari = () => {\r\n    if (!Device.browser) {\r\n        _setBrowser();\r\n    }\r\n    return !!Device.browser.safari;\r\n};\r\n\r\n// * ******* Support Detection ********\r\n\r\nconst _setSupport = () => {\r\n    if (Device.support) {\r\n        return;\r\n    }\r\n\r\n    if (!Device.browser) {\r\n        _setBrowser();\r\n    }\r\n\r\n    Device.support = {};\r\n    Device.support.touch = !!(\r\n        'ontouchstart' in window ||\r\n        navigator.maxTouchPoints > 0 ||\r\n        ((window as any).DocumentTouch && document instanceof (window as any).DocumentTouch)\r\n    );\r\n};\r\n\r\nconst supportTouch = () => {\r\n    if (!Device.support) {\r\n        _setSupport();\r\n    }\r\n\r\n    return !!Device.support.touch;\r\n};\r\n\r\n// * ******* System Detection ********\r\n\r\n/**\r\n * Provides a basic categorization of the used device based on various indicators.\r\n *\r\n * <b>Note:</b> Depending on the capabilities of the device it is also possible that multiple flags are set to <code>true</code>.\r\n *\r\n * @namespace\r\n * @name Device.system\r\n */\r\n\r\n/**\r\n * If this flag is set to <code>true</code>, the device is recognized as a phone.\r\n *\r\n * @name Device.system.phone\r\n * @type boolean\r\n */\r\n\r\n/**\r\n * @name Device.system.SYSTEMTYPE\r\n * Enumeration containing the names of known types of the devices.\r\n */\r\n\r\nconst SYSTEMTYPE = {\r\n    TABLET: 'tablet',\r\n    PHONE: 'phone',\r\n    DESKTOP: 'desktop',\r\n    COMBI: 'combi'\r\n};\r\n\r\nconst _isTablet = () => {\r\n    const sUserAgent = navigator.userAgent;\r\n    if (Device.os.name === Device.os.OS.IOS) {\r\n        return /ipad/i.test(sUserAgent);\r\n    }\r\n    // in real mobile device\r\n    if (supportTouch()) {\r\n        if (Device.os.windows && Device.os.version >= 8) {\r\n            return true;\r\n        }\r\n\r\n        if (Device.browser.chrome && Device.os.android && Device.os.version >= 4.4) {\r\n            return !/Mobile Safari\\/[.0-9]+/.test(sUserAgent);\r\n        }\r\n        let densityFactor = window.devicePixelRatio ? window.devicePixelRatio : 1; // may be undefined in Windows Phone devices\r\n        // On Android sometimes window.screen.width returns the logical CSS pixels, sometimes the physical device pixels;\r\n        // Tests on multiple devices suggest this depends on the Webkit version.\r\n        // The Webkit patch which changed the behavior was done here: https://bugs.webkit.org/show_bug.cgi?id=106460\r\n        // Chrome 27 with Webkit 537.36 returns the logical pixels,\r\n        // Chrome 18 with Webkit 535.19 returns the physical pixels.\r\n        // The BlackBerry 10 browser with Webkit 537.10+ returns the physical pixels.\r\n        // So it appears like somewhere above Webkit 537.10 we do not hve to divide by the devicePixelRatio anymore.\r\n        if (Device.os.android && Device.browser.webkit && parseFloat(Device.browser.webkitVersion) > 537.1) {\r\n            densityFactor = 1;\r\n        }\r\n\r\n        // this is how android distinguishes between tablet and phone\r\n        // http://android-developers.blogspot.de/2011/07/new-tools-for-managing-screen-sizes.html\r\n        const bTablet = Math.min(window.screen.width / densityFactor, window.screen.height / densityFactor) >= 600;\r\n\r\n        // special workaround for Nexus 7 where the window.screen.width is 600px or 601px in portrait mode (=> tablet)\r\n        // but window.screen.height 552px in landscape mode (=> phone), because the browser UI takes some space on top.\r\n        // So the detected device type depends on the orientation :-(\r\n        // actually this is a Chrome bug, as \"width\"/\"height\" should return the entire screen's dimensions and\r\n        // \"availWidth\"/\"availHeight\" should return the size available after subtracting the browser UI\r\n\r\n        /*\r\n                 if (isLandscape() &&\r\n                     (window.screen.height === 552 || window.screen.height === 553) // old/new Nexus 7\r\n                     &&\r\n                     (/Nexus 7/i.test(sUserAgent))) {\r\n                     bTablet = true;\r\n                 }\r\n                 */\r\n\r\n        return bTablet;\r\n    }\r\n    // This simple android phone detection can be used here because this is the mobile emulation mode in desktop browser\r\n    const bAndroidPhone = /(?=android)(?=.*mobile)/i.test(sUserAgent);\r\n    // in desktop browser, it's detected as tablet when\r\n    // 1. Windows 8 device with a touch screen where \"Touch\" is contained in the userAgent\r\n    // 2. Android emulation and it's not an Android phone\r\n    return (Device.browser.msie && sUserAgent.indexOf('Touch') !== -1) || (Device.os.android && !bAndroidPhone);\r\n};\r\n\r\nconst _getSystem = () => {\r\n    const bTabletDetected = _isTablet();\r\n    const isWin8Upwards = Device.os.windows && Device.os.version >= 8;\r\n\r\n    const oSystem: { [key: string]: any } = {};\r\n    oSystem.tablet = !!((Device.support.touch || isWin8Upwards) && bTabletDetected);\r\n    oSystem.phone = !!((Device.os.windows_phone || Device.support.touch) && !bTabletDetected);\r\n    oSystem.desktop = !!((!oSystem.tablet && !oSystem.phone) || isWin8Upwards);\r\n    oSystem.combi = oSystem.desktop && oSystem.tablet;\r\n    oSystem.SYSTEMTYPE = SYSTEMTYPE;\r\n\r\n    return oSystem;\r\n};\r\n\r\nconst _setSystem = () => {\r\n    _setSupport();\r\n    _setOS();\r\n\r\n    Device.system = {};\r\n    Device.system = _getSystem();\r\n    if (Device.system.tablet || Device.system.phone) {\r\n        Device.browser.mobile = true;\r\n    }\r\n};\r\n\r\nconst getSystem = () => {\r\n    if (!Device.system) {\r\n        _setSystem();\r\n    }\r\n\r\n    return Device.system;\r\n};\r\n\r\nconst isDesktop = () => {\r\n    if (!Device.system) {\r\n        _setSystem();\r\n    }\r\n\r\n    return Device.system.desktop;\r\n};\r\n\r\nconst isTablet = () => {\r\n    if (!Device.system) {\r\n        _setSystem();\r\n    }\r\n\r\n    return Device.system.tablet;\r\n};\r\n\r\nconst isPhone = () => {\r\n    if (!Device.system) {\r\n        _setSystem();\r\n    }\r\n\r\n    return Device.system.phone;\r\n};\r\n\r\nconst isMobile = () => {\r\n    if (!Device.system) {\r\n        _setSystem();\r\n    }\r\n\r\n    return Device.browser.mobile;\r\n};\r\n\r\nexport {\r\n    isIE,\r\n    isEdge,\r\n    isChrome,\r\n    isFF,\r\n    isSafari,\r\n    isMobile,\r\n    isDesktop,\r\n    isTablet,\r\n    isPhone,\r\n    isAndroid,\r\n    getOS,\r\n    getSystem,\r\n    getBrowser,\r\n    supportTouch\r\n};\r\n"]}