├── .eslintignore
├── .npmignore
├── .npmrc
├── src
    ├── index.ts
    ├── index.browser.ts
    ├── __tests__
    │   ├── desktop.test.ts
    │   ├── android.test.ts
    │   ├── other.test.ts
    │   ├── windows.test.ts
    │   ├── browser.e2e.test.ts
    │   ├── apple.test.ts
    │   └── amazon.test.ts
    └── isMobile.ts
├── prettier.config.js
├── types
    ├── index.d.ts
    ├── index.d.ts.map
    ├── isMobile.d.ts.map
    └── isMobile.d.ts
├── .dependabot
    └── config.yml
├── .eslintrc.js
├── tsconfig.json
├── jest.config.js
├── .gitignore
├── .github
    └── workflows
    │   ├── pull_request.yml
    │   └── release.yml
├── CONTRIBUTORS.md
├── LICENSE
├── package.json
└── README.md


/.eslintignore:
--------------------------------------------------------------------------------
1 | cjs
2 | dist
3 | esm
4 | 


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | *.tsbuildinfo
2 | .cache
3 | coverage


--------------------------------------------------------------------------------
/.npmrc:
--------------------------------------------------------------------------------
1 | registry=https://registry.npmjs.org
2 | 


--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
1 | export * from './isMobile';
2 | export { default } from './isMobile';
3 | 


--------------------------------------------------------------------------------
/prettier.config.js:
--------------------------------------------------------------------------------
1 | module.exports = require('@spotify/web-scripts/config/prettier.config.js');
2 | 


--------------------------------------------------------------------------------
/types/index.d.ts:
--------------------------------------------------------------------------------
1 | export * from './isMobile';
2 | export { default } from './isMobile';
3 | // # sourceMappingURL=index.d.ts.map
4 | 


--------------------------------------------------------------------------------
/.dependabot/config.yml:
--------------------------------------------------------------------------------
1 | version: 1
2 | update_configs:
3 |   - package_manager: "javascript"
4 |     directory: "/"
5 |     update_schedule: "daily"
6 | 


--------------------------------------------------------------------------------
/types/index.d.ts.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC"}


--------------------------------------------------------------------------------
/.eslintrc.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 |   ...require('@spotify/web-scripts/config/eslintrc.js'),
3 |   rules: {
4 |     'no-redeclare': 'off',
5 |     '@typescript-eslint/no-redeclare': ['error'],
6 |   },
7 | };
8 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 |   "extends": "@spotify/web-scripts/config/tsconfig.json",
3 |   "include": ["src"],
4 |   "exclude": ["src/__tests__", "src/index.browser.ts"],
5 |   "compilerOptions": {
6 |     "target": "es3"
7 |   }
8 | }
9 | 


--------------------------------------------------------------------------------
/jest.config.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 |   roots: ['<rootDir>/src/__tests__'],
 3 |   transform: {
 4 |     '^.+\\.ts$': 'ts-jest',
 5 |   },
 6 |   testRegex: '^.+\\.ts$',
 7 |   moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
 8 |   preset: 'jest-puppeteer',
 9 | };
10 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Generated output
 2 | cjs
 3 | esm
 4 | dist
 5 | 
 6 | # TypeScript incremental compilation cache
 7 | *.tsbuildinfo
 8 | 
 9 | # Parcel cache
10 | .cache
11 | 
12 | # Node modules
13 | node_modules
14 | 
15 | # NPM lock file (we use Yarn's)
16 | package-lock.json
17 | 
18 | # Logs
19 | npm-debug.log*
20 | yarn-debug.log*
21 | yarn-error.log*
22 | 
23 | # Coverage
24 | coverage/
25 | 
26 | # Mac OS
27 | .DS_Store
28 | 
29 | 


--------------------------------------------------------------------------------
/.github/workflows/pull_request.yml:
--------------------------------------------------------------------------------
 1 | name: Node CI
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - refs/pull/*
 7 |   pull_request:
 8 | 
 9 | jobs:
10 |   build:
11 |     runs-on: ubuntu-latest
12 |     strategy:
13 |       matrix:
14 |         node-version: [10, 12, 14]
15 |     steps:
16 |       - uses: actions/checkout@v2
17 |       - uses: actions/setup-node@v1
18 |         with:
19 |           node-version: ${{ matrix.node-version }}
20 |       - run: yarn install
21 |       - run: yarn lint
22 |       - run: yarn build
23 |       - run: yarn test
24 | 


--------------------------------------------------------------------------------
/src/index.browser.ts:
--------------------------------------------------------------------------------
 1 | import isMobile from './';
 2 | 
 3 | /**
 4 |  * This file is used to generate the browser version of this library.
 5 |  * It is compiled as `isMobile.min.js` into the `dist` directory.
 6 |  *
 7 |  * The `dist` directory is published to NPM so that the compiled file can
 8 |  * can be easily accessed by consumers of the library via the jsDelivr CDN.
 9 |  *
10 |  * It is meant to be included via a `<script>` tag and will execute
11 |  * immediately, assigning its result to the `isMobile` global variable.
12 |  */
13 | 
14 | exports = isMobile();
15 | 


--------------------------------------------------------------------------------
/.github/workflows/release.yml:
--------------------------------------------------------------------------------
 1 | name: Node CD
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - master
 7 | 
 8 | jobs:
 9 |   build:
10 |     runs-on: ubuntu-latest
11 |     steps:
12 |       - uses: actions/checkout@v2
13 |       - uses: actions/setup-node@v1
14 |         with:
15 |           node-version: "14.x"
16 |           registry-url: "https://registry.npmjs.org"
17 |       - run: yarn install
18 |       - run: yarn build
19 |       - run: yarn release
20 |         env:
21 |           GH_TOKEN: ${{ secrets.GH_TOKEN }}
22 |           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
23 |           NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
24 | 


