m0603va 1.0.0

package/Laba6/node_modules/nodemailer-fetch/README.md

@@ -0,0 +1,55 @@
+# nodemailer-fetch
+
+Fetches HTTP URL contents for [nodemailer](https://github.com/nodemailer/nodemailer).
+
+[![Build Status](https://secure.travis-ci.org/nodemailer/nodemailer-fetch.svg)](http://travis-ci.org/nodemailer/nodemailer-fetch)
+<a href="http://badge.fury.io/js/nodemailer-fetch"><img src="https://badge.fury.io/js/nodemailer-fetch.svg" alt="NPM version" height="18"></a>
+
+## Usage
+
+```javascript
+var fetch = require('nodemailer-fetch');
+fetch('http://www.google.com/').pipe(process.stdout);
+```
+
+The method takes the destination URL as the first and optional options object as the second argument.
+
+The defaults are the following:
+
+  * Default method is GET
+  * Basic auth is supported
+  * Up to 5 redirects are followed (Basic auth gets lost after first redirect)
+  * gzip is handled if present
+  * Cookies are supported
+  * No shared HTTP Agent
+  * Invalid SSL certs are allowed. Can be overwritten with the `tls` option
+
+### options
+
+Possible options are the following:
+
+  * **userAgent** a string defining the User Agent of the request (by default not set)
+  * **cookie** a cookie string or an array of cookie strings where a cookie is the value used by 'Set-Cookie' header
+  * **maxRedirects** how many redirects to allow (defaults to 5, set to 0 to disable redirects entirely)
+  * **method** HTTP method to use, defaults to GET (if `body` is set defaults to POST)
+  * **body** HTTP payload to send. If the value is an object it is converted to an *x-www-form-urlencoded* payload, other values are passed as is. Unlike authentication data payload and method is preserved between redirects
+  * **contentType** optional content type for the HTTP payload. Defaults to *x-www-form-urlencoded*. If the value is `false` then Content-Type header is not set
+  * **tls** optional object of TLS options
+  * **timeout** (milliseconds) sets timeout for the connection. Returns an error if timeout occurs
+  * **headers** custom headers as an object where key is the header key and value is either a string or an array of strings for multiple values
+
+  ```javascript
+  var fetch = require('nodemailer-fetch');
+  fetch('http://www.google.com/', {
+      cookie: [
+          'cookie_name1=cookie_value1',
+          'cookie_name2=cookie_value2; expires=Sun, 16 Jul 3567 06:23:41 GMT',
+      ],
+      userAgent: 'MyFetcher/1.0'
+  }).pipe(process.stdout);
+  ```
+
+> Cookies are domain specific like normal browser cookies, so if a redirect happens to another domain, then cookies are not passed to it, HTTPS-only cookies are not passed to HTTP etc.
+
+## License
+**MIT**

package/Laba6/node_modules/nodemailer-fetch/lib/cookies.js

@@ -0,0 +1,275 @@
+'use strict';
+
+// module to handle cookies
+
+var urllib = require('url');
+
+var SESSION_TIMEOUT = 1800; // 30 min
+
+module.exports = Cookies;
+
+/**
+ * Creates a biskviit cookie jar for managing cookie values in memory
+ *
+ * @constructor
+ * @param {Object} [options] Optional options object
+ */
+function Cookies(options) {
+    this.options = options || {};
+    this.cookies = [];
+}
+
+/**
+ * Stores a cookie string to the cookie storage
+ *
+ * @param {String} cookieStr Value from the 'Set-Cookie:' header
+ * @param {String} url Current URL
+ */
+Cookies.prototype.set = function (cookieStr, url) {
+    var urlparts = urllib.parse(url || '');
+    var cookie = this.parse(cookieStr);
+    var domain;
+
+    if (cookie.domain) {
+        domain = cookie.domain.replace(/^\./, '');
+
+        // do not allow cross origin cookies
+        if (
+            // can't be valid if the requested domain is shorter than current hostname
+            urlparts.hostname.length < domain.length ||
+
+            // prefix domains with dot to be sure that partial matches are not used
+            ('.' + urlparts.hostname).substr(-domain.length + 1) !== ('.' + domain)) {
+            cookie.domain = urlparts.hostname;
+        }
+    } else {
+        cookie.domain = urlparts.hostname;
+    }
+
+    if (!cookie.path) {
+        cookie.path = this.getPath(urlparts.pathname);
+    }
+
+    // if no expire date, then use sessionTimeout value
+    if (!cookie.expires) {
+        cookie.expires = new Date(Date.now() + (Number(this.options.sessionTimeout || SESSION_TIMEOUT) || SESSION_TIMEOUT) * 1000);
+    }
+
+    return this.add(cookie);
+};
+
+/**
+ * Returns cookie string for the 'Cookie:' header.
+ *
+ * @param {String} url URL to check for
+ * @returns {String} Cookie header or empty string if no matches were found
+ */
+Cookies.prototype.get = function (url) {
+    return this.list(url).map(function (cookie) {
+        return cookie.name + '=' + cookie.value;
+    }).join('; ');
+};
+
+/**
+ * Lists all valied cookie objects for the specified URL
+ *
+ * @param {String} url URL to check for
+ * @returns {Array} An array of cookie objects
+ */
+Cookies.prototype.list = function (url) {
+    var result = [];
+    var i;
+    var cookie;
+
+    for (i = this.cookies.length - 1; i >= 0; i--) {
+        cookie = this.cookies[i];
+
+        if (this.isExpired(cookie)) {
+            this.cookies.splice(i, i);
+            continue;
+        }
+
+        if (this.match(cookie, url)) {
+            result.unshift(cookie);
+        }
+    }
+
+    return result;
+};
+
+/**
+ * Parses cookie string from the 'Set-Cookie:' header
+ *
+ * @param {String} cookieStr String from the 'Set-Cookie:' header
+ * @returns {Object} Cookie object
+ */
+Cookies.prototype.parse = function (cookieStr) {
+    var cookie = {};
+
+    (cookieStr || '').toString().split(';').forEach(function (cookiePart) {
+        var valueParts = cookiePart.split('=');
+        var key = valueParts.shift().trim().toLowerCase();
+        var value = valueParts.join('=').trim();
+        var domain;
+
+        if (!key) {
+            // skip empty parts
+            return;
+        }
+
+        switch (key) {
+
+            case 'expires':
+                value = new Date(value);
+                // ignore date if can not parse it
+                if (value.toString() !== 'Invalid Date') {
+                    cookie.expires = value;
+                }
+                break;
+
+            case 'path':
+                cookie.path = value;
+                break;
+
+            case 'domain':
+                domain = value.toLowerCase();
+                if (domain.length && domain.charAt(0) !== '.') {
+                    domain = '.' + domain; // ensure preceeding dot for user set domains
+                }
+                cookie.domain = domain;
+                break;
+
+            case 'max-age':
+                cookie.expires = new Date(Date.now() + (Number(value) || 0) * 1000);
+                break;
+
+            case 'secure':
+                cookie.secure = true;
+                break;
+
+            case 'httponly':
+                cookie.httponly = true;
+                break;
+
+            default:
+                if (!cookie.name) {
+                    cookie.name = key;
+                    cookie.value = value;
+                }
+        }
+    });
+
+    return cookie;
+};
+
+/**
+ * Checks if a cookie object is valid for a specified URL
+ *
+ * @param {Object} cookie Cookie object
+ * @param {String} url URL to check for
+ * @returns {Boolean} true if cookie is valid for specifiec URL
+ */
+Cookies.prototype.match = function (cookie, url) {
+    var urlparts = urllib.parse(url || '');
+
+    // check if hostname matches
+    // .foo.com also matches subdomains, foo.com does not
+    if (urlparts.hostname !== cookie.domain && (cookie.domain.charAt(0) !== '.' || ('.' + urlparts.hostname).substr(-cookie.domain.length) !== cookie.domain)) {
+        return false;
+    }
+
+    // check if path matches
+    var path = this.getPath(urlparts.pathname);
+    if (path.substr(0, cookie.path.length) !== cookie.path) {
+        return false;
+    }
+
+    // check secure argument
+    if (cookie.secure && urlparts.protocol !== 'https:') {
+        return false;
+    }
+
+    return true;
+};
+
+/**
+ * Adds (or updates/removes if needed) a cookie object to the cookie storage
+ *
+ * @param {Object} cookie Cookie value to be stored
+ */
+Cookies.prototype.add = function (cookie) {
+    var i;
+    var len;
+
+    // nothing to do here
+    if (!cookie || !cookie.name) {
+        return false;
+    }
+
+    // overwrite if has same params
+    for (i = 0, len = this.cookies.length; i < len; i++) {
+        if (this.compare(this.cookies[i], cookie)) {
+
+            // check if the cookie needs to be removed instead
+            if (this.isExpired(cookie)) {
+                this.cookies.splice(i, 1); // remove expired/unset cookie
+                return false;
+            }
+
+            this.cookies[i] = cookie;
+            return true;
+        }
+    }
+
+    // add as new if not already expired
+    if (!this.isExpired(cookie)) {
+        this.cookies.push(cookie);
+    }
+
+    return true;
+};
+
+/**
+ * Checks if two cookie objects are the same
+ *
+ * @param {Object} a Cookie to check against
+ * @param {Object} b Cookie to check against
+ * @returns {Boolean} True, if the cookies are the same
+ */
+Cookies.prototype.compare = function (a, b) {
+    return a.name === b.name && a.path === b.path && a.domain === b.domain && a.secure === b.secure && a.httponly === a.httponly;
+};
+
+/**
+ * Checks if a cookie is expired
+ *
+ * @param {Object} cookie Cookie object to check against
+ * @returns {Boolean} True, if the cookie is expired
+ */
+Cookies.prototype.isExpired = function (cookie) {
+    return (cookie.expires && cookie.expires < new Date()) || !cookie.value;
+};
+
+/**
+ * Returns normalized cookie path for an URL path argument
+ *
+ * @param {String} pathname
+ * @returns {String} Normalized path
+ */
+Cookies.prototype.getPath = function (pathname) {
+    var path = (pathname || '/').split('/');
+    path.pop(); // remove filename part
+    path = path.join('/').trim();
+
+    // ensure path prefix /
+    if (path.charAt(0) !== '/') {
+        path = '/' + path;
+    }
+
+    // ensure path suffix /
+    if (path.substr(-1) !== '/') {
+        path += '/';
+    }
+
+    return path;
+};

package/Laba6/node_modules/nodemailer-fetch/lib/fetch.js

@@ -0,0 +1,224 @@
+'use strict';
+
+var http = require('http');
+var https = require('https');
+var urllib = require('url');
+var zlib = require('zlib');
+var PassThrough = require('stream').PassThrough;
+var Cookies = require('./cookies');
+
+var MAX_REDIRECTS = 5;
+
+module.exports = function (url, options) {
+    return fetch(url, options);
+};
+
+module.exports.Cookies = Cookies;
+
+function fetch(url, options) {
+    options = options || {};
+
+    options.fetchRes = options.fetchRes || new PassThrough();
+    options.cookies = options.cookies || new Cookies();
+    options.redirects = options.redirects || 0;
+    options.maxRedirects = isNaN(options.maxRedirects) ? MAX_REDIRECTS : options.maxRedirects;
+
+    if (options.cookie) {
+        [].concat(options.cookie || []).forEach(function (cookie) {
+            options.cookies.set(cookie, url);
+        });
+        options.cookie = false;
+    }
+
+    var fetchRes = options.fetchRes;
+    var parsed = urllib.parse(url);
+    var method = (options.method || '').toString().trim().toUpperCase() || 'GET';
+    var finished = false;
+    var cookies;
+    var body;
+
+    var handler = parsed.protocol === 'https:' ? https : http;
+
+    var headers = {
+        'accept-encoding': 'gzip,deflate'
+    };
+
+    Object.keys(options.headers || {}).forEach(function (key) {
+        headers[key.toLowerCase().trim()] = options.headers[key];
+    });
+
+    if (options.userAgent) {
+        headers['User-Agent'] = options.userAgent;
+    }
+
+    if (parsed.auth) {
+        headers.Authorization = 'Basic ' + new Buffer(parsed.auth).toString('base64');
+    }
+
+    if ((cookies = options.cookies.get(url))) {
+        headers.cookie = cookies;
+    }
+
+    if (options.body) {
+        if (options.contentType !== false) {
+            headers['Content-Type'] = options.contentType || 'application/x-www-form-urlencoded';
+        }
+
+        if (typeof options.body.pipe === 'function') {
+            // it's a stream
+            headers['Transfer-Encoding'] = 'chunked';
+            body = options.body;
+            body.on('error', function (err) {
+                if (finished) {
+                    return;
+                }
+                finished = true;
+                fetchRes.emit('error', err);
+            });
+        } else {
+            if (options.body instanceof Buffer) {
+                body = options.body;
+            } else if (typeof options.body === 'object') {
+                body = new Buffer(Object.keys(options.body).map(function (key) {
+                    var value = options.body[key].toString().trim();
+                    return encodeURIComponent(key) + '=' + encodeURIComponent(value);
+                }).join('&'));
+            } else {
+                body = new Buffer(options.body.toString().trim());
+            }
+
+            headers['Content-Type'] = options.contentType || 'application/x-www-form-urlencoded';
+            headers['Content-Length'] = body.length;
+        }
+        // if method is not provided, use POST instead of GET
+        method = (options.method || '').toString().trim().toUpperCase() || 'POST';
+    }
+
+    var req;
+    var reqOptions = {
+        method: method,
+        host: parsed.hostname,
+        path: parsed.path,
+        port: parsed.port ? parsed.port : (parsed.protocol === 'https:' ? 443 : 80),
+        headers: headers,
+        rejectUnauthorized: false,
+        agent: false
+    };
+
+    if (options.tls) {
+        Object.keys(options.tls).forEach(function (key) {
+            reqOptions[key] = options.tls[key];
+        });
+    }
+
+    try {
+        req = handler.request(reqOptions);
+    } catch (E) {
+        finished = true;
+        setImmediate(function () {
+            fetchRes.emit('error', E);
+        });
+        return fetchRes;
+    }
+
+    if (options.timeout) {
+        req.setTimeout(options.timeout, function () {
+            if (finished) {
+                return;
+            }
+            finished = true;
+            req.abort();
+            fetchRes.emit('error', new Error('Request Tiemout'));
+        });
+    }
+
+    req.on('error', function (err) {
+        if (finished) {
+            return;
+        }
+        finished = true;
+        fetchRes.emit('error', err);
+    });
+
+    req.on('response', function (res) {
+        var inflate;
+
+        if (finished) {
+            return;
+        }
+
+        switch (res.headers['content-encoding']) {
+            case 'gzip':
+            case 'deflate':
+                inflate = zlib.createUnzip();
+                break;
+        }
+
+        if (res.headers['set-cookie']) {
+            [].concat(res.headers['set-cookie'] || []).forEach(function (cookie) {
+                options.cookies.set(cookie, url);
+            });
+        }
+
+        if ([301, 302, 303, 307, 308].indexOf(res.statusCode) >= 0 && res.headers.location) {
+            // redirect
+            options.redirects++;
+            if (options.redirects > options.maxRedirects) {
+                finished = true;
+                fetchRes.emit('error', new Error('Maximum redirect count exceeded'));
+                req.abort();
+                return;
+            }
+            return fetch(urllib.resolve(url, res.headers.location), options);
+        }
+
+        if (res.statusCode >= 300) {
+            finished = true;
+            fetchRes.emit('error', new Error('Invalid status code ' + res.statusCode));
+            req.abort();
+            return;
+        }
+
+        res.on('error', function (err) {
+            if (finished) {
+                return;
+            }
+            finished = true;
+            fetchRes.emit('error', err);
+            req.abort();
+        });
+
+        if (inflate) {
+            res.pipe(inflate).pipe(fetchRes);
+            inflate.on('error', function (err) {
+                if (finished) {
+                    return;
+                }
+                finished = true;
+                fetchRes.emit('error', err);
+                req.abort();
+            });
+        } else {
+            res.pipe(fetchRes);
+        }
+    });
+
+    setImmediate(function () {
+        if (body) {
+            try {
+                if (typeof body.pipe === 'function') {
+                    return body.pipe(req);
+                } else {
+                    req.write(body);
+                }
+            } catch (err) {
+                finished = true;
+                fetchRes.emit('error', err);
+                return;
+            }
+        }
+        req.end();
+    });
+
+    return fetchRes;
+}

package/Laba6/node_modules/nodemailer-fetch/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "nodemailer-fetch",
+    "version": "1.6.0",
+    "description": "GET HTTP contents",
+    "main": "lib/fetch.js",
+    "scripts": {
+        "test": "grunt mochaTest"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/nodemailer/nodemailer-fetch.git"
+    },
+    "keywords": [
+        "nodemailer",
+        "http"
+    ],
+    "devDependencies": {
+        "chai": "^3.5.0",
+        "grunt": "^1.0.1",
+        "grunt-eslint": "^19.0.0",
+        "grunt-mocha-test": "^0.12.7",
+        "mocha": "^3.0.2"
+    },
+    "author": "Andris Reinman",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/nodemailer/nodemailer-fetch/issues"
+    },
+    "homepage": "https://github.com/nodemailer/nodemailer-fetch#readme"
+}