added whole system from ola4doc

sys/node_modules/browserslist/CHANGELOG.md

@@ -0,0 +1,88 @@
+## 1.4
+* Add `defaults` keyword.
+
+## 1.3.6
+* Add `UCAndroid` alias to `and_uc` (by Evilebot Tnawi).
+
+## 1.3.5
+* Fix Opera Mini support. Use `op_mini all`.
+
+## 1.3.4
+* Add space-less `>1%` and `>.5%` syntax support (by Andreas Lind).
+
+## 1.3.3
+* Clean `0` versions in some country-based requests.
+
+## 1.3.2
+* Update Firefox ESR.
+
+## 1.3.1
+* Add Safari TP support.
+
+## 1.3
+* Add coverage for specific country (by Joshua Wise).
+
+## 1.2
+* Add `browserslist.coverage()` method.
+* Add `--coverage` and `-c` argument to CLI.
+* Add `-v` argument support to CLI.
+* Better error handling in CLI.
+
+## 1.1.3
+* Fix jspm support (by Sean Anderson).
+
+## 1.1.2
+* Fix jspm support (by Sean Anderson).
+
+## 1.1.1
+* Fix space-less `>10%` and `>10% in my stats` queries.
+* Normalize error messages.
+* Remove development files from npm package.
+
+## 1.1
+* Added query against custom browser usage data (by Daniel Rey).
+
+## 1.0.1
+* Update Firefox ESR (by Rouven Weßling).
+
+## 1.0
+* Remove Opera 12.1 from default query.
+* Add `not` keyword and exclude browsers by query.
+* Add Microsoft Edge support (by Andrey Polischuk).
+* Add CLI for debug and non-JS usage (by Luke Horvat).
+* Use own class in Browserslist errors.
+
+## 0.5
+* Add version ranges `IE 6-9` (by Ben Briggs).
+
+## 0.4
+* Add `config` option and `BROWSERSLIST_CONFIG` environment variable support.
+* Add symlink config support.
+
+## 0.3.3
+* Fix DynJS compatibility (by Nick Howes).
+
+## 0.3.2
+* Fix joined versions on versions query (by Vincent De Oliveira).
+
+## 0.3.1
+* Fix global variable leak (by Peter Müller).
+
+## 0.3
+* Takes criterias from `BROWSERSLIST` environment variable.
+
+## 0.2
+* Return Can I Use joined versions as `ios_saf 7.0-7.1`.
+
+## 0.1.3
+* Better work with Can I Use joined versions like `ios_saf 7.0-7.1`.
+* Browserslist now understands `ios_saf 7.0` or `ios_saf 7`.
+
+## 0.1.2
+* Do not create global `browserslist` var (by Maxime Thirouin).
+
+## 0.1.1
+* Sort browsers by name and version.
+
+## 0.1
+* Initial release.

sys/node_modules/browserslist/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright 2014 Andrey Sitnik <andrey@sitnik.ru>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

sys/node_modules/browserslist/README.md