--------------------------------------------------------------------------------
/CONTRIBUTORS.md:
--------------------------------------------------------------------------------
 1 | * Igor Ribeio Lima ([https://github.com/igorlima](https://github.com/igorlima))
 2 | * Clay Hinson ([https://github.com/clayhinson](https://github.com/clayhinson))
 3 | * Vitaly Orlov ([https://github.com/orloffv](https://github.com/orloffv))
 4 | * Shinnosuke Watanabe ([https://github.com/shinnn](https://github.com/shinnn))
 5 | * Vladimir Matsola ([https://github.com/vomchik](https://github.com/vomchik))
 6 | * Bryce Neal ([https://github.com/prettymuchbryce](https://github.com/prettymuchbryce))
 7 | * Todd Smith-Salter ([https://github.com/ToddSmithSalter](https://github.com/ToddSmithSalter))
 8 | * Ma Cheng ([https://github.com/mc-zone](https://github.com/mc-zone))
 9 | * Ruslan Ismagilov ([https://github.com/isRuslan](https://github.com/isRuslan))
10 | * Samuli Hiltunen ([https://github.com/samuli-hiltunen-somedia](https://github.com/samuli-hiltunen-somedia))
11 | 


--------------------------------------------------------------------------------
/src/__tests__/desktop.test.ts:
--------------------------------------------------------------------------------
 1 | import isMobile, { isMobileResult } from '../';
 2 | 
 3 | describe('Desktop', () => {
 4 |   let mobile: isMobileResult;
 5 |   let userAgent: string;
 6 | 
 7 |   describe('Chrome', () => {
 8 |     beforeEach(() => {
 9 |       userAgent =
10 |         'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_3) AppleWebKit/535.19 (KHTML, like Gecko) Chrome/18.0.1025.151 Safari/535.19';
11 |       mobile = isMobile(userAgent);
12 |     });
13 | 
14 |     test('should not be a mobile device', () => {
15 |       expect(mobile.any).not.toBe(true);
16 |     });
17 |   });
18 | 
19 |   describe('Safari', () => {
20 |     beforeEach(() => {
21 |       userAgent =
22 |         'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_3) AppleWebKit/534.53.11 (KHTML, like Gecko) Version/5.1.3 Safari/534.53.10';
23 |       mobile = isMobile(userAgent);
24 |     });
25 | 
26 |     test('should not be a mobile device', () => {
27 |       expect(mobile.any).not.toBe(true);
28 |     });
29 |   });
30 | });
31 | 


--------------------------------------------------------------------------------
/types/isMobile.d.ts.map:
--------------------------------------------------------------------------------
1 | {"version":3,"file":"isMobile.d.ts","sourceRoot":"","sources":["../src/isMobile.ts"],"names":[],"mappings":"AAgBA,oBAAY,SAAS,GAAG,MAAM,CAAC;AAC/B,oBAAY,SAAS,GAAG;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAgBF,oBAAY,cAAc,GAAG;IAC3B,KAAK,EAAE;QACL,KAAK,EAAE,OAAO,CAAC;QACf,IAAI,EAAE,OAAO,CAAC;QACd,MAAM,EAAE,OAAO,CAAC;QAChB,SAAS,EAAE,OAAO,CAAC;QACnB,MAAM,EAAE,OAAO,CAAC;KACjB,CAAC;IACF,MAAM,EAAE;QACN,KAAK,EAAE,OAAO,CAAC;QACf,MAAM,EAAE,OAAO,CAAC;QAChB,MAAM,EAAE,OAAO,CAAC;KACjB,CAAC;IACF,OAAO,EAAE;QACP,KAAK,EAAE,OAAO,CAAC;QACf,MAAM,EAAE,OAAO,CAAC;QAChB,MAAM,EAAE,OAAO,CAAC;KACjB,CAAC;IACF,OAAO,EAAE;QACP,KAAK,EAAE,OAAO,CAAC;QACf,MAAM,EAAE,OAAO,CAAC;QAChB,MAAM,EAAE,OAAO,CAAC;KACjB,CAAC;IACF,KAAK,EAAE;QACL,UAAU,EAAE,OAAO,CAAC;QACpB,YAAY,EAAE,OAAO,CAAC;QACtB,KAAK,EAAE,OAAO,CAAC;QACf,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,EAAE,OAAO,CAAC;QAChB,MAAM,EAAE,OAAO,CAAC;KACjB,CAAC;IACF,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;IAChB,GAAG,EAAE,OAAO,CAAC;CACd,CAAC;AAEF,oBAAY,iBAAiB,GAAG,SAAS,GAAG,SAAS,CAAC;AAEtD,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,KAAK,CAAC,EAAE,iBAAiB,GAAG,cAAc,CAoH1E"}


--------------------------------------------------------------------------------
/types/isMobile.d.ts:
--------------------------------------------------------------------------------
 1 | export declare type UserAgent = string;
 2 | export declare type Navigator = {
 3 |   userAgent: string;
 4 |   platform: string;
 5 |   maxTouchPoints?: number;
 6 | };
 7 | export declare type isMobileResult = {
 8 |   apple: {
 9 |     phone: boolean;
10 |     ipod: boolean;
11 |     tablet: boolean;
12 |     universal: boolean;
13 |     device: boolean;
14 |   };
15 |   amazon: {
16 |     phone: boolean;
17 |     tablet: boolean;
18 |     device: boolean;
19 |   };
20 |   android: {
21 |     phone: boolean;
22 |     tablet: boolean;
23 |     device: boolean;
24 |   };
25 |   windows: {
26 |     phone: boolean;
27 |     tablet: boolean;
28 |     device: boolean;
29 |   };
30 |   other: {
31 |     blackberry: boolean;
32 |     blackberry10: boolean;
33 |     opera: boolean;
34 |     firefox: boolean;
35 |     chrome: boolean;
36 |     device: boolean;
37 |   };
38 |   phone: boolean;
39 |   tablet: boolean;
40 |   any: boolean;
41 | };
42 | export declare type IsMobileParameter = UserAgent | Navigator;
43 | export default function isMobile(param?: IsMobileParameter): isMobileResult;
44 | // # sourceMappingURL=isMobile.d.ts.map
45 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 Kai Mallea
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "ismobilejs",
 3 |   "publishConfig": {
 4 |     "access": "public"
 5 |   },
 6 |   "version": "0.0.0-development",
 7 |   "description": "A simple JS library that detects mobile devices.",
 8 |   "keywords": [
 9 |     "ismobile",
10 |     "device detection",
11 |     "mobile devices",
12 |     "useragent"
13 |   ],
14 |   "homepage": "https://github.com/kaimallea/isMobile",
15 |   "license": "MIT",
16 |   "author": {
17 |     "name": "Kai Mallea",
18 |     "email": "kmallea@gmail.com"
19 |   },
20 |   "repository": {
21 |     "type": "git",
22 |     "url": "https://github.com/kaimallea/isMobile.git"
23 |   },
24 |   "main": "cjs/index.js",
25 |   "module": "esm/index.js",
26 |   "jsdelivr": "dist/isMobile.min.js",
27 |   "types": "types",
28 |   "scripts": {
29 |     "prebuild": "rm -rf cjs esm dist",
30 |     "build": "yarn build:library && yarn build:browser",
31 |     "build:library": "web-scripts build",
32 |     "build:browser": "parcel build --target browser --experimental-scope-hoisting --global isMobile --out-file isMobile.min.js src/index.browser.ts",
33 |     "test": "jest",
34 |     "format": "web-scripts format",
35 |     "lint": "web-scripts lint",
36 |     "commit": "web-scripts commit",
37 |     "release": "web-scripts release",
38 |     "prepare": "web-scripts audit"
39 |   },
40 |   "husky": {
41 |     "hooks": {
42 |       "pre-commit": "web-scripts precommit --jest-config ./jest.config.js",
43 |       "commit-msg": "web-scripts commitmsg"
44 |     }
45 |   },
46 |   "devDependencies": {
47 |     "@spotify/web-scripts": "^9.0.0",
48 |     "@types/puppeteer": "^5.4.2",
49 |     "husky": "^6.0.0",
50 |     "jest-puppeteer": "^4.4.0",
51 |     "parcel-bundler": "^1.12.4",
52 |     "puppeteer": "^8.0.0",
53 |     "ts-jest": "^26.4.4"
54 |   },
55 |   "dependencies": {
56 |     "caniuse-lite": "^1.0.30001173"
57 |   }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/__tests__/android.test.ts:
--------------------------------------------------------------------------------
 1 | import isMobile, { isMobileResult } from '../';
 2 | 
 3 | describe('Android', () => {
 4 |   let mobile: isMobileResult;
 5 |   let userAgent: string;
 6 | 
 7 |   describe('Phone UserAgent', () => {
 8 |     beforeEach(() => {
 9 |       userAgent =
10 |         'Mozilla/5.0 (Linux; <Android Version>; <Build Tag etc.>) AppleWebKit/<WebKit Rev> (KHTML, like Gecko) Chrome/<Chrome Rev> Mobile Safari/<WebKit Rev>';
11 |       mobile = isMobile(userAgent);
12 |     });
13 | 
14 |     test('should be an Android Phone', () => {
15 |       expect(mobile.android.phone).toBe(true);
16 |     });
17 | 
18 |     test('should not be an Android Tablet', () => {
19 |       expect(mobile.android.tablet).not.toBe(true);
20 |     });
21 | 
22 |     test('should be matched as Any Phone', () => {
23 |       expect(mobile.phone).toBe(true);
24 |     });
25 | 
26 |     test('should be an Android device', () => {
27 |       expect(mobile.android.device).toBe(true);
28 |     });
29 |   });
30 | 
31 |   describe('Tablet UserAgent', () => {
32 |     beforeEach(() => {
33 |       userAgent =
34 |         'Mozilla/5.0 (Linux; <Android Version>; <Build Tag etc.>) AppleWebKit/<WebKit Rev>(KHTML, like Gecko) Chrome/<Chrome Rev> Safari/<WebKit Rev>';
35 |       mobile = isMobile(userAgent);
36 |     });
37 | 
38 |     test('should not be an Android Phone', () => {
39 |       expect(mobile.android.phone).not.toBe(true);
40 |     });
41 | 
42 |     test('should be an Android Tablet', () => {
43 |       expect(mobile.android.tablet).toBe(true);
44 |     });
45 | 
46 |     test('should be matched as Any Tablet', () => {
47 |       expect(mobile.tablet).toBe(true);
48 |     });
49 | 
50 |     test('should be an Android device', () => {
51 |       expect(mobile.android.device).toBe(true);
52 |     });
53 |   });
54 | 
55 |   describe('OkHttp UserAgent', () => {
56 |     beforeEach(() => {
57 |       userAgent = 'okhttp/3.9.1';
58 |       mobile = isMobile(userAgent);
59 |     });
60 | 
61 |     test('should not be an Android Phone', () => {
62 |       expect(mobile.android.phone).toBe(false);
63 |     });
64 | 
65 |     test('should not be an Android Tablet', () => {
66 |       expect(mobile.android.tablet).toBe(false);
67 |     });
68 | 
69 |     test('should be matched as Any Tablet', () => {
70 |       expect(mobile.tablet).toBe(false);
71 |     });
72 | 
73 |     test('should be an Android device', () => {
74 |       expect(mobile.android.device).toBe(true);
75 |     });
76 |   });
77 | });
78 | 


--------------------------------------------------------------------------------
/src/__tests__/other.test.ts:
--------------------------------------------------------------------------------
  1 | import isMobile, { isMobileResult } from '../';
  2 | 
  3 | describe('Other Mobile Devices', () => {
  4 |   let mobile: isMobileResult;
  5 |   let userAgent: string;
  6 | 
  7 |   describe('BlackBerry 10', () => {
  8 |     beforeEach(() => {
  9 |       userAgent =
 10 |         'Mozilla/5.0 (BB10; Touch) AppleWebKit/537.35+ (KHTML, like Gecko) Version/10.2.0.1791 Mobile Safari/537.35+';
 11 |       mobile = isMobile(userAgent);
 12 |     });
 13 | 
 14 |     test('should not be a Chrome device', () => {
 15 |       expect(mobile.other.chrome).not.toBe(true);
 16 |     });
 17 | 
 18 |     test('should be a BlackBerry 10 device', () => {
 19 |       expect(mobile.other.blackberry10).toBe(true);
 20 |     });
 21 | 
 22 |     test('should not be a BlackBerry device', () => {
 23 |       expect(mobile.other.blackberry).not.toBe(true);
 24 |     });
 25 | 
 26 |     test('should not be an Android device', () => {
 27 |       expect(mobile.android.device).not.toBe(true);
 28 |     });
 29 | 
 30 |     test('should not be an Apple device', () => {
 31 |       expect(mobile.apple.device).not.toBe(true);
 32 |     });
 33 | 
 34 |     test('should be a mobile device', () => {
 35 |       expect(mobile.any).toBe(true);
 36 |     });
 37 |   });
 38 | 
 39 |   describe('BlackBerry', () => {
 40 |     beforeEach(() => {
 41 |       userAgent =
 42 |         'Mozilla/5.0 (BlackBerry; U; BlackBerry 9900; en) AppleWebKit/534.11+ (KHTML, like Gecko) Version/7.1.0.346 Mobile Safari/534.11+';
 43 |       mobile = isMobile(userAgent);
 44 |     });
 45 | 
 46 |     test('should not be a Chrome device', () => {
 47 |       expect(mobile.other.chrome).not.toBe(true);
 48 |     });
 49 | 
 50 |     test('should be a BlackBerry device', () => {
 51 |       expect(mobile.other.blackberry).toBe(true);
 52 |     });
 53 | 
 54 |     test('should not be a BlackBerry 10 device', () => {
 55 |       expect(mobile.other.blackberry10).not.toBe(true);
 56 |     });
 57 | 
 58 |     test('should not be an Android device', () => {
 59 |       expect(mobile.android.device).not.toBe(true);
 60 |     });
 61 | 
 62 |     test('should not be an Apple device', () => {
 63 |       expect(mobile.apple.device).not.toBe(true);
 64 |     });
 65 | 
 66 |     test('should be a mobile device', () => {
 67 |       expect(mobile.any).toBe(true);
 68 |     });
 69 |   });
 70 | 
 71 |   describe('Opera Mini', () => {
 72 |     beforeEach(() => {
 73 |       userAgent =
 74 |         'Opera/9.80 (J2ME/MIDP; Opera Mini/9.80 (S60; SymbOS; Opera Mobi/23.348; U; en) Presto/2.5.25 Version/10.54';
 75 |       mobile = isMobile(userAgent);
 76 |     });
 77 | 
 78 |     test('should not be a Chrome device', () => {
 79 |       expect(mobile.other.chrome).not.toBe(true);
 80 |     });
 81 | 
 82 |     test('should be an Opera Mini device', () => {
 83 |       expect(mobile.other.opera).toBe(true);
 84 |     });
 85 | 
 86 |     test('should not be an Android device', () => {
 87 |       expect(mobile.android.device).not.toBe(true);
 88 |     });
 89 | 
 90 |     test('should not be an Apple device', () => {
 91 |       expect(mobile.apple.device).not.toBe(true);
 92 |     });
 93 | 
 94 |     test('should be a mobile device', () => {
 95 |       expect(mobile.any).toBe(true);
 96 |     });
 97 |   });
 98 | 
 99 |   describe('Firefox OS', () => {
100 |     beforeEach(() => {
101 |       userAgent = 'Mozilla/5.0 (Mobile; rv:14.0) Gecko/14.0 Firefox/14.0';
102 |       mobile = isMobile(userAgent);
103 |     });
104 | 
105 |     test('should not be a Chrome device', () => {
106 |       expect(mobile.other.chrome).not.toBe(true);
107 |     });
108 | 
109 |     test('should be a Firefox OS device', () => {
110 |       expect(mobile.other.firefox).toBe(true);
111 |     });
112 | 
113 |     test('should not be an Android device', () => {
114 |       expect(mobile.android.device).not.toBe(true);
115 |     });
116 | 
117 |     test('should not be an Apple device', () => {
118 |       expect(mobile.apple.device).not.toBe(true);
119 |     });
120 | 
121 |     test('should be a mobile device', () => {
122 |       expect(mobile.any).toBe(true);
123 |     });
124 |   });
125 | 
126 |   describe('Chrome', () => {
127 |     beforeEach(() => {
128 |       userAgent =
129 |         'Mozilla/5.0 (Linux; Android 4.4.4; en-us; Nexus 4 Build/JOP40D) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2307.2 Mobile Safari/537.36';
130 |       mobile = isMobile(userAgent);
131 |     });
132 | 
133 |     test('should be a Chrome device', () => {
134 |       expect(mobile.other.chrome).toBe(true);
135 |     });
136 | 
137 |     test('should be an Android device', () => {
138 |       expect(mobile.android.device).toBe(true);
139 |     });
140 | 
141 |     test('should not be a Firefox OS device', () => {
142 |       expect(mobile.other.firefox).toBe(false);
143 |     });
144 | 
145 |     test('should not be an Apple device', () => {
146 |       expect(mobile.apple.device).not.toBe(true);
147 |     });
148 | 
149 |     test('should be a mobile device', () => {
150 |       expect(mobile.any).toBe(true);
151 |     });
152 |   });
153 | });
154 | 


--------------------------------------------------------------------------------
/src/__tests__/windows.test.ts:
--------------------------------------------------------------------------------
  1 | import isMobile, { isMobileResult } from '../';
  2 | 
  3 | describe('Windows', () => {
  4 |   let mobile: isMobileResult;
  5 |   let userAgent: string;
  6 | 
  7 |   describe('Windows Phone UserAgent', () => {
  8 |     beforeEach(() => {
  9 |       userAgent =
 10 |         'Mozilla/5.0 (compatible; MSIE 9.0; Windows Phone OS 7.5; Trident/5.0; IEMobile/9.0)';
 11 |       mobile = isMobile(userAgent);
 12 |     });
 13 | 
 14 |     test('should be a Windows Phone device', () => {
 15 |       expect(mobile.windows.phone).toBe(true);
 16 |     });
 17 | 
 18 |     test('should not be an Android device', () => {
 19 |       expect(mobile.android.device).not.toBe(true);
 20 |     });
 21 | 
 22 |     test('should not be an Apple device', () => {
 23 |       expect(mobile.apple.device).not.toBe(true);
 24 |     });
 25 | 
 26 |     test('should be matched as Any Phone', () => {
 27 |       expect(mobile.phone).toBe(true);
 28 |     });
 29 | 
 30 |     test('should be a mobile device', () => {
 31 |       expect(mobile.any).toBe(true);
 32 |     });
 33 |   });
 34 | 
 35 |   describe('Windows 8.1 Phone UserAgent', () => {
 36 |     beforeEach(() => {
 37 |       userAgent =
 38 |         '//Mozilla/5.0 (Mobile; Windows Phone 8.1; Android 4.0; ARM; Trident/7.0; Touch; rv:11.0; IEMobile/11.0; NOKIA; Lumia 930) like iPhone OS 7_0_3 Mac OS X AppleWebKit/537 (KHTML, like Gecko) Mobile Safari/537';
 39 |       mobile = isMobile(userAgent);
 40 |     });
 41 | 
 42 |     test('should be a Windows Phone device', () => {
 43 |       expect(mobile.windows.phone).toBe(true);
 44 |     });
 45 | 
 46 |     test('should not be an Android device', () => {
 47 |       expect(mobile.android.device).not.toBe(true);
 48 |     });
 49 | 
 50 |     test('should not be an Apple device', () => {
 51 |       expect(mobile.apple.device).not.toBe(true);
 52 |     });
 53 | 
 54 |     test('should be matched as Any Phone', () => {
 55 |       expect(mobile.phone).toBe(true);
 56 |     });
 57 | 
 58 |     test('should be a mobile device', () => {
 59 |       expect(mobile.any).toBe(true);
 60 |     });
 61 |   });
 62 | 
 63 |   describe('Windows Edge Phone UserAgent', () => {
 64 |     beforeEach(() => {
 65 |       userAgent =
 66 |         'Mozilla/5.0 (Windows Phone 10.0; Android 4.2.1; <Manufacturer>; <Device>) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.135 Mobile Safari/537.36 Edge/12.10166';
 67 |       mobile = isMobile(userAgent);
 68 |     });
 69 | 
 70 |     test('should be a Windows Phone device', () => {
 71 |       expect(mobile.windows.phone).toBe(true);
 72 |     });
 73 | 
 74 |     test('should not be an Android device', () => {
 75 |       expect(mobile.android.device).not.toBe(true);
 76 |     });
 77 | 
 78 |     test('should not be an Apple device', () => {
 79 |       expect(mobile.apple.device).not.toBe(true);
 80 |     });
 81 | 
 82 |     test('should be matched as Any Phone', () => {
 83 |       expect(mobile.phone).toBe(true);
 84 |     });
 85 | 
 86 |     test('should be a mobile device', () => {
 87 |       expect(mobile.any).toBe(true);
 88 |     });
 89 |   });
 90 | 
 91 |   describe('Windows Tablet UserAgent', () => {
 92 |     beforeEach(() => {
 93 |       userAgent =
 94 |         'Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; ARM; Trident/6.0; Touch)';
 95 |       mobile = isMobile(userAgent);
 96 |     });
 97 | 
 98 |     test('should be a Windows Tablet device', () => {
 99 |       expect(mobile.windows.tablet).toBe(true);
100 |     });
101 | 
102 |     test('should not be a Windows Phone device', () => {
103 |       expect(mobile.windows.phone).not.toBe(true);
104 |     });
105 | 
106 |     test('should not be an Android device', () => {
107 |       expect(mobile.android.device).not.toBe(true);
108 |     });
109 | 
110 |     test('should not be an Apple device', () => {
111 |       expect(mobile.apple.device).not.toBe(true);
112 |     });
113 | 
114 |     test('should be matched as Any Tablet', () => {
115 |       expect(mobile.tablet).toBe(true);
116 |     });
117 | 
118 |     test('should be a mobile device', () => {
119 |       expect(mobile.any).toBe(true);
120 |     });
121 |   });
122 | 
123 |   describe('Windows Touch Laptop UserAgent', () => {
124 |     beforeEach(() => {
125 |       userAgent =
126 |         'Mozilla/5.0 (Windows NT 6.3; WOW64; Trident/7.0; Touch; MAGWJS; rv:11.0) like Gecko';
127 |       mobile = isMobile(userAgent);
128 |     });
129 | 
130 |     test('should not be a Windows Tablet device', () => {
131 |       expect(mobile.windows.tablet).not.toBe(true);
132 |     });
133 | 
134 |     test('should not be a Windows Phone device', () => {
135 |       expect(mobile.windows.phone).not.toBe(true);
136 |     });
137 | 
138 |     test('should not be an Android device', () => {
139 |       expect(mobile.android.device).not.toBe(true);
140 |     });
141 | 
142 |     test('should not be an Apple device', () => {
143 |       expect(mobile.apple.device).not.toBe(true);
144 |     });
145 | 
146 |     test('should not be matched as Any Tablet', () => {
147 |       expect(mobile.tablet).not.toBe(true);
148 |     });
149 | 
150 |     test('should not be a mobile device', () => {
151 |       expect(mobile.any).not.toBe(true);
152 |     });
153 |   });
154 | });
155 | 


--------------------------------------------------------------------------------
/src/__tests__/browser.e2e.test.ts:
--------------------------------------------------------------------------------
  1 | import puppeteer from 'puppeteer';
  2 | import { isMobileResult } from '..';
  3 | 
  4 | describe('E2E Tests', () => {
  5 |   test('isMobile global variable is present', async () => {
  6 |     const browser = await puppeteer.launch();
  7 |     const page = await browser.newPage();
  8 |     await page.setUserAgent('okhttp/3.0.0');
  9 |     await page.addScriptTag({ path: './dist/isMobile.min.js' });
 10 | 
 11 |     const isMobile: isMobileResult = await page.evaluate(() => isMobile);
 12 | 
 13 |     expect(isMobile).toMatchInlineSnapshot(`
 14 |       Object {
 15 |         "amazon": Object {
 16 |           "device": false,
 17 |           "phone": false,
 18 |           "tablet": false,
 19 |         },
 20 |         "android": Object {
 21 |           "device": true,
 22 |           "phone": false,
 23 |           "tablet": false,
 24 |         },
 25 |         "any": true,
 26 |         "apple": Object {
 27 |           "device": false,
 28 |           "ipod": false,
 29 |           "phone": false,
 30 |           "tablet": false,
 31 |           "universal": false,
 32 |         },
 33 |         "other": Object {
 34 |           "blackberry": false,
 35 |           "blackberry10": false,
 36 |           "chrome": false,
 37 |           "device": false,
 38 |           "firefox": false,
 39 |           "opera": false,
 40 |         },
 41 |         "phone": false,
 42 |         "tablet": false,
 43 |         "windows": Object {
 44 |           "device": false,
 45 |           "phone": false,
 46 |           "tablet": false,
 47 |         },
 48 |       }
 49 |     `);
 50 | 
 51 |     await browser.close();
 52 |   });
 53 | 
 54 |   (process.env.GITHUB_ACTIONS ? test.skip : test)(
 55 |     'isMobile correctly checks iOS 13',
 56 |     async () => {
 57 |       const iPadIos13 = {
 58 |         ...puppeteer.devices['iPad Pro'],
 59 |         userAgent:
 60 |           'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15) AppleWebKit/605.1.15 (KHTML, like Gecko)',
 61 |       };
 62 |       const browser = await puppeteer.launch();
 63 |       const page = await browser.newPage();
 64 |       await page.evaluateOnNewDocument(() => {
 65 |         Object.defineProperty(navigator, 'maxTouchPoints', {
 66 |           get: () => 4,
 67 |         });
 68 |       });
 69 |       await page.emulate(iPadIos13);
 70 |       await page.addScriptTag({ path: './dist/isMobile.min.js' });
 71 | 
 72 |       const isMobile: isMobileResult = await page.evaluate(() => isMobile);
 73 | 
 74 |       // eslint-disable-next-line jest/no-standalone-expect
 75 |       expect(isMobile).toMatchInlineSnapshot(`
 76 |       Object {
 77 |         "amazon": Object {
 78 |           "device": false,
 79 |           "phone": false,
 80 |           "tablet": false,
 81 |         },
 82 |         "android": Object {
 83 |           "device": false,
 84 |           "phone": false,
 85 |           "tablet": false,
 86 |         },
 87 |         "any": true,
 88 |         "apple": Object {
 89 |           "device": true,
 90 |           "ipod": false,
 91 |           "phone": false,
 92 |           "tablet": true,
 93 |           "universal": false,
 94 |         },
 95 |         "other": Object {
 96 |           "blackberry": false,
 97 |           "blackberry10": false,
 98 |           "chrome": false,
 99 |           "device": false,
100 |           "firefox": false,
101 |           "opera": false,
102 |         },
103 |         "phone": false,
104 |         "tablet": true,
105 |         "windows": Object {
106 |           "device": false,
107 |           "phone": false,
108 |           "tablet": false,
109 |         },
110 |       }
111 |     `);
112 | 
113 |       await browser.close();
114 |     },
115 |   );
116 | 
117 |   test('isMobile correctly fails iOS 13 check when MSStream is present', async () => {
118 |     const iPadIos13 = {
119 |       ...puppeteer.devices['iPad Pro'],
120 |       userAgent:
121 |         'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15) AppleWebKit/605.1.15 (KHTML, like Gecko)',
122 |     };
123 |     const browser = await puppeteer.launch();
124 |     const page = await browser.newPage();
125 |     await page.evaluateOnNewDocument(() => {
126 |       Object.defineProperty(navigator, 'maxTouchPoints', {
127 |         get: () => 4,
128 |       });
129 | 
130 |       Object.defineProperty(window, 'MSStream', {
131 |         get: () => (fn: Function) => fn(),
132 |       });
133 |     });
134 |     await page.emulate(iPadIos13);
135 |     await page.addScriptTag({ path: './dist/isMobile.min.js' });
136 | 
137 |     const isMobile: isMobileResult = await page.evaluate(() => isMobile);
138 | 
139 |     expect(isMobile).toMatchInlineSnapshot(`
140 |       Object {
141 |         "amazon": Object {
142 |           "device": false,
143 |           "phone": false,
144 |           "tablet": false,
145 |         },
146 |         "android": Object {
147 |           "device": false,
148 |           "phone": false,
149 |           "tablet": false,
150 |         },
151 |         "any": false,
152 |         "apple": Object {
153 |           "device": false,
154 |           "ipod": false,
155 |           "phone": false,
156 |           "tablet": false,
157 |           "universal": false,
158 |         },
159 |         "other": Object {
160 |           "blackberry": false,
161 |           "blackberry10": false,
162 |           "chrome": false,
163 |           "device": false,
164 |           "firefox": false,
165 |           "opera": false,
166 |         },
167 |         "phone": false,
168 |         "tablet": false,
169 |         "windows": Object {
170 |           "device": false,
171 |           "phone": false,
172 |           "tablet": false,
173 |         },
174 |       }
175 |     `);
176 | 
177 |     await browser.close();
178 |   });
179 | });
180 | 


--------------------------------------------------------------------------------
/src/isMobile.ts:
--------------------------------------------------------------------------------
  1 | const appleIphone = /iPhone/i;
  2 | const appleIpod = /iPod/i;
  3 | const appleTablet = /iPad/i;
  4 | const appleUniversal = /\biOS-universal(?:.+)Mac\b/i;
  5 | const androidPhone = /\bAndroid(?:.+)Mobile\b/i; // Match 'Android' AND 'Mobile'
  6 | const androidTablet = /Android/i;
  7 | const amazonPhone = /(?:SD4930UR|\bSilk(?:.+)Mobile\b)/i; // Match 'Silk' AND 'Mobile'
  8 | const amazonTablet = /Silk/i;
  9 | const windowsPhone = /Windows Phone/i;
 10 | const windowsTablet = /\bWindows(?:.+)ARM\b/i; // Match 'Windows' AND 'ARM'
 11 | const otherBlackBerry = /BlackBerry/i;
 12 | const otherBlackBerry10 = /BB10/i;
 13 | const otherOpera = /Opera Mini/i;
 14 | const otherChrome = /\b(CriOS|Chrome)(?:.+)Mobile/i;
 15 | const otherFirefox = /Mobile(?:.+)Firefox\b/i; // Match 'Mobile' AND 'Firefox'
 16 | 
 17 | export type UserAgent = string;
 18 | export type Navigator = {
 19 |   userAgent: string;
 20 |   platform: string;
 21 |   maxTouchPoints?: number;
 22 | };
 23 | 
 24 | const isAppleTabletOnIos13 = (navigator?: Navigator): boolean => {
 25 |   return (
 26 |     typeof navigator !== 'undefined' &&
 27 |     navigator.platform === 'MacIntel' &&
 28 |     typeof navigator.maxTouchPoints === 'number' &&
 29 |     navigator.maxTouchPoints > 1 &&
 30 |     typeof MSStream === 'undefined'
 31 |   );
 32 | };
 33 | 
 34 | function createMatch(userAgent: UserAgent): (regex: RegExp) => boolean {
 35 |   return (regex: RegExp): boolean => regex.test(userAgent);
 36 | }
 37 | 
 38 | export type isMobileResult = {
 39 |   apple: {
 40 |     phone: boolean;
 41 |     ipod: boolean;
 42 |     tablet: boolean;
 43 |     universal: boolean;
 44 |     device: boolean;
 45 |   };
 46 |   amazon: {
 47 |     phone: boolean;
 48 |     tablet: boolean;
 49 |     device: boolean;
 50 |   };
 51 |   android: {
 52 |     phone: boolean;
 53 |     tablet: boolean;
 54 |     device: boolean;
 55 |   };
 56 |   windows: {
 57 |     phone: boolean;
 58 |     tablet: boolean;
 59 |     device: boolean;
 60 |   };
 61 |   other: {
 62 |     blackberry: boolean;
 63 |     blackberry10: boolean;
 64 |     opera: boolean;
 65 |     firefox: boolean;
 66 |     chrome: boolean;
 67 |     device: boolean;
 68 |   };
 69 |   phone: boolean;
 70 |   tablet: boolean;
 71 |   any: boolean;
 72 | };
 73 | 
 74 | export type IsMobileParameter = UserAgent | Navigator;
 75 | 
 76 | export default function isMobile(param?: IsMobileParameter): isMobileResult {
 77 |   let nav: Navigator = {
 78 |     userAgent: '',
 79 |     platform: '',
 80 |     maxTouchPoints: 0,
 81 |   };
 82 | 
 83 |   if (!param && typeof navigator !== 'undefined') {
 84 |     nav = {
 85 |       userAgent: navigator.userAgent,
 86 |       platform: navigator.platform,
 87 |       maxTouchPoints: navigator.maxTouchPoints || 0,
 88 |     };
 89 |   } else if (typeof param === 'string') {
 90 |     nav.userAgent = param;
 91 |   } else if (param && param.userAgent) {
 92 |     nav = {
 93 |       userAgent: param.userAgent,
 94 |       platform: param.platform,
 95 |       maxTouchPoints: param.maxTouchPoints || 0,
 96 |     };
 97 |   }
 98 | 
 99 |   let userAgent = nav.userAgent;
100 | 
101 |   // Facebook mobile app's integrated browser adds a bunch of strings that
102 |   // match everything. Strip it out if it exists.
103 |   let tmp = userAgent.split('[FBAN');
104 |   if (typeof tmp[1] !== 'undefined') {
105 |     userAgent = tmp[0];
106 |   }
107 | 
108 |   // Twitter mobile app's integrated browser on iPad adds a "Twitter for
109 |   // iPhone" string. Same probably happens on other tablet platforms.
110 |   // This will confuse detection so strip it out if it exists.
111 |   tmp = userAgent.split('Twitter');
112 |   if (typeof tmp[1] !== 'undefined') {
113 |     userAgent = tmp[0];
114 |   }
115 | 
116 |   const match = createMatch(userAgent);
117 | 
118 |   const result: isMobileResult = {
119 |     apple: {
120 |       phone: match(appleIphone) && !match(windowsPhone),
121 |       ipod: match(appleIpod),
122 |       tablet:
123 |         !match(appleIphone) &&
124 |         (match(appleTablet) || isAppleTabletOnIos13(nav)) &&
125 |         !match(windowsPhone),
126 |       universal: match(appleUniversal),
127 |       device:
128 |         (match(appleIphone) ||
129 |           match(appleIpod) ||
130 |           match(appleTablet) ||
131 |           match(appleUniversal) ||
132 |           isAppleTabletOnIos13(nav)) &&
133 |         !match(windowsPhone),
134 |     },
135 |     amazon: {
136 |       phone: match(amazonPhone),
137 |       tablet: !match(amazonPhone) && match(amazonTablet),
138 |       device: match(amazonPhone) || match(amazonTablet),
139 |     },
140 |     android: {
141 |       phone:
142 |         (!match(windowsPhone) && match(amazonPhone)) ||
143 |         (!match(windowsPhone) && match(androidPhone)),
144 |       tablet:
145 |         !match(windowsPhone) &&
146 |         !match(amazonPhone) &&
147 |         !match(androidPhone) &&
148 |         (match(amazonTablet) || match(androidTablet)),
149 |       device:
150 |         (!match(windowsPhone) &&
151 |           (match(amazonPhone) ||
152 |             match(amazonTablet) ||
153 |             match(androidPhone) ||
154 |             match(androidTablet))) ||
155 |         match(/\bokhttp\b/i),
156 |     },
157 |     windows: {
158 |       phone: match(windowsPhone),
159 |       tablet: match(windowsTablet),
160 |       device: match(windowsPhone) || match(windowsTablet),
161 |     },
162 |     other: {
163 |       blackberry: match(otherBlackBerry),
164 |       blackberry10: match(otherBlackBerry10),
165 |       opera: match(otherOpera),
166 |       firefox: match(otherFirefox),
167 |       chrome: match(otherChrome),
168 |       device:
169 |         match(otherBlackBerry) ||
170 |         match(otherBlackBerry10) ||
171 |         match(otherOpera) ||
172 |         match(otherFirefox) ||
173 |         match(otherChrome),
174 |     },
175 |     any: false,
176 |     phone: false,
177 |     tablet: false,
178 |   };
179 | 
180 |   result.any =
181 |     result.apple.device ||
182 |     result.android.device ||
183 |     result.windows.device ||
184 |     result.other.device;
185 |   // excludes 'other' devices and ipods, targeting touchscreen phones
186 |   result.phone =
187 |     result.apple.phone || result.android.phone || result.windows.phone;
188 |   result.tablet =
189 |     result.apple.tablet || result.android.tablet || result.windows.tablet;
190 | 
191 |   return result;
192 | }
193 | 


--------------------------------------------------------------------------------
/src/__tests__/apple.test.ts:
--------------------------------------------------------------------------------
  1 | import isMobile, { isMobileResult } from '../';
  2 | 
  3 | describe('Apple', () => {
  4 |   let mobile: isMobileResult;
  5 |   let userAgent: string;
  6 | 
  7 |   describe('iPhone UserAgent', () => {
  8 |     beforeEach(() => {
  9 |       userAgent =
 10 |         'Mozilla/5.0 (iPhone; U; CPU like Mac OS X; en) AppleWebKit/420+ (KHTML, like Gecko) Version/3.0 Mobile/1A543 Safari/419.3';
 11 |       mobile = isMobile(userAgent);
 12 |     });
 13 | 
 14 |     test('should be an iPhone', () => {
 15 |       expect(mobile.apple.phone).toBe(true);
 16 |     });
 17 | 
 18 |     test('should not be an iPad', () => {
 19 |       expect(mobile.apple.tablet).not.toBe(true);
 20 |     });
 21 | 
 22 |     test('should not be an iPod', () => {
 23 |       expect(mobile.apple.ipod).not.toBe(true);
 24 |     });
 25 | 
 26 |     test('should be matched as Any Phone', () => {
 27 |       expect(mobile.phone).toBe(true);
 28 |     });
 29 | 
 30 |     test('should be an Apple device', () => {
 31 |       expect(mobile.apple.device).toBe(true);
 32 |     });
 33 |   });
 34 | 
 35 |   describe('iPad UserAgent', () => {
 36 |     beforeEach(() => {
 37 |       userAgent =
 38 |         'Mozilla/5.0 (iPad; U; CPU OS 3_2 like Mac OS X; en-us) AppleWebKit/531.21.10 (KHTML, like Gecko) Version/4.0.4 Mobile/7B334b Safari/531.21.10';
 39 |       mobile = isMobile(userAgent);
 40 |     });
 41 | 
 42 |     test('should not be an iPhone', () => {
 43 |       expect(mobile.apple.phone).not.toBe(true);
 44 |     });
 45 | 
 46 |     test('should be an iPad', () => {
 47 |       expect(mobile.apple.tablet).toBe(true);
 48 |     });
 49 | 
 50 |     test('should not be an iPod', () => {
 51 |       expect(mobile.apple.ipod).not.toBe(true);
 52 |     });
 53 | 
 54 |     test('should be matched as Any Tablet', () => {
 55 |       expect(mobile.tablet).toBe(true);
 56 |     });
 57 | 
 58 |     test('should be an Apple device', () => {
 59 |       expect(mobile.apple.device).toBe(true);
 60 |     });
 61 |   });
 62 | 
 63 |   describe('iPad on iOS 13', () => {
 64 |     beforeEach(() => {
 65 |       const nav = {
 66 |         userAgent:
 67 |           'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15) AppleWebKit/605.1.15 (KHTML, like Gecko)',
 68 |         platform: 'MacIntel',
 69 |         maxTouchPoints: 4,
 70 |       };
 71 |       mobile = isMobile(nav);
 72 |     });
 73 | 
 74 |     test('should not be an iPhone', () => {
 75 |       expect(mobile.apple.phone).not.toBe(true);
 76 |     });
 77 | 
 78 |     test('should be an iPad', () => {
 79 |       expect(mobile.apple.tablet).toBe(true);
 80 |     });
 81 | 
 82 |     test('should not be an iPod', () => {
 83 |       expect(mobile.apple.ipod).not.toBe(true);
 84 |     });
 85 | 
 86 |     test('should be matched as Any Tablet', () => {
 87 |       expect(mobile.tablet).toBe(true);
 88 |     });
 89 | 
 90 |     test('should be an Apple device', () => {
 91 |       expect(mobile.apple.device).toBe(true);
 92 |     });
 93 |   });
 94 | 
 95 |   describe('iPod UserAgent', () => {
 96 |     beforeEach(() => {
 97 |       userAgent =
 98 |         'Mozilla/5.0 (iPod; U; CPU like Mac OS X; en) AppleWebKit/420.1 (KHTML, like Gecko) Version/3.0 Mobile/3A101a Safari/419.3';
 99 |       mobile = isMobile(userAgent);
100 |     });
101 | 
102 |     test('should not be an iPhone', () => {
103 |       expect(mobile.apple.phone).not.toBe(true);
104 |     });
105 | 
106 |     test('should not be an iPad', () => {
107 |       expect(mobile.apple.tablet).not.toBe(true);
108 |     });
109 | 
110 |     test('should be an iPod', () => {
111 |       expect(mobile.apple.ipod).toBe(true);
112 |     });
113 | 
114 |     test('should be an Apple device', () => {
115 |       expect(mobile.apple.device).toBe(true);
116 |     });
117 |   });
118 | 
119 |   describe('Facebook iPhone App UserAgent', () => {
120 |     beforeEach(() => {
121 |       userAgent =
122 |         'Mozilla/5.0 (iPhone; CPU OS 8_1 like Mac OS X) AppleWebKit/600.1.4 (KHTML, like Gecko) Mobile/12B410 [FBAN/FBIOS;FBAV/20.1.0.15.10;FBBV/5758778;FBDV/iPad5,4;FBMD/iPad;FBSN/iPhone OS;FBSV/8.1;FBSS/2; FBCR/;FBID/tablet;FBLC/fi_FI;FBOP/1]';
123 |       mobile = isMobile(userAgent);
124 |     });
125 | 
126 |     test('should be an iPhone', () => {
127 |       expect(mobile.apple.phone).toBe(true);
128 |     });
129 | 
130 |     test('should not be an iPad', () => {
131 |       expect(mobile.apple.tablet).not.toBe(true);
132 |     });
133 | 
134 |     test('should not be an iPod', () => {
135 |       expect(mobile.apple.ipod).not.toBe(true);
136 |     });
137 | 
138 |     test('should be an Apple device', () => {
139 |       expect(mobile.apple.device).toBe(true);
140 |     });
141 |   });
142 | 
143 |   describe('Facebook iPad App UserAgent', () => {
144 |     beforeEach(() => {
145 |       userAgent =
146 |         'Mozilla/5.0 (iPad; CPU OS 8_1 like Mac OS X) AppleWebKit/600.1.4 (KHTML, like Gecko) Mobile/12B410 [FBAN/FBIOS;FBAV/20.1.0.15.10;FBBV/5758778;FBDV/iPad5,4;FBMD/iPad;FBSN/iPhone OS;FBSV/8.1;FBSS/2; FBCR/;FBID/tablet;FBLC/fi_FI;FBOP/1]';
147 |       mobile = isMobile(userAgent);
148 |     });
149 | 
150 |     test('should not be an iPhone', () => {
151 |       expect(mobile.apple.phone).not.toBe(true);
152 |     });
153 | 
154 |     test('should be an iPad', () => {
155 |       expect(mobile.apple.tablet).toBe(true);
156 |     });
157 | 
158 |     test('should not be an iPod', () => {
159 |       expect(mobile.apple.ipod).not.toBe(true);
160 |     });
161 | 
162 |     test('should be an Apple device', () => {
163 |       expect(mobile.apple.device).toBe(true);
164 |     });
165 |   });
166 | 
167 |   describe('Twitter iPhone App UserAgent', () => {
168 |     beforeEach(() => {
169 |       userAgent =
170 |         'Mozilla/5.0 (iPhone; CPU iPhone OS 9_2_1 like Mac OS X) AppleWebKit/601.1.46 (KHTML, like Gecko) Mobile/13D15 Twitter for iPhone';
171 |       mobile = isMobile(userAgent);
172 |     });
173 | 
174 |     test('should be an iPhone', () => {
175 |       expect(mobile.apple.phone).toBe(true);
176 |     });
177 | 
178 |     test('should not be an iPad', () => {
179 |       expect(mobile.apple.tablet).not.toBe(true);
180 |     });
181 | 
182 |     test('should not be an iPod', () => {
183 |       expect(mobile.apple.ipod).not.toBe(true);
184 |     });
185 | 
186 |     test('should be an Apple device', () => {
187 |       expect(mobile.apple.device).toBe(true);
188 |     });
189 |   });
190 | 
191 |   describe('Twitter iPad App UserAgent', () => {
192 |     beforeEach(() => {
193 |       userAgent =
194 |         'Mozilla/5.0 (iPad; CPU OS 9_2_1 like Mac OS X) AppleWebKit/601.1.46 (KHTML, like Gecko) Mobile/13D15 Twitter for iPhone';
195 |       mobile = isMobile(userAgent);
196 |     });
197 | 
198 |     test('should not be an iPhone', () => {
199 |       expect(mobile.apple.phone).not.toBe(true);
200 |     });
201 | 
202 |     test('should be an iPad', () => {
203 |       expect(mobile.apple.tablet).toBe(true);
204 |     });
205 | 
206 |     test('should not be an iPod', () => {
207 |       expect(mobile.apple.ipod).not.toBe(true);
208 |     });
209 | 
210 |     test('should be an Apple device', () => {
211 |       expect(mobile.apple.device).toBe(true);
212 |     });
213 |   });
214 | });
215 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | [![Build Status](https://travis-ci.org/kaimallea/isMobile.png)](https://travis-ci.org/kaimallea/isMobile)
  2 | [![Node dependencies status](https://david-dm.org/kaimallea/isMobile.png)](https://david-dm.org/kaimallea/isMobile)
  3 | [![](https://data.jsdelivr.com/v1/package/npm/ismobilejs/badge)](https://www.jsdelivr.com/package/npm/ismobilejs)
  4 | 
  5 | # isMobile
  6 | 
  7 | A simple JS library that detects mobile devices in both the browser and NodeJS.
  8 | 
  9 | ## Why use isMobile?
 10 | 
 11 | ### In the Browser
 12 | 
 13 | You might not need this library. In most cases, [responsive design](https://en.wikipedia.org/wiki/Responsive_web_design) solves the problem of controlling how to render things across different screen sizes. I recommend a [mobile first](https://medium.com/@Vincentxia77/what-is-mobile-first-design-why-its-important-how-to-make-it-7d3cf2e29d00) approach. But there are always edge cases. If you have an edge case, then this library might be for you.
 14 | 
 15 | My edge case at the time was redirecting users to a completely separate mobile site. I tried to keep this script small (**currently ~1.3k bytes, minified**) and simple, because it would need to execute in the `<head>`, which is generally a bad idea, since JS blocks the downloading and rendering of all assets while it parses and executes. In the case of mobile redirection, I don't mind so much, because I want to start the redirect as soon as possible, before the device has a chance to start downloading and rendering other stuff. For non-mobile platforms, the script should execute fast, so the browser can quickly get back to downloading and rendering.
 16 | 
 17 | #### How it works in the browser
 18 | 
 19 | isMobile runs quickly during initial page load to detect mobile devices; it then creates a JavaScript object with the results.
 20 | 
 21 | ### In NodeJS
 22 | 
 23 | You might want to use this library to do server-side device detection to minimize the amount of bytes you send back to visitors. Or you have your own arbitrary use case.
 24 | 
 25 | #### How is works in NodeJS
 26 | 
 27 | You import and call the `isMobile` function, passing it a user agent string; it then returns a JavaScript object with the results.
 28 | 
 29 | ## Devices detected by isMobile
 30 | 
 31 | In a browser, the following properties of the global `isMobile` object will either be `true` or `false`. In Node, `isMobile` will be whatever you named the variable.
 32 | 
 33 | ### Apple devices
 34 | 
 35 | - `isMobile.apple.phone`
 36 | - `isMobile.apple.ipod`
 37 | - `isMobile.apple.tablet`
 38 | - `isMobile.apple.universal`
 39 | - `isMobile.apple.device` (any mobile Apple device)
 40 | 
 41 | ### Android devices
 42 | 
 43 | - `isMobile.android.phone`
 44 | - `isMobile.android.tablet`
 45 | - `isMobile.android.device` (any mobile Android device; OkHttp user agents will match this)
 46 | 
 47 | ### Amazon Silk devices (also passes Android checks)
 48 | 
 49 | - `isMobile.amazon.phone`
 50 | - `isMobile.amazon.tablet`
 51 | - `isMobile.amazon.device` (any mobile Amazon Silk device)
 52 | 
 53 | ### Windows devices
 54 | 
 55 | - `isMobile.windows.phone`
 56 | - `isMobile.windows.tablet`
 57 | - `isMobile.windows.device` (any mobile Windows device)
 58 | 
 59 | ### "Other" devices
 60 | 
 61 | - `isMobile.other.blackberry_10`
 62 | - `isMobile.other.blackberry`
 63 | - `isMobile.other.opera` (Opera Mini)
 64 | - `isMobile.other.firefox`
 65 | - `isMobile.other.chrome`
 66 | - `isMobile.other.device` (any "Other" device)
 67 | 
 68 | ### Aggregate Groupings
 69 | 
 70 | - `isMobile.any` - any device matched
 71 | - `isMobile.phone` - any device in the 'phone' groups above
 72 | - `isMobile.tablet` - any device in the 'tablet' groups above
 73 | 
 74 | ## Usage
 75 | 
 76 | ### Node.js
 77 | 
 78 | #### Install
 79 | 
 80 | ```bash
 81 | yarn add ismobilejs
 82 | ```
 83 | 
 84 | or
 85 | 
 86 | ```bash
 87 | npm install ismobilejs
 88 | ```
 89 | 
 90 | #### Use
 91 | 
 92 | ```ts
 93 | import isMobile from 'ismobilejs';
 94 | const userAgent = req.headers['user-agent'];
 95 | console.log(isMobile(userAgent).any);
 96 | ```
 97 | 
 98 | Or pass in a `window.navigator`-shaped object that includes at least a `userAgent` property. To properly detect iPad on iOS 13, the object should also include the `platform` and `maxTouchPoints` properties.
 99 | 
100 | ```js
101 | // this is just an example. window.navigator is readonly in the browser
102 | window.navigator = {
103 |   ...
104 |   userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15) AppleWebKit/605.1.15 (KHTML, like Gecko)',
105 |   platform: 'MacIntel',
106 |   maxTouchPoints: 2,
107 |   ..
108 | }
109 | ```
110 | 
111 | ```ts
112 | import isMobile from 'ismobilejs';
113 | console.log(isMobile(window.navigator).apple.tablet);
114 | ```
115 | 
116 | ### Browser
117 | 
118 | A real-word example: I include the minified version of the script, inline, and at the top of the `<head>`. Cellular connections tend to suck, so it would be wasteful overhead to open another connection, just to download ~1.3kb of JS:
119 | 
120 | <!-- prettier-ignore -->
121 | ```html
122 | <!DOCTYPE html>
123 | <html lang="en">
124 |   <head>
125 |     <meta charset="utf-8" />
126 |     <script>
127 |       // Minified version of isMobile included in the HTML since it's small
128 |       (function () {var a={};var f=/iPhone/i,h=/iPod/i,i=/iPad/i,r=/\biOS-universal(?:.+)Mac\b/i,g=/\bAndroid(?:.+)Mobile\b/i,j=/Android/i,c=/(?:SD4930UR|\bSilk(?:.+)Mobile\b)/i,d=/Silk/i,b=/Windows Phone/i,k=/\bWindows(?:.+)ARM\b/i,m=/BlackBerry/i,n=/BB10/i,o=/Opera Mini/i,p=/\b(CriOS|Chrome)(?:.+)Mobile/i,q=/Mobile(?:.+)Firefox\b/i;function s(l){return function($){return $.test(l)}}function e(l){var $=(l=l||("undefined"!=typeof navigator?navigator.userAgent:"")).split("[FBAN");void 0!==$[1]&&(l=$[0]),void 0!==($=l.split("Twitter"))[1]&&(l=$[0]);var a=s(l),e={apple:{phone:a(f)&&!a(b),ipod:a(h),tablet:!a(f)&&a(i)&&!a(b),universal:a(r),device:(a(f)||a(h)||a(i))&&!a(b)},amazon:{phone:a(c),tablet:!a(c)&&a(d),device:a(c)||a(d)},android:{phone:!a(b)&&a(c)||!a(b)&&a(g),tablet:!a(b)&&!a(c)&&!a(g)&&(a(d)||a(j)),device:!a(b)&&(a(c)||a(d)||a(g)||a(j))||a(/\bokhttp\b/i)},windows:{phone:a(b),tablet:a(k),device:a(b)||a(k)},other:{blackberry:a(m),blackberry10:a(n),opera:a(o),firefox:a(q),chrome:a(p),device:a(m)||a(n)||a(o)||a(q)||a(p)},any:!1,phone:!1,tablet:!1};return e.any=e.apple.universal||e.apple.device||e.android.device||e.windows.device||e.other.device,e.phone=e.apple.phone||e.android.phone||e.windows.phone,e.tablet=e.apple.tablet||e.android.tablet||e.windows.tablet,e}a=e();if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=a}else if(typeof define==="function"&&define.amd){define(function(){return a})}else{this["isMobile"]=a}})();
129 | 
130 |       // My own arbitrary use of isMobile, as an example
131 |       (function() {
132 |         var MOBILE_SITE = '/mobile/index.html', // site to redirect to
133 |           NO_REDIRECT = 'noredirect'; // cookie to prevent redirect
134 | 
135 |         // I only want to redirect iPhones, Android phones
136 |         if (isMobile.apple.phone || isMobile.android.phone) {
137 |           // Only redirect if the user didn't previously choose
138 |           // to explicitly view the full site. This is validated
139 |           // by checking if a "noredirect" cookie exists
140 |           if (document.cookie.indexOf(NO_REDIRECT) === -1) {
141 |             document.location = MOBILE_SITE;
142 |           }
143 |         }
144 |       })();
145 |     </script>
146 |   </head>
147 |   <body>
148 |     <!-- imagine lots of html and content -->
149 |   </body>
150 | </html>
151 | ```
152 | 
153 | ### jsDelivr CDN [![](https://data.jsdelivr.com/v1/package/npm/ismobilejs/badge)](https://www.jsdelivr.com/package/npm/ismobilejs)
154 | 
155 | Alternatively, you can include this library via [jsDelivr CDN](https://www.jsdelivr.com/package/npm/ismobilejs) in a `script` tag:
156 | 
157 | `<script src="https://cdn.jsdelivr.net/npm/ismobilejs@1/dist/isMobile.min.js"></script>`
158 | 
159 | **Visit the isMobile [jsDelivr page](https://www.jsdelivr.com/package/npm/ismobilejs) to get the most up-to-date URL pointing to the lastest version.**
160 | 
161 | ## Building manually
162 | 
163 | After checking out the repo, install dependencies:
164 | 
165 | ```bash
166 | yarn install
167 | ```
168 | 
169 | Then build the library:
170 | 
171 | ```bash
172 | yarn build
173 | ```
174 | 
175 | Three versions of the library will be generated:
176 | 
177 | 1. `./cjs/index.js` - the CommonJS version of the library
178 | 2. `./esm/index.js` - the ESModule version of the library
179 | 3. `./dist/isMobile.min.js` - the browser version of the library
180 | 
181 | Additionally, types will be output to `types`.
182 | 
183 | ## Contributing
184 | 
185 | This library uses Spotify's [web-scripts](https://github.com/spotify/web-scripts) project to build, lint, test, format and release the this library.
186 | 
187 | You must use `yarn commit` rather than `git commit` to commit files. This enforced commit messages to following a specific format and enables automation of release notes and version bump.
188 | 


--------------------------------------------------------------------------------
/src/__tests__/amazon.test.ts:
--------------------------------------------------------------------------------
  1 | import isMobile, { isMobileResult } from '../';
  2 | 
  3 | describe('Amazon', () => {
  4 |   let mobile: isMobileResult;
  5 |   let userAgent: string;
  6 | 
  7 |   describe('Amazon Kindle Fire User Agent', () => {
  8 |     beforeEach(() => {
  9 |       userAgent =
 10 |         'Mozilla/5.0 (Linux; U; Android android-version; locale; KFOT Build/product-build) AppleWebKit/webkit-version (KHTML, like Gecko) Silk/browser-version like Chrome/chrome-version Safari/webkit-version';
 11 |       mobile = isMobile(userAgent);
 12 |     });
 13 | 
 14 |     test('should not be an Amazon Phone', () => {
 15 |       expect(mobile.amazon.phone).not.toBe(true);
 16 |     });
 17 | 
 18 |     test('should be an Amazon Tablet', () => {
 19 |       expect(mobile.amazon.tablet).toBe(true);
 20 |     });
 21 | 
 22 |     test('should be an Amazon device', () => {
 23 |       expect(mobile.amazon.device).toBe(true);
 24 |     });
 25 | 
 26 |     test('should not be an Android Phone', () => {
 27 |       expect(mobile.android.phone).not.toBe(true);
 28 |     });
 29 | 
 30 |     test('should be an Android Tablet', () => {
 31 |       expect(mobile.android.tablet).toBe(true);
 32 |     });
 33 | 
 34 |     test('should be matched as Any Tablet', () => {
 35 |       expect(mobile.tablet).toBe(true);
 36 |     });
 37 | 
 38 |     test('should be an Android device', () => {
 39 |       expect(mobile.android.device).toBe(true);
 40 |     });
 41 |   });
 42 | 
 43 |   describe('Amazon Kindle Fire HD User Agent', () => {
 44 |     beforeEach(() => {
 45 |       userAgent =
 46 |         'Mozilla/5.0 (Linux; U; Android android-version; locale; KFTT Build/product-build) AppleWebKit/webkit-version (KHTML, like Gecko) Silk/browser-version like Chrome/chrome-version Safari/webkit-version';
 47 |       mobile = isMobile(userAgent);
 48 |     });
 49 | 
 50 |     test('should not be an Amazon Phone', () => {
 51 |       expect(mobile.amazon.phone).not.toBe(true);
 52 |     });
 53 | 
 54 |     test('should be an Amazon Tablet', () => {
 55 |       expect(mobile.amazon.tablet).toBe(true);
 56 |     });
 57 | 
 58 |     test('should be an Amazon device', () => {
 59 |       expect(mobile.amazon.device).toBe(true);
 60 |     });
 61 | 
 62 |     test('should not be an Android Phone', () => {
 63 |       expect(mobile.android.phone).not.toBe(true);
 64 |     });
 65 | 
 66 |     test('should be an Android Tablet', () => {
 67 |       expect(mobile.android.tablet).toBe(true);
 68 |     });
 69 | 
 70 |     test('should be matched as Any Tablet', () => {
 71 |       expect(mobile.tablet).toBe(true);
 72 |     });
 73 | 
 74 |     test('should be an Android device', () => {
 75 |       expect(mobile.android.device).toBe(true);
 76 |     });
 77 |   });
 78 | 
 79 |   describe('Amazon Kindle Fire HD 8.9inch User Agent', () => {
 80 |     beforeEach(() => {
 81 |       userAgent =
 82 |         'Mozilla/5.0 (Linux; U; Android android-version; locale; KFJWI Build/product-build) AppleWebKit/webkit-version (KHTML, like Gecko) Silk/browser-version like Chrome/chrome-version Safari/webkit-version';
 83 |       mobile = isMobile(userAgent);
 84 |     });
 85 | 
 86 |     test('should not be an Amazon Phone', () => {
 87 |       expect(mobile.amazon.phone).not.toBe(true);
 88 |     });
 89 | 
 90 |     test('should be an Amazon Tablet', () => {
 91 |       expect(mobile.amazon.tablet).toBe(true);
 92 |     });
 93 | 
 94 |     test('should be an Amazon device', () => {
 95 |       expect(mobile.amazon.device).toBe(true);
 96 |     });
 97 | 
 98 |     test('should not be an Android Phone', () => {
 99 |       expect(mobile.android.phone).not.toBe(true);
100 |     });
101 | 
102 |     test('should be an Android Tablet', () => {
103 |       expect(mobile.android.tablet).toBe(true);
104 |     });
105 | 
106 |     test('should be matched as Any Tablet', () => {
107 |       expect(mobile.tablet).toBe(true);
108 |     });
109 | 
110 |     test('should be an Android device', () => {
111 |       expect(mobile.android.device).toBe(true);
112 |     });
113 |   });
114 | 
115 |   describe('Amazon Kindle Fire HD 8.9inch 4G User Agent', () => {
116 |     beforeEach(() => {
117 |       userAgent =
118 |         'Mozilla/5.0 (Linux; U; Android android-version; locale; KFJWA Build/product-build) AppleWebKit/webkit-version (KHTML, like Gecko) Silk/browser-version like Chrome/chrome-version Safari/webkit-version';
119 |       mobile = isMobile(userAgent);
120 |     });
121 | 
122 |     test('should not be an Amazon Phone', () => {
123 |       expect(mobile.amazon.phone).not.toBe(true);
124 |     });
125 | 
126 |     test('should be an Amazon Tablet', () => {
127 |       expect(mobile.amazon.tablet).toBe(true);
128 |     });
129 | 
130 |     test('should be an Amazon device', () => {
131 |       expect(mobile.amazon.device).toBe(true);
132 |     });
133 | 
134 |     test('should not be an Android Phone', () => {
135 |       expect(mobile.android.phone).not.toBe(true);
136 |     });
137 | 
138 |     test('should be an Android Tablet', () => {
139 |       expect(mobile.android.tablet).toBe(true);
140 |     });
141 | 
142 |     test('should be matched as Any Tablet', () => {
143 |       expect(mobile.tablet).toBe(true);
144 |     });
145 | 
146 |     test('should be an Android device', () => {
147 |       expect(mobile.android.device).toBe(true);
148 |     });
149 |   });
150 | 
151 |   describe('Amazon Kindle Fire HD 7inch (3rd Generation) User Agent', () => {
152 |     beforeEach(() => {
153 |       userAgent =
154 |         'Mozilla/5.0 (Linux; U; Android android-version; locale; KFSOWI Build/product-build) AppleWebKit/webkit-version (KHTML, like Gecko) Silk/browser-version like Chrome/chrome-version Safari/webkit-version';
155 |       mobile = isMobile(userAgent);
156 |     });
157 | 
158 |     test('should not be an Amazon Phone', () => {
159 |       expect(mobile.amazon.phone).not.toBe(true);
160 |     });
161 | 
162 |     test('should be an Amazon Tablet', () => {
163 |       expect(mobile.amazon.tablet).toBe(true);
164 |     });
165 | 
166 |     test('should be an Amazon device', () => {
167 |       expect(mobile.amazon.device).toBe(true);
168 |     });
169 | 
170 |     test('should not be an Android Phone', () => {
171 |       expect(mobile.android.phone).not.toBe(true);
172 |     });
173 | 
174 |     test('should be an Android Tablet', () => {
175 |       expect(mobile.android.tablet).toBe(true);
176 |     });
177 | 
178 |     test('should be matched as Any Tablet', () => {
179 |       expect(mobile.tablet).toBe(true);
180 |     });
181 | 
182 |     test('should be an Android device', () => {
183 |       expect(mobile.android.device).toBe(true);
184 |     });
185 |   });
186 | 
187 |   describe('Amazon Kindle Fire HDX 7inch (3rd Generation) User Agent', () => {
188 |     beforeEach(() => {
189 |       userAgent =
190 |         'Mozilla/5.0 (Linux; U; Android android-version; locale; KFTHWI Build/product-build) AppleWebKit/webkit-version (KHTML, like Gecko) Silk/browser-version like Chrome/chrome-version Safari/webkit-version';
191 |       mobile = isMobile(userAgent);
192 |     });
193 | 
194 |     test('should not be an Amazon Phone', () => {
195 |       expect(mobile.amazon.phone).not.toBe(true);
196 |     });
197 | 
198 |     test('should be an Amazon Tablet', () => {
199 |       expect(mobile.amazon.tablet).toBe(true);
200 |     });
201 | 
202 |     test('should be an Amazon device', () => {
203 |       expect(mobile.amazon.device).toBe(true);
204 |     });
205 | 
206 |     test('should not be an Android Phone', () => {
207 |       expect(mobile.android.phone).not.toBe(true);
208 |     });
209 | 
210 |     test('should be an Android Tablet', () => {
211 |       expect(mobile.android.tablet).toBe(true);
212 |     });
213 | 
214 |     test('should be matched as Any Tablet', () => {
215 |       expect(mobile.tablet).toBe(true);
216 |     });
217 | 
218 |     test('should be an Android device', () => {
219 |       expect(mobile.android.device).toBe(true);
220 |     });
221 |   });
222 | 
223 |   describe('Amazon Kindle Fire HDX 7 (3rd Generation) 4G User Agent', () => {
224 |     beforeEach(() => {
225 |       userAgent =
226 |         'Mozilla/5.0 (Linux; U; Android android-version; locale; KFTHWA Build/product-build) AppleWebKit/webkit-version (KHTML, like Gecko) Silk/browser-version like Chrome/chrome-version Safari/webkit-version';
227 |       mobile = isMobile(userAgent);
228 |     });
229 | 
230 |     test('should not be an Amazon Phone', () => {
231 |       expect(mobile.amazon.phone).not.toBe(true);
232 |     });
233 | 
234 |     test('should be an Amazon Tablet', () => {
235 |       expect(mobile.amazon.tablet).toBe(true);
236 |     });
237 | 
238 |     test('should be an Amazon device', () => {
239 |       expect(mobile.amazon.device).toBe(true);
240 |     });
241 | 
242 |     test('should not be an Android Phone', () => {
243 |       expect(mobile.android.phone).not.toBe(true);
244 |     });
245 | 
246 |     test('should be an Android Tablet', () => {
247 |       expect(mobile.android.tablet).toBe(true);
248 |     });
249 | 
250 |     test('should be matched as Any Tablet', () => {
251 |       expect(mobile.tablet).toBe(true);
252 |     });
253 | 
254 |     test('should be an Android device', () => {
255 |       expect(mobile.android.device).toBe(true);
256 |     });
257 |   });
258 | 
259 |   describe('Amazon Kindle Fire HDX 8.9inch (3rd Generation) User Agent', () => {
260 |     beforeEach(() => {
261 |       userAgent =
262 |         'Mozilla/5.0 (Linux; U; Android android-version; locale; KFAPWI Build/product-build) AppleWebKit/webkit-version (KHTML, like Gecko) Silk/browser-version like Chrome/chrome-version Safari/webkit-version';
263 |       mobile = isMobile(userAgent);
264 |     });
265 | 
266 |     test('should not be an Amazon Phone', () => {
267 |       expect(mobile.amazon.phone).not.toBe(true);
268 |     });
269 | 
270 |     test('should be an Amazon Tablet', () => {
271 |       expect(mobile.amazon.tablet).toBe(true);
272 |     });
273 | 
274 |     test('should be an Amazon device', () => {
275 |       expect(mobile.amazon.device).toBe(true);
276 |     });
277 | 
278 |     test('should not be an Android Phone', () => {
279 |       expect(mobile.android.phone).not.toBe(true);
280 |     });
281 | 
282 |     test('should be an Android Tablet', () => {
283 |       expect(mobile.android.tablet).toBe(true);
284 |     });
285 | 
286 |     test('should be matched as Any Tablet', () => {
287 |       expect(mobile.tablet).toBe(true);
288 |     });
289 | 
290 |     test('should be an Android device', () => {
291 |       expect(mobile.android.device).toBe(true);
292 |     });
293 |   });
294 | 
295 |   describe('Amazon Kindle Fire HDX 8.9inch (3rd Generation) 4G User Agent', () => {
296 |     beforeEach(() => {
297 |       userAgent =
298 |         'Mozilla/5.0 (Linux; U; Android android-version; locale; KFAPWA Build/product-build) AppleWebKit/webkit-version (KHTML, like Gecko) Silk/browser-version like Chrome/chrome-version Safari/webkit-version';
299 |       mobile = isMobile(userAgent);
300 |     });
301 | 
302 |     test('should not be an Amazon Phone', () => {
303 |       expect(mobile.amazon.phone).not.toBe(true);
304 |     });
305 | 
306 |     test('should be an Amazon Tablet', () => {
307 |       expect(mobile.amazon.tablet).toBe(true);
308 |     });
309 | 
310 |     test('should be an Amazon device', () => {
311 |       expect(mobile.amazon.device).toBe(true);
312 |     });
313 | 
314 |     test('should not be an Android Phone', () => {
315 |       expect(mobile.android.phone).not.toBe(true);
316 |     });
317 | 
318 |     test('should be an Android Tablet', () => {
319 |       expect(mobile.android.tablet).toBe(true);
320 |     });
321 | 
322 |     test('should be matched as Any Tablet', () => {
323 |       expect(mobile.tablet).toBe(true);
324 |     });
325 | 
326 |     test('should be an Android device', () => {
327 |       expect(mobile.android.device).toBe(true);
328 |     });
329 |   });
330 | 
331 |   describe('Amazon Fire HD 6 (4th Generation) User Agent', () => {
332 |     beforeEach(() => {
333 |       userAgent =
334 |         'Mozilla/5.0 (Linux; U; Android android-version; locale; KFARWI Build/product-build) AppleWebKit/webkit-version (KHTML, like Gecko) Silk/browser-version like Chrome/chrome-version Safari/webkit-version';
335 |       mobile = isMobile(userAgent);
336 |     });
337 | 
338 |     test('should not be an Amazon Phone', () => {
339 |       expect(mobile.amazon.phone).not.toBe(true);
340 |     });
341 | 
342 |     test('should be an Amazon Tablet', () => {
343 |       expect(mobile.amazon.tablet).toBe(true);
344 |     });
345 | 
346 |     test('should be an Amazon device', () => {
347 |       expect(mobile.amazon.device).toBe(true);
348 |     });
349 | 
350 |     test('should not be an Android Phone', () => {
351 |       expect(mobile.android.phone).not.toBe(true);
352 |     });
353 | 
354 |     test('should be an Android Tablet', () => {
355 |       expect(mobile.android.tablet).toBe(true);
356 |     });
357 | 
358 |     test('should be matched as Any Tablet', () => {
359 |       expect(mobile.tablet).toBe(true);
360 |     });
361 | 
362 |     test('should be an Android device', () => {
363 |       expect(mobile.android.device).toBe(true);
364 |     });
365 |   });
366 | 
367 |   describe('Amazon Fire HD 7 (4th Generation) User Agent', () => {
368 |     beforeEach(() => {
369 |       userAgent =
370 |         'Mozilla/5.0 (Linux; U; Android android-version; locale; KFASWI Build/product-build) AppleWebKit/webkit-version (KHTML, like Gecko) Silk/browser-version like Chrome/chrome-version Safari/webkit-version';
371 |       mobile = isMobile(userAgent);
372 |     });
373 | 
374 |     test('should not be an Amazon Phone', () => {
375 |       expect(mobile.amazon.phone).not.toBe(true);
376 |     });
377 | 
378 |     test('should be an Amazon Tablet', () => {
379 |       expect(mobile.amazon.tablet).toBe(true);
380 |     });
381 | 
382 |     test('should be an Amazon device', () => {
383 |       expect(mobile.amazon.device).toBe(true);
384 |     });
385 | 
386 |     test('should not be an Android Phone', () => {
387 |       expect(mobile.android.phone).not.toBe(true);
388 |     });
389 | 
390 |     test('should be an Android Tablet', () => {
391 |       expect(mobile.android.tablet).toBe(true);
392 |     });
393 | 
394 |     test('should be matched as Any Tablet', () => {
395 |       expect(mobile.tablet).toBe(true);
396 |     });
397 | 
398 |     test('should be an Android device', () => {
399 |       expect(mobile.android.device).toBe(true);
400 |     });
401 |   });
402 | 
403 |   describe('Amazon Fire HDX 8.9 (4th Generation) User Agent', () => {
404 |     beforeEach(() => {
405 |       userAgent =
406 |         'Mozilla/5.0 (Linux; U; Android android-version; locale; KFSAWI Build/product-build) AppleWebKit/webkit-version (KHTML, like Gecko) Silk/browser-version like Chrome/chrome-version Safari/webkit-version';
407 |       mobile = isMobile(userAgent);
408 |     });
409 | 
410 |     test('should not be an Amazon Phone', () => {
411 |       expect(mobile.amazon.phone).not.toBe(true);
412 |     });
413 | 
414 |     test('should be an Amazon Tablet', () => {
415 |       expect(mobile.amazon.tablet).toBe(true);
416 |     });
417 | 
418 |     test('should be an Amazon device', () => {
419 |       expect(mobile.amazon.device).toBe(true);
420 |     });
421 | 
422 |     test('should not be an Android Phone', () => {
423 |       expect(mobile.android.phone).not.toBe(true);
424 |     });
425 | 
426 |     test('should be an Android Tablet', () => {
427 |       expect(mobile.android.tablet).toBe(true);
428 |     });
429 | 
430 |     test('should be matched as Any Tablet', () => {
431 |       expect(mobile.tablet).toBe(true);
432 |     });
433 | 
434 |     test('should be an Android device', () => {
435 |       expect(mobile.android.device).toBe(true);
436 |     });
437 |   });
438 | 
439 |   describe('Amazon Fire HDX 8.9 (4th Generation) 4G User Agent', () => {
440 |     beforeEach(() => {
441 |       userAgent =
442 |         'Mozilla/5.0 (Linux; U; Android android-version; locale; KFSAWA Build/product-build) AppleWebKit/webkit-version (KHTML, like Gecko) Silk/browser-version like Chrome/chrome-version Safari/webkit-version';
443 |       mobile = isMobile(userAgent);
444 |     });
445 | 
446 |     test('should not be an Amazon Phone', () => {
447 |       expect(mobile.amazon.phone).not.toBe(true);
448 |     });
449 | 
450 |     test('should be an Amazon Tablet', () => {
451 |       expect(mobile.amazon.tablet).toBe(true);
452 |     });
453 | 
454 |     test('should be an Amazon device', () => {
455 |       expect(mobile.amazon.device).toBe(true);
456 |     });
457 | 
458 |     test('should not be an Android Phone', () => {
459 |       expect(mobile.android.phone).not.toBe(true);
460 |     });
461 | 
462 |     test('should be an Android Tablet', () => {
463 |       expect(mobile.android.tablet).toBe(true);
464 |     });
465 | 
466 |     test('should be matched as Any Tablet', () => {
467 |       expect(mobile.tablet).toBe(true);
468 |     });
469 | 
470 |     test('should be an Android device', () => {
471 |       expect(mobile.android.device).toBe(true);
472 |     });
473 |   });
474 | 
475 |   describe('Amazon Fire Phone User Agent', () => {
476 |     beforeEach(() => {
477 |       userAgent =
478 |         'Mozilla/5.0 (Linux; U; Android android-version; locale; SD4930UR Build/product-build) AppleWebKit/webkit-version (KHTML, like Gecko) Silk/browser-version like Chrome/chrome-version Safari/webkit-version';
479 |       mobile = isMobile(userAgent);
480 |     });
481 | 
482 |     test('should be an Amazon Phone', () => {
483 |       expect(mobile.amazon.phone).toBe(true);
484 |     });
485 | 
486 |     test('should not be an Amazon Tablet', () => {
487 |       expect(mobile.amazon.tablet).not.toBe(true);
488 |     });
489 | 
490 |     test('should be an Amazon device', () => {
491 |       expect(mobile.amazon.device).toBe(true);
492 |     });
493 | 
494 |     test('should be an Android Phone', () => {
495 |       expect(mobile.android.phone).toBe(true);
496 |     });
497 | 
498 |     test('should not be an Android Tablet', () => {
499 |       expect(mobile.android.tablet).not.toBe(true);
500 |     });
501 | 
502 |     test('should be matched as Any Phone', () => {
503 |       expect(mobile.phone).toBe(true);
504 |     });
505 | 
506 |     test('should be an Android device', () => {
507 |       expect(mobile.android.device).toBe(true);
508 |     });
509 |   });
510 | 
511 |   describe('Amazon Fire Generic Phone User Agent', () => {
512 |     beforeEach(() => {
513 |       userAgent =
514 |         'Mozilla/5.0 (Linux; Android android-version; product-model Build/product-build) AppleWebKit/webkit-version (KHTML, like Gecko) Silk/browser-version like Chrome/chrome-version Mobile Safari/webkit-version';
515 |       mobile = isMobile(userAgent);
516 |     });
517 | 
518 |     test('should be an Amazon Phone', () => {
519 |       expect(mobile.amazon.phone).toBe(true);
520 |     });
521 | 
522 |     test('should not be an Amazon Tablet', () => {
523 |       expect(mobile.amazon.tablet).not.toBe(true);
524 |     });
525 | 
526 |     test('should be an Amazon device', () => {
527 |       expect(mobile.amazon.device).toBe(true);
528 |     });
529 | 
530 |     test('should be an Android Phone', () => {
531 |       expect(mobile.android.phone).toBe(true);
532 |     });
533 | 
534 |     test('should not be an Android Tablet', () => {
535 |       expect(mobile.android.tablet).not.toBe(true);
536 |     });
537 | 
538 |     test('should be matched as Any Phone', () => {
539 |       expect(mobile.phone).toBe(true);
540 |     });
541 | 
542 |     test('should be an Android device', () => {
543 |       expect(mobile.android.device).toBe(true);
544 |     });
545 |   });
546 | });
547 | 


--------------------------------------------------------------------------------