angular-slickgrid 4.1.4 → 4.2.2

package/test/cypress/node_modules/proxy-from-env/README.md

@@ -0,0 +1,131 @@
+# proxy-from-env
+
+[![Build Status](https://travis-ci.org/Rob--W/proxy-from-env.svg?branch=master)](https://travis-ci.org/Rob--W/proxy-from-env)
+[![Coverage Status](https://coveralls.io/repos/github/Rob--W/proxy-from-env/badge.svg?branch=master)](https://coveralls.io/github/Rob--W/proxy-from-env?branch=master)
+
+`proxy-from-env` is a Node.js package that exports a function (`getProxyForUrl`)
+that takes an input URL (a string or
+[`url.parse`](https://nodejs.org/docs/latest/api/url.html#url_url_parsing)'s
+return value) and returns the desired proxy URL (also a string) based on
+standard proxy environment variables. If no proxy is set, an empty string is
+returned.
+
+It is your responsibility to actually proxy the request using the given URL.
+
+Installation:
+
+```sh
+npm install proxy-from-env
+```
+
+## Example
+This example shows how the data for a URL can be fetched via the
+[`http` module](https://nodejs.org/api/http.html), in a proxy-aware way.
+
+```javascript
+var http = require('http');
+var parseUrl = require('url').parse;
+var getProxyForUrl = require('proxy-from-env').getProxyForUrl;
+
+var some_url = 'http://example.com/something';
+
+// // Example, if there is a proxy server at 10.0.0.1:1234, then setting the
+// // http_proxy environment variable causes the request to go through a proxy.
+// process.env.http_proxy = 'http://10.0.0.1:1234';
+// 
+// // But if the host to be proxied is listed in NO_PROXY, then the request is
+// // not proxied (but a direct request is made).
+// process.env.no_proxy = 'example.com';
+
+var proxy_url = getProxyForUrl(some_url);  // <-- Our magic.
+if (proxy_url) {
+  // Should be proxied through proxy_url.
+  var parsed_some_url = parseUrl(some_url);
+  var parsed_proxy_url = parseUrl(proxy_url);
+  // A HTTP proxy is quite simple. It is similar to a normal request, except the
+  // path is an absolute URL, and the proxied URL's host is put in the header
+  // instead of the server's actual host.
+  httpOptions = {
+    protocol: parsed_proxy_url.protocol,
+    hostname: parsed_proxy_url.hostname,
+    port: parsed_proxy_url.port,
+    path: parsed_some_url.href,
+    headers: {
+      Host: parsed_some_url.host,  // = host name + optional port.
+    },
+  };
+} else {
+  // Direct request.
+  httpOptions = some_url;
+}
+http.get(httpOptions, function(res) {
+  var responses = [];
+  res.on('data', function(chunk) { responses.push(chunk); });
+  res.on('end', function() { console.log(responses.join(''));  });
+});
+
+```
+
+## Environment variables
+The environment variables can be specified in lowercase or uppercase, with the
+lowercase name having precedence over the uppercase variant. A variable that is
+not set has the same meaning as a variable that is set but has no value.
+
+### NO\_PROXY
+
+`NO_PROXY` is a list of host names (optionally with a port). If the input URL
+matches any of the entries in `NO_PROXY`, then the input URL should be fetched
+by a direct request (i.e. without a proxy).
+
+Matching follows the following rules:
+
+- `NO_PROXY=*` disables all proxies.
+- Space and commas may be used to separate the entries in the `NO_PROXY` list.
+- If `NO_PROXY` does not contain any entries, then proxies are never disabled.
+- If a port is added after the host name, then the ports must match. If the URL
+  does not have an explicit port name, the protocol's default port is used.
+- Generally, the proxy is only disabled if the host name is an exact match for
+  an entry in the `NO_PROXY` list. The only exceptions are entries that start
+  with a dot or with a wildcard; then the proxy is disabled if the host name
+  ends with the entry.
+
+See `test.js` for examples of what should match and what does not.
+
+### \*\_PROXY
+
+The environment variable used for the proxy depends on the protocol of the URL.
+For example, `https://example.com` uses the "https" protocol, and therefore the
+proxy to be used is `HTTPS_PROXY` (_NOT_ `HTTP_PROXY`, which is _only_ used for
+http:-URLs).
+
+The library is not limited to http(s), other schemes such as
+`FTP_PROXY` (ftp:),
+`WSS_PROXY` (wss:),
+`WS_PROXY` (ws:)
+are also supported.
+
+If present, `ALL_PROXY` is used as fallback if there is no other match.
+
+
+## External resources
+The exact way of parsing the environment variables is not codified in any
+standard. This library is designed to be compatible with formats as expected by
+existing software.
+The following resources were used to determine the desired behavior:
+
+- cURL:
+  https://curl.haxx.se/docs/manpage.html#ENVIRONMENT  
+  https://github.com/curl/curl/blob/4af40b3646d3b09f68e419f7ca866ff395d1f897/lib/url.c#L4446-L4514  
+  https://github.com/curl/curl/blob/4af40b3646d3b09f68e419f7ca866ff395d1f897/lib/url.c#L4608-L4638  
+
+- wget: 
+  https://www.gnu.org/software/wget/manual/wget.html#Proxies  
+  http://git.savannah.gnu.org/cgit/wget.git/tree/src/init.c?id=636a5f9a1c508aa39e35a3a8e9e54520a284d93d#n383  
+  http://git.savannah.gnu.org/cgit/wget.git/tree/src/retr.c?id=93c1517c4071c4288ba5a4b038e7634e4c6b5482#n1278  
+
+- W3:
+  https://www.w3.org/Daemon/User/Proxies/ProxyClients.html  
+
+- Python's urllib:
+  https://github.com/python/cpython/blob/936135bb97fe04223aa30ca6e98eac8f3ed6b349/Lib/urllib/request.py#L755-L782  
+  https://github.com/python/cpython/blob/936135bb97fe04223aa30ca6e98eac8f3ed6b349/Lib/urllib/request.py#L2444-L2479

package/test/cypress/node_modules/psl/README.md

@@ -0,0 +1,215 @@
+# psl (Public Suffix List)
+
+[![NPM](https://nodei.co/npm/psl.png?downloads=true&downloadRank=true)](https://nodei.co/npm/psl/)
+
+[![Greenkeeper badge](https://badges.greenkeeper.io/lupomontero/psl.svg)](https://greenkeeper.io/)
+[![Build Status](https://travis-ci.org/lupomontero/psl.svg?branch=master)](https://travis-ci.org/lupomontero/psl)
+[![devDependency Status](https://david-dm.org/lupomontero/psl/dev-status.png)](https://david-dm.org/lupomontero/psl#info=devDependencies)
+
+`psl` is a `JavaScript` domain name parser based on the
+[Public Suffix List](https://publicsuffix.org/).
+
+This implementation is tested against the
+[test data hosted by Mozilla](http://mxr.mozilla.org/mozilla-central/source/netwerk/test/unit/data/test_psl.txt?raw=1)
+and kindly provided by [Comodo](https://www.comodo.com/).
+
+Cross browser testing provided by
+[<img alt="BrowserStack" width="160" src="./browserstack-logo.svg" />](https://www.browserstack.com/)
+
+## What is the Public Suffix List?
+
+The Public Suffix List is a cross-vendor initiative to provide an accurate list
+of domain name suffixes.
+
+The Public Suffix List is an initiative of the Mozilla Project, but is
+maintained as a community resource. It is available for use in any software,
+but was originally created to meet the needs of browser manufacturers.
+
+A "public suffix" is one under which Internet users can directly register names.
+Some examples of public suffixes are ".com", ".co.uk" and "pvt.k12.wy.us". The
+Public Suffix List is a list of all known public suffixes.
+
+Source: http://publicsuffix.org
+
+
+## Installation
+
+### Node.js
+
+```sh
+npm install --save psl
+```
+
+### Browser
+
+Download [psl.min.js](https://raw.githubusercontent.com/lupomontero/psl/master/dist/psl.min.js)
+and include it in a script tag.
+
+```html
+<script src="psl.min.js"></script>
+```
+
+This script is browserified and wrapped in a [umd](https://github.com/umdjs/umd)
+wrapper so you should be able to use it standalone or together with a module
+loader.
+
+## API
+
+### `psl.parse(domain)`
+
+Parse domain based on Public Suffix List. Returns an `Object` with the following
+properties:
+
+* `tld`: Top level domain (this is the _public suffix_).
+* `sld`: Second level domain (the first private part of the domain name).
+* `domain`: The domain name is the `sld` + `tld`.
+* `subdomain`: Optional parts left of the domain.
+
+#### Example:
+
+```js
+var psl = require('psl');
+
+// Parse domain without subdomain
+var parsed = psl.parse('google.com');
+console.log(parsed.tld); // 'com'
+console.log(parsed.sld); // 'google'
+console.log(parsed.domain); // 'google.com'
+console.log(parsed.subdomain); // null
+
+// Parse domain with subdomain
+var parsed = psl.parse('www.google.com');
+console.log(parsed.tld); // 'com'
+console.log(parsed.sld); // 'google'
+console.log(parsed.domain); // 'google.com'
+console.log(parsed.subdomain); // 'www'
+
+// Parse domain with nested subdomains
+var parsed = psl.parse('a.b.c.d.foo.com');
+console.log(parsed.tld); // 'com'
+console.log(parsed.sld); // 'foo'
+console.log(parsed.domain); // 'foo.com'
+console.log(parsed.subdomain); // 'a.b.c.d'
+```
+
+### `psl.get(domain)`
+
+Get domain name, `sld` + `tld`. Returns `null` if not valid.
+
+#### Example:
+
+```js
+var psl = require('psl');
+
+// null input.
+psl.get(null); // null
+
+// Mixed case.
+psl.get('COM'); // null
+psl.get('example.COM'); // 'example.com'
+psl.get('WwW.example.COM'); // 'example.com'
+
+// Unlisted TLD.
+psl.get('example'); // null
+psl.get('example.example'); // 'example.example'
+psl.get('b.example.example'); // 'example.example'
+psl.get('a.b.example.example'); // 'example.example'
+
+// TLD with only 1 rule.
+psl.get('biz'); // null
+psl.get('domain.biz'); // 'domain.biz'
+psl.get('b.domain.biz'); // 'domain.biz'
+psl.get('a.b.domain.biz'); // 'domain.biz'
+
+// TLD with some 2-level rules.
+psl.get('uk.com'); // null);
+psl.get('example.uk.com'); // 'example.uk.com');
+psl.get('b.example.uk.com'); // 'example.uk.com');
+
+// More complex TLD.
+psl.get('c.kobe.jp'); // null
+psl.get('b.c.kobe.jp'); // 'b.c.kobe.jp'
+psl.get('a.b.c.kobe.jp'); // 'b.c.kobe.jp'
+psl.get('city.kobe.jp'); // 'city.kobe.jp'
+psl.get('www.city.kobe.jp'); // 'city.kobe.jp'
+
+// IDN labels.
+psl.get('食狮.com.cn'); // '食狮.com.cn'
+psl.get('食狮.公司.cn'); // '食狮.公司.cn'
+psl.get('www.食狮.公司.cn'); // '食狮.公司.cn'
+
+// Same as above, but punycoded.
+psl.get('xn--85x722f.com.cn'); // 'xn--85x722f.com.cn'
+psl.get('xn--85x722f.xn--55qx5d.cn'); // 'xn--85x722f.xn--55qx5d.cn'
+psl.get('www.xn--85x722f.xn--55qx5d.cn'); // 'xn--85x722f.xn--55qx5d.cn'
+```
+
+### `psl.isValid(domain)`
+
+Check whether a domain has a valid Public Suffix. Returns a `Boolean` indicating
+whether the domain has a valid Public Suffix.
+
+#### Example
+
+```js
+var psl = require('psl');
+
+psl.isValid('google.com'); // true
+psl.isValid('www.google.com'); // true
+psl.isValid('x.yz'); // false
+```
+
+
+## Testing and Building
+
+Test are written using [`mocha`](https://mochajs.org/) and can be
+run in two different environments: `node` and `phantomjs`.
+
+```sh
+# This will run `eslint`, `mocha` and `karma`.
+npm test
+
+# Individual test environments
+# Run tests in node only.
+./node_modules/.bin/mocha test
+# Run tests in phantomjs only.
+./node_modules/.bin/karma start ./karma.conf.js --single-run
+
+# Build data (parse raw list) and create dist files
+npm run build
+```
+
+Feel free to fork if you see possible improvements!
+
+
+## Acknowledgements
+
+* Mozilla Foundation's [Public Suffix List](https://publicsuffix.org/)
+* Thanks to Rob Stradling of [Comodo](https://www.comodo.com/) for providing
+  test data.
+* Inspired by [weppos/publicsuffix-ruby](https://github.com/weppos/publicsuffix-ruby)
+
+
+## License
+
+The MIT License (MIT)
+
+Copyright (c) 2017 Lupo Montero <lupomontero@gmail.com>
+
+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.

package/test/cypress/node_modules/pump/README.md

@@ -0,0 +1,65 @@
+# pump
+
+pump is a small node module that pipes streams together and destroys all of them if one of them closes.
+
+```
+npm install pump
+```
+
+[![build status](http://img.shields.io/travis/mafintosh/pump.svg?style=flat)](http://travis-ci.org/mafintosh/pump)
+
+## What problem does it solve?
+
+When using standard `source.pipe(dest)` source will _not_ be destroyed if dest emits close or an error.
+You are also not able to provide a callback to tell when then pipe has finished.
+
+pump does these two things for you
+
+## Usage
+
+Simply pass the streams you want to pipe together to pump and add an optional callback
+
+``` js
+var pump = require('pump')
+var fs = require('fs')
+
+var source = fs.createReadStream('/dev/random')
+var dest = fs.createWriteStream('/dev/null')
+
+pump(source, dest, function(err) {
+  console.log('pipe finished', err)
+})
+
+setTimeout(function() {
+  dest.destroy() // when dest is closed pump will destroy source
+}, 1000)
+```
+
+You can use pump to pipe more than two streams together as well
+
+``` js
+var transform = someTransformStream()
+
+pump(source, transform, anotherTransform, dest, function(err) {
+  console.log('pipe finished', err)
+})
+```
+
+If `source`, `transform`, `anotherTransform` or `dest` closes all of them will be destroyed.
+
+Similarly to `stream.pipe()`, `pump()` returns the last stream passed in, so you can do:
+
+```
+return pump(s1, s2) // returns s2
+```
+
+If you want to return a stream that combines *both* s1 and s2 to a single stream use
+[pumpify](https://github.com/mafintosh/pumpify) instead.
+
+## License
+
+MIT
+
+## Related
+
+`pump` is part of the [mississippi stream utility collection](https://github.com/maxogden/mississippi) which includes more useful stream modules similar to this one.

package/test/cypress/node_modules/punycode/README.md

@@ -0,0 +1,122 @@
+# Punycode.js [![Build status](https://travis-ci.org/bestiejs/punycode.js.svg?branch=master)](https://travis-ci.org/bestiejs/punycode.js) [![Code coverage status](http://img.shields.io/codecov/c/github/bestiejs/punycode.js.svg)](https://codecov.io/gh/bestiejs/punycode.js) [![Dependency status](https://gemnasium.com/bestiejs/punycode.js.svg)](https://gemnasium.com/bestiejs/punycode.js)
+
+Punycode.js is a robust Punycode converter that fully complies to [RFC 3492](https://tools.ietf.org/html/rfc3492) and [RFC 5891](https://tools.ietf.org/html/rfc5891).
+
+This JavaScript library is the result of comparing, optimizing and documenting different open-source implementations of the Punycode algorithm:
+
+* [The C example code from RFC 3492](https://tools.ietf.org/html/rfc3492#appendix-C)
+* [`punycode.c` by _Markus W. Scherer_ (IBM)](http://opensource.apple.com/source/ICU/ICU-400.42/icuSources/common/punycode.c)
+* [`punycode.c` by _Ben Noordhuis_](https://github.com/bnoordhuis/punycode/blob/master/punycode.c)
+* [JavaScript implementation by _some_](http://stackoverflow.com/questions/183485/can-anyone-recommend-a-good-free-javascript-for-punycode-to-unicode-conversion/301287#301287)
+* [`punycode.js` by _Ben Noordhuis_](https://github.com/joyent/node/blob/426298c8c1c0d5b5224ac3658c41e7c2a3fe9377/lib/punycode.js) (note: [not fully compliant](https://github.com/joyent/node/issues/2072))
+
+This project was [bundled](https://github.com/joyent/node/blob/master/lib/punycode.js) with Node.js from [v0.6.2+](https://github.com/joyent/node/compare/975f1930b1...61e796decc) until [v7](https://github.com/nodejs/node/pull/7941) (soft-deprecated).
+
+The current version supports recent versions of Node.js only. It provides a CommonJS module and an ES6 module. For the old version that offers the same functionality with broader support, including Rhino, Ringo, Narwhal, and web browsers, see [v1.4.1](https://github.com/bestiejs/punycode.js/releases/tag/v1.4.1).
+
+## Installation
+
+Via [npm](https://www.npmjs.com/):
+
+```bash
+npm install punycode --save
+```
+
+In [Node.js](https://nodejs.org/):
+
+```js
+const punycode = require('punycode');
+```
+
+## API
+
+### `punycode.decode(string)`
+
+Converts a Punycode string of ASCII symbols to a string of Unicode symbols.
+
+```js
+// decode domain name parts
+punycode.decode('maana-pta'); // 'mañana'
+punycode.decode('--dqo34k'); // '☃-⌘'
+```
+
+### `punycode.encode(string)`
+
+Converts a string of Unicode symbols to a Punycode string of ASCII symbols.
+
+```js
+// encode domain name parts
+punycode.encode('mañana'); // 'maana-pta'
+punycode.encode('☃-⌘'); // '--dqo34k'
+```
+
+### `punycode.toUnicode(input)`
+
+Converts a Punycode string representing a domain name or an email address to Unicode. Only the Punycoded parts of the input will be converted, i.e. it doesn’t matter if you call it on a string that has already been converted to Unicode.
+
+```js
+// decode domain names
+punycode.toUnicode('xn--maana-pta.com');
+// → 'mañana.com'
+punycode.toUnicode('xn----dqo34k.com');
+// → '☃-⌘.com'
+
+// decode email addresses
+punycode.toUnicode('джумла@xn--p-8sbkgc5ag7bhce.xn--ba-lmcq');
+// → 'джумла@джpумлатест.bрфa'
+```
+
+### `punycode.toASCII(input)`
+
+Converts a lowercased Unicode string representing a domain name or an email address to Punycode. Only the non-ASCII parts of the input will be converted, i.e. it doesn’t matter if you call it with a domain that’s already in ASCII.
+
+```js
+// encode domain names
+punycode.toASCII('mañana.com');
+// → 'xn--maana-pta.com'
+punycode.toASCII('☃-⌘.com');
+// → 'xn----dqo34k.com'
+
+// encode email addresses
+punycode.toASCII('джумла@джpумлатест.bрфa');
+// → 'джумла@xn--p-8sbkgc5ag7bhce.xn--ba-lmcq'
+```
+
+### `punycode.ucs2`
+
+#### `punycode.ucs2.decode(string)`
+
+Creates an array containing the numeric code point values of each Unicode symbol in the string. While [JavaScript uses UCS-2 internally](https://mathiasbynens.be/notes/javascript-encoding), this function will convert a pair of surrogate halves (each of which UCS-2 exposes as separate characters) into a single code point, matching UTF-16.
+
+```js
+punycode.ucs2.decode('abc');
+// → [0x61, 0x62, 0x63]
+// surrogate pair for U+1D306 TETRAGRAM FOR CENTRE:
+punycode.ucs2.decode('\uD834\uDF06');
+// → [0x1D306]
+```
+
+#### `punycode.ucs2.encode(codePoints)`
+
+Creates a string based on an array of numeric code point values.
+
+```js
+punycode.ucs2.encode([0x61, 0x62, 0x63]);
+// → 'abc'
+punycode.ucs2.encode([0x1D306]);
+// → '\uD834\uDF06'
+```
+
+### `punycode.version`
+
+A string representing the current Punycode.js version number.
+
+## Author
+
+| [![twitter/mathias](https://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](https://twitter.com/mathias "Follow @mathias on Twitter") |
+|---|
+| [Mathias Bynens](https://mathiasbynens.be/) |
+
+## License
+
+Punycode.js is available under the [MIT](https://mths.be/mit) license.