@@ -0,0 +1,233 @@
+# Browserslist [![Build Status][ci-img]][ci]
+
+Get browser versions that match given criteria.
+Useful for tools like [Autoprefixer].
+
+You can select browsers by passing a string. This library will use
+Can I Use data to return list of all matching versions.
+For example, query to select all browser versions that are the last version
+of each major browser, or have a usage of over 10% in global usage statistics:
+
+```js
+browserslist('last 1 version, > 10%');
+//=> ["and_chr 51", "chrome 53", "chrome 52", "edge 14", "firefox 49",
+//    "ie 11", "ie_mob 11", "ios_saf 10", "opera 39", "safari 10"]
+```
+
+To share browser support with users, you can use [browserl.ist](http://browserl.ist/).
+
+<a href="https://evilmartians.com/?utm_source=browserslist">
+  <img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg"
+    alt="Sponsored by Evil Martians"
+    width="236"
+    height="54"
+  \>
+</a>
+
+[Autoprefixer]: https://github.com/postcss/autoprefixer
+[ci-img]:       https://travis-ci.org/ai/browserslist.svg
+[ci]:           https://travis-ci.org/ai/browserslist
+
+## Queries
+
+Browserslist will use browsers criterias from:
+
+1. First argument.
+2. `BROWSERSLIST` environment variable.
+3. `browserslist` config file in current or parent directories.
+4. If all methods will not give a result, Browserslist will use defaults:
+   `> 1%, last 2 versions, Firefox ESR`.
+
+Multiple criteria are combined as a boolean `OR`. A browser version must match
+at least one of the criteria to be selected.
+
+You can specify the versions by queries (case insensitive):
+
+* `last 2 versions`: the last 2 versions for each major browser.
+* `last 2 Chrome versions`: the last 2 versions of Chrome browser.
+* `> 5%`: versions selected by global usage statistics.
+* `> 5% in US`: uses USA usage statistics. It accepts [two-letter country code].
+* `> 5% in my stats`: uses [custom usage data].
+* `ie 6-8`: selects an inclusive range of versions.
+* `Firefox > 20`: versions of Firefox newer than 20.
+* `Firefox >= 20`: versions of Firefox newer than or equal to 20.
+* `Firefox < 20`: versions of Firefox less than 20.
+* `Firefox <= 20`: versions of Firefox less than or equal to 20.
+* `Firefox ESR`: the latest [Firefox ESR] version.
+* `iOS 7`: the iOS browser version 7 directly.
+* `not ie <= 8`: exclude browsers selected before by previous queries.
+  You can add `not ` to any query.
+
+Browserslist works with separated versions of browsers.
+You should avoid queries like `Firefox > 0`.
+
+All queries are based on the [Can I Use] support table, e. g. `last 3 iOS versions` might select `8.4, 9.2, 9.3` (mixed major & minor), whereas `last 3 Chrome versions` might select `50, 49, 48` (major only).
+
+[two-letter country code]: http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements
+[custom usage data]:       #custom-usage-data
+[Can I Use]:               http://caniuse.com/
+
+## Browsers
+
+Names are case insensitive:
+
+### Major Browsers
+
+* `Chrome` for Google Chrome.
+* `Firefox` or `ff` for Mozilla Firefox.
+* `Explorer` or `ie` for Internet Explorer.
+* `Edge` for Microsoft Edge.
+* `iOS` or `ios_saf` for iOS Safari.
+* `Opera` for Opera.
+* `Safari` for desktop Safari.
+* `ExplorerMobile` or `ie_mob` for Internet Explorer Mobile.
+
+### Other
+
+* `Android` for Android WebView.
+* `BlackBerry` or `bb` for Blackberry browser.
+* `ChromeAndroid` or `and_chr` for Chrome for Android
+  (in Other section, because mostly same as common `Chrome`).
+* `FirefoxAndroid` or `and_ff` for Firefox for Android.
+* `OperaMobile` or `op_mob` for Opera Mobile.
+* `OperaMini` or `op_mini` for Opera Mini.
+* `Samsung` for Samsung Internet.
+* `UCAndroid` or `and_uc` for UC Browser for Android.
+
+## Config File
+
+Browserslist’s config should be named `browserslist` and have browsers queries
+split by a new line. Comments starts with `#` symbol:
+
+```yaml
+# Browsers that we support
+
+> 1%
+Last 2 versions
+IE 8 # sorry
+```
+
+Browserslist will check config in every directory in `path`.
+So, if tool process `app/styles/main.css`, you can put config to root,
+`app/` or `app/styles`.
+
+You can specify direct path to config by `config` option
+or `BROWSERSLIST_CONFIG` environment variables.
+
+## Environment Variables
+
+If some tool use Browserslist inside, you can change browsers settings
+by [environment variables]:
+
+* `BROWSERSLIST` with browsers queries.
+
+   ```sh
+  BROWSERSLIST="> 5%" gulp css
+   ```
+
+* `BROWSERSLIST_CONFIG` with path to config file.
+
+   ```sh
+  BROWSERSLIST_CONFIG=./config/browserslist gulp css
+   ```
+
+* `BROWSERSLIST_STATS` with path to the custom usage data.
+
+   ```sh
+  BROWSERSLIST_STATS=./config/usage_data.json gulp css
+   ```
+
+[environment variables]: https://en.wikipedia.org/wiki/Environment_variable
+
+## Custom Usage Data
+
+If you have a website, you can query against the usage statistics of your site:
+
+1. Import your Google Analytics data into [Can I Use].
+   Press `Import…` button in Settings page.
+2. Open browser DevTools on [caniuse.com] add paste this snippet into Console:
+
+    ```js
+   var e=document.createElement('a');e.setAttribute('href', 'data:text/plain;charset=utf-8,'+encodeURIComponent(JSON.stringify(JSON.parse(localStorage['usage-data-by-id'])[localStorage['config-primary_usage']])));e.setAttribute('download','stats.json');document.body.appendChild(e);e.click();document.body.removeChild(e);
+    ```
+3. Save data to file in your project.
+4. Give it to Browserslist by `stats` option
+   or `BROWSERSLIST_STATS` environment variable:
+
+    ```js
+   browserslist('> 5% in my stats', { stats: 'path/to/the/stats.json' });
+    ```
+
+Of course, you can generate usage statistics file by any other method.
+Option `stats` accepts path to file or data itself:
+
+```js
+var custom = {
+    ie: {
+        6: 0.01,
+        7: 0.4,
+        8: 1.5
+    },
+    chrome: {
+        …
+    },
+    …
+};
+
+browserslist('> 5% in my stats', { stats: custom });
+```
+
+Note that you can query against your custom usage data while also querying
+against global or regional data. For example, the query
+`> 5% in my stats, > 1%, > 10% in US` is permitted.
+
+[Can I Use]: http://caniuse.com/
+
+## Usage
+
+```js
+var browserslist = require('browserslist');
+
+// Your CSS/JS build tool code
+var process = function (css, opts) {
+    var browsers = browserslist(opts.browsers, { path: opts.file });
+    // Your code to add features for selected browsers
+}
+```
+
+Queries can be a string `"> 5%, last 1 version"`
+or an array `['> 5%', 'last 1 version']`.
+
+If a query is missing, Browserslist will look for a config file.
+You can provide a `path` option (that can be a file) to find the config file
+relatively to it.
+
+For non-JS environment and debug purpose you can use CLI tool:
+
+```sh
+browserslist "> 1%, last 2 version"
+```
+
+## Coverage
+
+You can get total users coverage for selected browsers by JS API:
+
+```js
+browserslist.coverage(browserslist('> 1%')) //=> 81.4
+```
+
+```js
+browserslist.coverage(browserslist('> 1% in US'), 'US') //=> 83.1
+```
+
+Or by CLI:
+
+```sh
+$ browserslist --coverage "> 1%"
+These browsers account for 81.4% of all users globally
+```
+
+```sh
+$ browserslist --coverage=US "> 1% in US"
+These browsers account for 83.1% of all users in the US
+```

sys/node_modules/browserslist/cli.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+
+var browserslist = require('./');
+var pkg          = require('./package.json');
+var args         = process.argv.slice(2);
+
+function isArg(arg) {
+    return args.some(function (str) {
+        return str === arg || str.indexOf(arg + '=') === 0;
+    });
+}
+
+function getArgValue(arg) {
+    var found = args.filter(function (str) {
+        return str.indexOf(arg + '=') === 0;
+    })[0];
+    var value = found && found.split('=')[1];
+    return value && value.replace(/^['"]|['"]$/g, '');
+}
+
+function error(msg) {
+    process.stderr.write(pkg.name + ': ' + msg + '\n');
+    process.exit(1);
+}
+
+function query(queries) {
+    try {
+        return browserslist(queries);
+    } catch (e) {
+        if ( e.name === 'BrowserslistError' ) {
+            return error(e.message);
+        } else {
+            throw e;
+        }
+    }
+}
+
+if ( args.length === 0 || isArg('--help') || isArg('-h') ) {
+    process.stdout.write([
+        pkg.description,
+        '',
+        'Usage:',
+        '  ' + pkg.name + ' "QUERIES"',
+        '  ' + pkg.name + ' --coverage "QUERIES"',
+        '  ' + pkg.name + ' --coverage=US "QUERIES"'
+    ].join('\n') + '\n');
+
+} else if ( isArg('--version') || isArg('-v') ) {
+    process.stdout.write(pkg.name + ' ' + pkg.version + '\n');
+
+} else if ( isArg('--version') || isArg('-v') ) {
+    process.stdout.write(pkg.name + ' ' + pkg.version + '\n');
+
+} else if ( isArg('--coverage') || isArg('-c') ) {
+    var browsers = args.find(function (i) {
+        return i[0] !== '-';
+    });
+    if ( !browsers ) error('Define a browsers query to get coverage');
+
+    var country = getArgValue('--coverage') || getArgValue('-c');
+    var result  = browserslist.coverage(query(browsers), country);
+    var round   = Math.round(result * 100) / 100.0;
+
+    var end = 'globally';
+    if (country && country !== 'global') {
+        end = 'in the ' + country.toUpperCase();
+    }
+
+    process.stdout.write(
+        'These browsers account for ' + round + '% of all users ' + end + '\n');
+
+} else if ( args.length === 1 && args[0][0] !== '-' ) {
+    query(args[0]).forEach(function (browser) {
+        process.stdout.write(browser + '\n');
+    });
+
+} else {
+    error('Unknown arguments. Use --help to pick right one.');
+}

sys/node_modules/browserslist/index.js

@@ -0,0 +1,500 @@
+var caniuse = require('caniuse-db/data.json').agents;
+var path    = require('path');
+var fs      = require('fs');
+
+var FLOAT = /^\d+(\.\d+)?$/;
+
+function uniq(array) {
+    var filtered = [];
+    for ( var i = 0; i < array.length; i++ ) {
+        if ( filtered.indexOf(array[i]) === -1 ) filtered.push(array[i]);
+    }
+    return filtered;
+}
+
+function BrowserslistError(message) {
+    this.name = 'BrowserslistError';
+    this.message = message || '';
+    if ( Error.captureStackTrace ) {
+        Error.captureStackTrace(this, BrowserslistError);
+    }
+}
+BrowserslistError.prototype = Error.prototype;
+
+function error(name) {
+    var obj = new BrowserslistError(name);
+    obj.browserslist = true;
+    throw obj;
+}
+
+// Helpers
+
+var normalize = function (versions) {
+    return versions.filter(function (version) {
+        return typeof version === 'string';
+    });
+};
+
+var fillUsage = function (result, name, data) {
+    for ( var i in data ) {
+        result[name + ' ' + i] = data[i];
+    }
+};
+
+// Return array of browsers by selection queries:
+//
+//   browserslist('IE >= 10, IE 8') //=> ['ie 11', 'ie 10', 'ie 8']
+var browserslist = function (selections, opts) {
+    if ( typeof opts === 'undefined' ) opts = { };
+
+    if ( typeof selections === 'undefined' || selections === null ) {
+
+        if ( process.env.BROWSERSLIST ) {
+            selections = process.env.BROWSERSLIST;
+        } else if ( opts.config || process.env.BROWSERSLIST_CONFIG ) {
+            var file = opts.config || process.env.BROWSERSLIST_CONFIG;
+            if ( fs.existsSync(file) && fs.statSync(file).isFile() ) {
+                selections = browserslist.parseConfig( fs.readFileSync(file) );
+            } else {
+                error('Can\'t read ' + file + ' config');
+            }
+        } else {
+            var config = browserslist.readConfig(opts.path);
+            if ( config !== false ) {
+                selections = config;
+            } else {
+                selections = browserslist.defaults;
+            }
+        }
+    }
+
+    if ( typeof selections === 'string' ) {
+        selections = selections.split(/,\s*/);
+    }
+
+    if ( opts.stats || process.env.BROWSERSLIST_STATS ) {
+        browserslist.usage.custom = { };
+        var stats = opts.stats || process.env.BROWSERSLIST_STATS;
+        if ( typeof stats === 'string' ) {
+            try {
+                stats = JSON.parse(fs.readFileSync(stats));
+            } catch (e) {
+                error('Can\'t read ' + stats);
+            }
+        }
+        if ( 'dataByBrowser' in stats ) {
+            // Allow to use the data as-is from the caniuse.com website
+            stats = stats.dataByBrowser;
+        }
+        for ( var browser in stats ) {
+            fillUsage(browserslist.usage.custom, browser, stats[browser]);
+        }
+    }
+
+    var result = [];
+
+    var exclude, query, match, array, used;
+    selections.forEach(function (selection) {
+        if ( selection.trim() === '' ) return;
+        exclude = false;
+        used    = false;
+
+        if ( selection.indexOf('not ') === 0 ) {
+            selection = selection.slice(4);
+            exclude   = true;
+        }
+
+        for ( var i in browserslist.queries ) {
+            query = browserslist.queries[i];
+            match = selection.match(query.regexp);
+            if ( match ) {
+                array = query.select.apply(browserslist, match.slice(1));
+                if ( exclude ) {
+                    result = result.filter(function (j) {
+                        return array.indexOf(j) === -1;
+                    });
+                } else {
+                    result = result.concat(array);
+                }
+                used   = true;
+                break;
+            }
+        }
+
+        if ( !used ) {
+            error('Unknown browser query `' + selection + '`');
+        }
+    });
+
+    result = uniq(result);
+
+    return result.filter(function (i) {
+        var version = i.split(' ')[1];
+        if ( version === '0' ) {
+            var name = i.split(' ')[0];
+            return !result.some(function (j) {
+                return j !== i && j.split(' ')[0] === name;
+            });
+        } else {
+            return true;
+        }
+    }).sort(function (name1, name2) {
+        name1 = name1.split(' ');
+        name2 = name2.split(' ');
+        if ( name1[0] === name2[0] ) {
+            if ( FLOAT.test(name1[1]) && FLOAT.test(name2[1]) ) {
+                var d = parseFloat(name2[1]) - parseFloat(name1[1]);
+                if ( d > 0 ) {
+                    return 1;
+                } else if ( d < 0 ) {
+                    return -1;
+                } else {
+                    return 0;
+                }
+            } else {
+                return name2[1].localeCompare(name1[1]);
+            }
+        } else {
+            return name1[0].localeCompare(name2[0]);
+        }
+    });
+};
+
+var normalizeVersion = function (data, version) {
+    if ( data.versions.indexOf(version) !== -1 ) {
+        return version;
+    } else {
+        return browserslist.versionAliases[data.name][version];
+    }
+};
+
+var loadCountryStatistics = function (country) {
+    if (!browserslist.usage[country]) {
+        var usage = { };
+        var data = require(
+            'caniuse-db/region-usage-json/' + country + '.json');
+        for ( var i in data.data ) {
+            fillUsage(usage, i, data.data[i]);
+        }
+        browserslist.usage[country] = usage;
+    }
+};
+
+// Will be filled by Can I Use data below
+browserslist.data  = { };
+browserslist.usage = {
+    global: { },
+    custom: null
+};
+
+// Default browsers query
+browserslist.defaults = [
+    '> 1%',
+    'last 2 versions',
+    'Firefox ESR'
+];
+
+// What browsers will be used in `last n version` query
+browserslist.major = ['safari', 'opera', 'ios_saf', 'ie_mob', 'ie',
+                      'edge', 'firefox', 'chrome'];
+
+// Browser names aliases
+browserslist.aliases = {
+    fx:             'firefox',
+    ff:             'firefox',
+    ios:            'ios_saf',
+    explorer:       'ie',
+    blackberry:     'bb',
+    explorermobile: 'ie_mob',
+    operamini:      'op_mini',
+    operamobile:    'op_mob',
+    chromeandroid:  'and_chr',
+    firefoxandroid: 'and_ff',
+    ucandroid:      'and_uc'
+};
+
+// Aliases to work with joined versions like `ios_saf 7.0-7.1`
+browserslist.versionAliases = { };
+
+// Get browser data by alias or case insensitive name
+browserslist.byName = function (name) {
+    name = name.toLowerCase();
+    name = browserslist.aliases[name] || name;
+    return browserslist.data[name];
+};
+
+// Get browser data by alias or case insensitive name and throw error
+// on unknown browser
+browserslist.checkName = function (name) {
+    var data = browserslist.byName(name);
+    if ( !data ) error('Unknown browser ' + name);
+    return data;
+};
+
+// Find config, read file and parse it
+browserslist.readConfig = function (from) {
+    if ( from === false )   return false;
+    if ( !fs.readFileSync || !fs.existsSync || !fs.statSync ) return false;
+    if ( typeof from === 'undefined' ) from = '.';
+
+    var dirs = path.resolve(from).split(path.sep);
+    var config;
+    while ( dirs.length ) {
+        config = dirs.concat(['browserslist']).join(path.sep);
+
+        if ( fs.existsSync(config) && fs.statSync(config).isFile() ) {
+            return browserslist.parseConfig( fs.readFileSync(config) );
+        }
+
+        dirs.pop();
+    }
+
+    return false;
+};
+
+// Return browsers market coverage
+browserslist.coverage = function (browsers, country) {
+    if (country && country !== 'global') {
+        country = country.toUpperCase();
+        loadCountryStatistics(country);
+    } else {
+        country = 'global'; // Default value
+    }
+
+    return browsers.reduce(function (all, i) {
+        var usage = browserslist.usage[country][i];
+        if (usage === undefined) {
+            // Sometimes, Caniuse consolidates country usage data into a single
+            // "version 0" entry. This is usually when there is only 1 version.
+            usage = browserslist.usage[country][i.replace(/ [\d.]+$/, ' 0')];
+        }
+        return all + (usage || 0);
+    }, 0);
+};
+
+// Return array of queries from config content
+browserslist.parseConfig = function (string) {
+    return string.toString()
+            .replace(/#[^\n]*/g, '')
+            .split(/\n/)
+            .map(function (i) {
+                return i.trim();
+            }).filter(function (i) {
+                return i !== '';
+            });
+};
+
+browserslist.queries = {
+
+    lastVersions: {
+        regexp: /^last\s+(\d+)\s+versions?$/i,
+        select: function (versions) {
+            var selected = [];
+            browserslist.major.forEach(function (name) {
+                var data  = browserslist.byName(name);
+                if ( !data ) return;
+                var array = data.released.slice(-versions);
+
+                array = array.map(function (v) {
+                    return data.name + ' ' + v;
+                });
+                selected = selected.concat(array);
+            });
+            return selected;
+        }
+    },
+
+    lastByBrowser: {
+        regexp: /^last\s+(\d+)\s+(\w+)\s+versions?$/i,
+        select: function (versions, name) {
+            var data = browserslist.checkName(name);
+            return data.released.slice(-versions).map(function (v) {
+                return data.name + ' ' + v;
+            });
+        }
+    },
+
+    globalStatistics: {
+        regexp: /^>\s*(\d*\.?\d+)%$/,
+        select: function (popularity) {
+            popularity = parseFloat(popularity);
+            var result = [];
+
+            for ( var version in browserslist.usage.global ) {
+                if ( browserslist.usage.global[version] > popularity ) {
+                    result.push(version);
+                }
+            }
+
+            return result;
+        }
+    },
+
+    customStatistics: {
+        regexp: /^>\s*(\d*\.?\d+)%\s+in\s+my\s+stats$/,
+        select: function (popularity) {
+            popularity = parseFloat(popularity);
+            var result = [];
+
+            var usage = browserslist.usage.custom;
+            if ( !usage ) {
+                error('Custom usage statistics was not provided');
+            }
+
+            for ( var version in usage ) {
+                if ( usage[version] > popularity ) {
+                    result.push(version);
+                }
+            }
+
+            return result;
+        }
+    },
+
+    countryStatistics: {
+        regexp: /^>\s*(\d*\.?\d+)%\s+in\s+(\w\w)$/,
+        select: function (popularity, country) {
+            popularity = parseFloat(popularity);
+            country    = country.toUpperCase();
+            var result = [];
+
+            loadCountryStatistics(country);
+            var usage = browserslist.usage[country];
+
+            for ( var version in usage ) {
+                if ( usage[version] > popularity ) {
+                    result.push(version);
+                }
+            }
+
+            return result;
+        }
+    },
+
+    range: {
+        regexp: /^(\w+)\s+([\d\.]+)\s*-\s*([\d\.]+)$/i,
+        select: function (name, from, to) {
+            var data = browserslist.checkName(name);
+            from = parseFloat(normalizeVersion(data, from) || from);
+            to = parseFloat(normalizeVersion(data, to) || to);
+
+            var filter = function (v) {
+                var parsed = parseFloat(v);
+                return parsed >= from && parsed <= to;
+            };
+
+            return data.released.filter(filter).map(function (v) {
+                return data.name + ' ' + v;
+            });
+        }
+    },
+
+    versions: {
+        regexp: /^(\w+)\s*(>=?|<=?)\s*([\d\.]+)$/,
+        select: function (name, sign, version) {
+            var data = browserslist.checkName(name);
+            var alias = normalizeVersion(data, version);
+            if ( alias ) {
+                version = alias;
+            }
+            version = parseFloat(version);
+
+            var filter;
+            if ( sign === '>' ) {
+                filter = function (v) {
+                    return parseFloat(v) > version;
+                };
+            } else if ( sign === '>=' ) {
+                filter = function (v) {
+                    return parseFloat(v) >= version;
+                };
+            } else if ( sign === '<' ) {
+                filter = function (v) {
+                    return parseFloat(v) < version;
+                };
+            } else if ( sign === '<=' ) {
+                filter = function (v) {
+                    return parseFloat(v) <= version;
+                };
+            }
+            return data.released.filter(filter).map(function (v) {
+                return data.name + ' ' + v;
+            });
+        }
+    },
+
+    esr: {
+        regexp: /^(firefox|ff|fx)\s+esr$/i,
+        select: function () {
+            return ['firefox 45'];
+        }
+    },
+
+    opMini: {
+        regexp: /(operamini|op_mini)\s+all/i,
+        select: function () {
+            return ['op_mini all'];
+        }
+    },
+
+    direct: {
+        regexp: /^(\w+)\s+(tp|[\d\.]+)$/i,
+        select: function (name, version) {
+            if ( /tp/i.test(version) ) version = 'TP';
+            var data  = browserslist.checkName(name);
+            var alias = normalizeVersion(data, version);
+            if ( alias ) {
+                version = alias;
+            } else {
+                if ( version.indexOf('.') === -1 ) {
+                    alias = version + '.0';
+                } else if ( /\.0$/.test(version) ) {
+                    alias = version.replace(/\.0$/, '');
+                }
+                alias = normalizeVersion(data, alias);
+                if ( alias ) {
+                    version = alias;
+                } else {
+                    error('Unknown version ' + version + ' of ' + name);
+                }
+            }
+            return [data.name + ' ' + version];
+        }
+    },
+
+    defaults: {
+        regexp: /^defaults$/i,
+        select: function () {
+            return browserslist(browserslist.defaults);
+        }
+    }
+
+};
+
+// Get and convert Can I Use data
+
+(function () {
+    for ( var name in caniuse ) {
+        browserslist.data[name] = {
+            name:     name,
+            versions: normalize(caniuse[name].versions),
+            released: normalize(caniuse[name].versions.slice(0, -3))
+        };
+        fillUsage(browserslist.usage.global, name, caniuse[name].usage_global);
+
+        browserslist.versionAliases[name] = { };
+        for ( var i = 0; i < caniuse[name].versions.length; i++ ) {
+            if ( !caniuse[name].versions[i] ) continue;
+            var full = caniuse[name].versions[i];
+
+            if ( full.indexOf('-') !== -1 ) {
+                var interval = full.split('-');
+                for ( var j = 0; j < interval.length; j++ ) {
+                    browserslist.versionAliases[name][interval[j]] = full;
+                }
+            }
+        }
+    }
+}());
+
+module.exports = browserslist;

sys/node_modules/browserslist/package.json

@@ -0,0 +1,96 @@
+{
+  "_args": [
+    [
+      {
+        "raw": "browserslist@~1.4.0",
+        "scope": null,
+        "escapedName": "browserslist",
+        "name": "browserslist",
+        "rawSpec": "~1.4.0",
+        "spec": ">=1.4.0 <1.5.0",
+        "type": "range"
+      },
+      "/mnt/Data/bach/Documents/ola/OLA#3DOC/sys/node_modules/autoprefixer"
+    ]
+  ],
+  "_from": "browserslist@>=1.4.0 <1.5.0",
+  "_id": "browserslist@1.4.0",
+  "_inCache": true,
+  "_location": "/browserslist",
+  "_nodeVersion": "6.6.0",
+  "_npmOperationalInternal": {
+    "host": "packages-12-west.internal.npmjs.com",
+    "tmp": "tmp/browserslist-1.4.0.tgz_1474894616062_0.6606198253575712"
+  },
+  "_npmUser": {
+    "name": "ai",
+    "email": "andrey@sitnik.ru"
+  },
+  "_npmVersion": "3.10.3",
+  "_phantomChildren": {},
+  "_requested": {
+    "raw": "browserslist@~1.4.0",
+    "scope": null,
+    "escapedName": "browserslist",
+    "name": "browserslist",
+    "rawSpec": "~1.4.0",
+    "spec": ">=1.4.0 <1.5.0",
+    "type": "range"
+  },
+  "_requiredBy": [
+    "/autoprefixer"
+  ],
+  "_resolved": "https://registry.npmjs.org/browserslist/-/browserslist-1.4.0.tgz",
+  "_shasum": "9cfdcf5384d9158f5b70da2aa00b30e8ff019049",
+  "_shrinkwrap": null,
+  "_spec": "browserslist@~1.4.0",
+  "_where": "/mnt/Data/bach/Documents/ola/OLA#3DOC/sys/node_modules/autoprefixer",
+  "author": {
+    "name": "Andrey Sitnik",
+    "email": "andrey@sitnik.ru"
+  },
+  "bin": {
+    "browserslist": "./cli.js"
+  },
+  "bugs": {
+    "url": "https://github.com/ai/browserslist/issues"
+  },
+  "dependencies": {
+    "caniuse-db": "^1.0.30000539"
+  },
+  "description": "Get browsers versions that matches given criterias like in Autoprefixer",
+  "devDependencies": {
+    "ava": "0.16.0",
+    "eslint": "3.6.0",
+    "eslint-config-postcss": "2.0.2"
+  },
+  "directories": {},
+  "dist": {
+    "shasum": "9cfdcf5384d9158f5b70da2aa00b30e8ff019049",
+    "tarball": "https://registry.npmjs.org/browserslist/-/browserslist-1.4.0.tgz"
+  },
+  "gitHead": "899cfa8240c879c7544f20c52eaf2d3f2e7e2be9",
+  "homepage": "https://github.com/ai/browserslist#readme",
+  "keywords": [
+    "caniuse",
+    "browsers"
+  ],
+  "license": "MIT",
+  "maintainers": [
+    {
+      "name": "ai",
+      "email": "andrey@sitnik.ru"
+    }
+  ],
+  "name": "browserslist",
+  "optionalDependencies": {},
+  "readme": "ERROR: No README data found!",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ai/browserslist.git"
+  },
+  "scripts": {
+    "test": "ava && eslint *.js test/*.js"
+  },
+  "version": "1.4.0"
+}