youtube-downloader-by-ahmad 1.0.0

package/mime-types/index.js

@@ -0,0 +1,188 @@
+/*!
+ * mime-types
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+'use strict'
+
+/**
+ * Module dependencies.
+ * @private
+ */
+
+var db = require('mime-db')
+var extname = require('path').extname
+
+/**
+ * Module variables.
+ * @private
+ */
+
+var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/
+var TEXT_TYPE_REGEXP = /^text\//i
+
+/**
+ * Module exports.
+ * @public
+ */
+
+exports.charset = charset
+exports.charsets = { lookup: charset }
+exports.contentType = contentType
+exports.extension = extension
+exports.extensions = Object.create(null)
+exports.lookup = lookup
+exports.types = Object.create(null)
+
+// Populate the extensions/types maps
+populateMaps(exports.extensions, exports.types)
+
+/**
+ * Get the default charset for a MIME type.
+ *
+ * @param {string} type
+ * @return {boolean|string}
+ */
+
+function charset (type) {
+  if (!type || typeof type !== 'string') {
+    return false
+  }
+
+  // TODO: use media-typer
+  var match = EXTRACT_TYPE_REGEXP.exec(type)
+  var mime = match && db[match[1].toLowerCase()]
+
+  if (mime && mime.charset) {
+    return mime.charset
+  }
+
+  // default text/* to utf-8
+  if (match && TEXT_TYPE_REGEXP.test(match[1])) {
+    return 'UTF-8'
+  }
+
+  return false
+}
+
+/**
+ * Create a full Content-Type header given a MIME type or extension.
+ *
+ * @param {string} str
+ * @return {boolean|string}
+ */
+
+function contentType (str) {
+  // TODO: should this even be in this module?
+  if (!str || typeof str !== 'string') {
+    return false
+  }
+
+  var mime = str.indexOf('/') === -1
+    ? exports.lookup(str)
+    : str
+
+  if (!mime) {
+    return false
+  }
+
+  // TODO: use content-type or other module
+  if (mime.indexOf('charset') === -1) {
+    var charset = exports.charset(mime)
+    if (charset) mime += '; charset=' + charset.toLowerCase()
+  }
+
+  return mime
+}
+
+/**
+ * Get the default extension for a MIME type.
+ *
+ * @param {string} type
+ * @return {boolean|string}
+ */
+
+function extension (type) {
+  if (!type || typeof type !== 'string') {
+    return false
+  }
+
+  // TODO: use media-typer
+  var match = EXTRACT_TYPE_REGEXP.exec(type)
+
+  // get extensions
+  var exts = match && exports.extensions[match[1].toLowerCase()]
+
+  if (!exts || !exts.length) {
+    return false
+  }
+
+  return exts[0]
+}
+
+/**
+ * Lookup the MIME type for a file path/extension.
+ *
+ * @param {string} path
+ * @return {boolean|string}
+ */
+
+function lookup (path) {
+  if (!path || typeof path !== 'string') {
+    return false
+  }
+
+  // get the extension ("ext" or ".ext" or full path)
+  var extension = extname('x.' + path)
+    .toLowerCase()
+    .substr(1)
+
+  if (!extension) {
+    return false
+  }
+
+  return exports.types[extension] || false
+}
+
+/**
+ * Populate the extensions and types maps.
+ * @private
+ */
+
+function populateMaps (extensions, types) {
+  // source preference (least -> most)
+  var preference = ['nginx', 'apache', undefined, 'iana']
+
+  Object.keys(db).forEach(function forEachMimeType (type) {
+    var mime = db[type]
+    var exts = mime.extensions
+
+    if (!exts || !exts.length) {
+      return
+    }
+
+    // mime -> extensions
+    extensions[type] = exts
+
+    // extension -> mime
+    for (var i = 0; i < exts.length; i++) {
+      var extension = exts[i]
+
+      if (types[extension]) {
+        var from = preference.indexOf(db[types[extension]].source)
+        var to = preference.indexOf(mime.source)
+
+        if (types[extension] !== 'application/octet-stream' &&
+          (from > to || (from === to && types[extension].substr(0, 12) === 'application/'))) {
+          // skip the remapping
+          continue
+        }
+      }
+
+      // set the extension -> mime
+      types[extension] = type
+    }
+  })
+}

package/mime-types/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "mime-types",
+  "description": "The ultimate javascript content-type utility.",
+  "version": "2.1.35",
+  "contributors": [
+    "Douglas Christopher Wilson <doug@somethingdoug.com>",
+    "Jeremiah Senkpiel <fishrock123@rocketmail.com> (https://searchbeam.jit.su)",
+    "Jonathan Ong <me@jongleberry.com> (http://jongleberry.com)"
+  ],
+  "license": "MIT",
+  "keywords": [
+    "mime",
+    "types"
+  ],
+  "repository": "jshttp/mime-types",
+  "dependencies": {
+    "mime-db": "1.52.0"
+  },
+  "devDependencies": {
+    
+  },
+  "files": [
+    "HISTORY.md",
+    "LICENSE",
+    "index.js"
+  ],
+  "engines": {
+    "node": ">= 0.6"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "test": "mocha --reporter spec test/test.js",
+    "test-ci": "nyc --reporter=lcov --reporter=text npm test",
+    "test-cov": "nyc --reporter=html --reporter=text npm test"
+  }
+}

package/miniget/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (C) 2017 by fent
+
+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/miniget/README.md

@@ -0,0 +1,111 @@
+# node-miniget
+
+A small http(s) GET library with redirects, retries, reconnects, concatenating or streaming, and no dependencies. This keeps filesize small for potential browser use.
+
+![Depfu](https://img.shields.io/depfu/fent/node-miniget)
+[![codecov](https://codecov.io/gh/fent/node-miniget/branch/master/graph/badge.svg)](https://codecov.io/gh/fent/node-miniget)
+
+
+# Usage
+
+Concatenates a response
+
+```js
+const miniget = require('miniget');
+
+miniget('http://mywebsite.com', (err, res, body) => {
+  console.log('webpage contents: ', body);
+});
+
+// with await
+let body = await miniget('http://yourwebsite.com').text();
+```
+
+Request can be streamed right away
+
+```js
+miniget('http://api.mywebsite.com/v1/messages.json')
+  .pipe(someWritableStream());
+```
+
+
+# API
+
+### miniget(url, [options])
+
+Makes a GET request. `url` can be a string or a `URL` object. `options` can have any properties from the [`http.request()` function](https://nodejs.org/api/http.html#http_http_request_options_callback), in addition to
+
+* `maxRedirects` - Default is `10`.
+* `maxRetries` - Number of times to retry the request if there is a 500 or connection error. Default is `2`.
+* `maxReconnects` - During a big download, if there is a disconnect, miniget can try to reconnect and continue the download where it left off. Default is `0`.
+* `backoff` - An object with `inc` and `max` used to calculate how long to wait to retry a request. Default is `{ inc: 100, max: 10000 }`.
+* `highWaterMark` - Amount of data to buffer when in stream mode.
+* `transform` - Use this to add additional features. Called with the object that `http.get()` or `https.get()` would be called with. Must return a transformed object.
+* `acceptEncoding` - An object with encoding name as the key, and the value as a function that returns a decoding stream.
+  ```js
+  acceptEncoding: { gzip: () => require('zlip').createGunzip(stream) }
+  ```
+  Given encodings will be added to the `Accept-Encoding` header, and the response will be decoded if the server responds with encoded content.
+
+Defaults are held in `miniget.defaultOptions` and can be adjusted globally.
+
+Miniget returns a readable stream, errors will then be emitted on the stream. Returned stream has additional methods added, and can emit the following events.
+
+### Stream#destroy([error])
+
+Destroys the request.
+
+### Stream#destroyed
+
+Set to `true` after `Stream#destroy()` has been called.
+
+### Stream#text()
+
+Returns a promise that resolves to the concatenated contents of the response.
+
+```js
+let body = await miniget('http://yourwebsite.com').text();
+```
+
+#### Event: redirect
+* `string` - URL redirected to.
+
+Emitted when the request was redirected with a redirection status code.
+
+#### Event: retry
+* `number` - Number of retry.
+* `Error` - Request or status code error.
+
+Emitted when the request fails, or the response has a status code >= 500.
+
+#### Event: reconnect
+* `number` - Number of reconnect.
+* `Error` - Request or response error.
+
+Emitted when the request or response fails after download has started.
+
+#### Event: request
+* [`http.ClientRequest`](https://nodejs.org/api/http.html#http_class_http_clientrequest) - Request.
+
+Emitted when a video request is made, including after any redirects, retries, and reconnects.
+
+#### Event: response
+* [`http.ServerResponse`](https://nodejs.org/api/http.html#http_class_http_serverresponse) - Response.
+
+Emitted when a video response has been found and has started downloading, including after any successful reconnects.
+
+#### Forwarded events
+
+Any events emitted from the [request](https://nodejs.org/api/http.html#http_class_http_clientrequest) or [response](https://nodejs.org/api/http.html#http_class_http_serverresponse) objects will be forwarded to the miniget stream.
+
+# Install
+
+    npm install miniget
+
+
+# Tests
+Tests are written with [mocha](https://mochajs.org)
+
+```bash
+npm test
+```

package/miniget/dist/index.d.ts

@@ -0,0 +1,65 @@
+/// <reference types="node" />
+import { RequestOptions } from 'http';
+import { PassThrough, Transform } from 'stream';
+declare namespace Miniget {
+    interface Options extends RequestOptions {
+        maxRedirects?: number;
+        maxRetries?: number;
+        maxReconnects?: number;
+        backoff?: {
+            inc: number;
+            max: number;
+        };
+        highWaterMark?: number;
+        transform?: (parsedUrl: RequestOptions) => RequestOptions;
+        acceptEncoding?: {
+            [key: string]: () => Transform;
+        };
+    }
+    interface DefaultOptions extends Options {
+        maxRedirects: number;
+        maxRetries: number;
+        maxReconnects: number;
+        backoff: {
+            inc: number;
+            max: number;
+        };
+    }
+    type defaultOptions = Miniget.Options;
+    type MinigetError = Error;
+    interface Stream extends PassThrough {
+        abort: (err?: Error) => void;
+        aborted: boolean;
+        destroy: (err?: Error) => this;
+        destroyed: boolean;
+        text: () => Promise<string>;
+        on(event: 'reconnect', listener: (attempt: number, err?: Miniget.MinigetError) => void): this;
+        on(event: 'retry', listener: (attempt: number, err?: Miniget.MinigetError) => void): this;
+        on(event: 'redirect', listener: (url: string) => void): this;
+        on(event: string | symbol, listener: (...args: any) => void): this;
+    }
+}
+declare function Miniget(url: string | URL, options?: Miniget.Options): Miniget.Stream;
+declare namespace Miniget {
+    var defaultOptions: {
+        maxRedirects: number;
+        maxRetries: number;
+        maxReconnects: number;
+        backoff: {
+            inc: number;
+            max: number;
+        };
+    };
+    var MinigetError: {
+        new (message: string, statusCode?: number | undefined): {
+            statusCode?: number | undefined;
+            name: string;
+            message: string;
+            stack?: string | undefined;
+        };
+        captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
+        prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+        stackTraceLimit: number;
+    };
+}
+export = Miniget;

package/miniget/dist/index.js

@@ -0,0 +1,281 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const stream_1 = require("stream");
+const httpLibs = { 'http:': http_1.default, 'https:': https_1.default };
+const redirectStatusCodes = new Set([301, 302, 303, 307, 308]);
+const retryStatusCodes = new Set([429, 503]);
+// `request`, `response`, `abort`, left out, miniget will emit these.
+const requestEvents = ['connect', 'continue', 'information', 'socket', 'timeout', 'upgrade'];
+const responseEvents = ['aborted'];
+Miniget.MinigetError = class MinigetError extends Error {
+    constructor(message, statusCode) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+};
+Miniget.defaultOptions = {
+    maxRedirects: 10,
+    maxRetries: 2,
+    maxReconnects: 0,
+    backoff: { inc: 100, max: 10000 },
+};
+function Miniget(url, options = {}) {
+    var _a;
+    const opts = Object.assign({}, Miniget.defaultOptions, options);
+    const stream = new stream_1.PassThrough({ highWaterMark: opts.highWaterMark });
+    stream.destroyed = stream.aborted = false;
+    let activeRequest;
+    let activeResponse;
+    let activeDecodedStream;
+    let redirects = 0;
+    let retries = 0;
+    let retryTimeout;
+    let reconnects = 0;
+    let contentLength;
+    let acceptRanges = false;
+    let rangeStart = 0, rangeEnd;
+    let downloaded = 0;
+    // Check if this is a ranged request.
+    if ((_a = opts.headers) === null || _a === void 0 ? void 0 : _a.Range) {
+        let r = /bytes=(\d+)-(\d+)?/.exec(`${opts.headers.Range}`);
+        if (r) {
+            rangeStart = parseInt(r[1], 10);
+            rangeEnd = parseInt(r[2], 10);
+        }
+    }
+    // Add `Accept-Encoding` header.
+    if (opts.acceptEncoding) {
+        opts.headers = Object.assign({
+            'Accept-Encoding': Object.keys(opts.acceptEncoding).join(', '),
+        }, opts.headers);
+    }
+    const downloadHasStarted = () => activeDecodedStream && downloaded > 0;
+    const downloadComplete = () => !acceptRanges || downloaded === contentLength;
+    const reconnect = (err) => {
+        activeDecodedStream = null;
+        retries = 0;
+        let inc = opts.backoff.inc;
+        let ms = Math.min(inc, opts.backoff.max);
+        retryTimeout = setTimeout(doDownload, ms);
+        stream.emit('reconnect', reconnects, err);
+    };
+    const reconnectIfEndedEarly = (err) => {
+        if (options.method !== 'HEAD' && !downloadComplete() && reconnects++ < opts.maxReconnects) {
+            reconnect(err);
+            return true;
+        }
+        return false;
+    };
+    const retryRequest = (retryOptions) => {
+        if (stream.destroyed) {
+            return false;
+        }
+        if (downloadHasStarted()) {
+            return reconnectIfEndedEarly(retryOptions.err);
+        }
+        else if ((!retryOptions.err || retryOptions.err.message === 'ENOTFOUND') &&
+            retries++ < opts.maxRetries) {
+            let ms = retryOptions.retryAfter ||
+                Math.min(retries * opts.backoff.inc, opts.backoff.max);
+            retryTimeout = setTimeout(doDownload, ms);
+            stream.emit('retry', retries, retryOptions.err);
+            return true;
+        }
+        return false;
+    };
+    const forwardEvents = (ee, events) => {
+        for (let event of events) {
+            ee.on(event, stream.emit.bind(stream, event));
+        }
+    };
+    const doDownload = () => {
+        let parsed = {}, httpLib;
+        try {
+            let urlObj = typeof url === 'string' ? new URL(url) : url;
+            parsed = Object.assign({}, {
+                host: urlObj.host,
+                hostname: urlObj.hostname,
+                path: urlObj.pathname + urlObj.search + urlObj.hash,
+                port: urlObj.port,
+                protocol: urlObj.protocol,
+            });
+            if (urlObj.username) {
+                parsed.auth = `${urlObj.username}:${urlObj.password}`;
+            }
+            httpLib = httpLibs[String(parsed.protocol)];
+        }
+        catch (err) {
+            // Let the error be caught by the if statement below.
+        }
+        if (!httpLib) {
+            stream.emit('error', new Miniget.MinigetError(`Invalid URL: ${url}`));
+            return;
+        }
+        Object.assign(parsed, opts);
+        if (acceptRanges && downloaded > 0) {
+            let start = downloaded + rangeStart;
+            let end = rangeEnd || '';
+            parsed.headers = Object.assign({}, parsed.headers, {
+                Range: `bytes=${start}-${end}`,
+            });
+        }
+        if (opts.transform) {
+            try {
+                parsed = opts.transform(parsed);
+            }
+            catch (err) {
+                stream.emit('error', err);
+                return;
+            }
+            if (!parsed || parsed.protocol) {
+                httpLib = httpLibs[String(parsed === null || parsed === void 0 ? void 0 : parsed.protocol)];
+                if (!httpLib) {
+                    stream.emit('error', new Miniget.MinigetError('Invalid URL object from `transform` function'));
+                    return;
+                }
+            }
+        }
+        const onError = (err) => {
+            if (stream.destroyed || stream.readableEnded) {
+                return;
+            }
+            cleanup();
+            if (!retryRequest({ err })) {
+                stream.emit('error', err);
+            }
+            else {
+                activeRequest.removeListener('close', onRequestClose);
+            }
+        };
+        const onRequestClose = () => {
+            cleanup();
+            retryRequest({});
+        };
+        const cleanup = () => {
+            activeRequest.removeListener('close', onRequestClose);
+            activeResponse === null || activeResponse === void 0 ? void 0 : activeResponse.removeListener('data', onData);
+            activeDecodedStream === null || activeDecodedStream === void 0 ? void 0 : activeDecodedStream.removeListener('end', onEnd);
+        };
+        const onData = (chunk) => { downloaded += chunk.length; };
+        const onEnd = () => {
+            cleanup();
+            if (!reconnectIfEndedEarly()) {
+                stream.end();
+            }
+        };
+        activeRequest = httpLib.request(parsed, (res) => {
+            // Needed for node v10, v12.
+            // istanbul ignore next
+            if (stream.destroyed) {
+                return;
+            }
+            if (redirectStatusCodes.has(res.statusCode)) {
+                if (redirects++ >= opts.maxRedirects) {
+                    stream.emit('error', new Miniget.MinigetError('Too many redirects'));
+                }
+                else {
+                    if (res.headers.location) {
+                        url = res.headers.location;
+                    }
+                    else {
+                        let err = new Miniget.MinigetError('Redirect status code given with no location', res.statusCode);
+                        stream.emit('error', err);
+                        cleanup();
+                        return;
+                    }
+                    setTimeout(doDownload, parseInt(res.headers['retry-after'] || '0', 10) * 1000);
+                    stream.emit('redirect', url);
+                }
+                cleanup();
+                return;
+                // Check for rate limiting.
+            }
+            else if (retryStatusCodes.has(res.statusCode)) {
+                if (!retryRequest({ retryAfter: parseInt(res.headers['retry-after'] || '0', 10) })) {
+                    let err = new Miniget.MinigetError(`Status code: ${res.statusCode}`, res.statusCode);
+                    stream.emit('error', err);
+                }
+                cleanup();
+                return;
+            }
+            else if (res.statusCode && (res.statusCode < 200 || res.statusCode >= 400)) {
+                let err = new Miniget.MinigetError(`Status code: ${res.statusCode}`, res.statusCode);
+                if (res.statusCode >= 500) {
+                    onError(err);
+                }
+                else {
+                    stream.emit('error', err);
+                }
+                cleanup();
+                return;
+            }
+            activeDecodedStream = res;
+            if (opts.acceptEncoding && res.headers['content-encoding']) {
+                for (let enc of res.headers['content-encoding'].split(', ').reverse()) {
+                    let fn = opts.acceptEncoding[enc];
+                    if (fn) {
+                        activeDecodedStream = activeDecodedStream.pipe(fn());
+                        activeDecodedStream.on('error', onError);
+                    }
+                }
+            }
+            if (!contentLength) {
+                contentLength = parseInt(`${res.headers['content-length']}`, 10);
+                acceptRanges = res.headers['accept-ranges'] === 'bytes' &&
+                    contentLength > 0 && opts.maxReconnects > 0;
+            }
+            res.on('data', onData);
+            activeDecodedStream.on('end', onEnd);
+            activeDecodedStream.pipe(stream, { end: !acceptRanges });
+            activeResponse = res;
+            stream.emit('response', res);
+            res.on('error', onError);
+            forwardEvents(res, responseEvents);
+        });
+        activeRequest.on('error', onError);
+        activeRequest.on('close', onRequestClose);
+        forwardEvents(activeRequest, requestEvents);
+        if (stream.destroyed) {
+            streamDestroy(...destroyArgs);
+        }
+        stream.emit('request', activeRequest);
+        activeRequest.end();
+    };
+    stream.abort = (err) => {
+        console.warn('`MinigetStream#abort()` has been deprecated in favor of `MinigetStream#destroy()`');
+        stream.aborted = true;
+        stream.emit('abort');
+        stream.destroy(err);
+    };
+    let destroyArgs;
+    const streamDestroy = (err) => {
+        activeRequest.destroy(err);
+        activeDecodedStream === null || activeDecodedStream === void 0 ? void 0 : activeDecodedStream.unpipe(stream);
+        activeDecodedStream === null || activeDecodedStream === void 0 ? void 0 : activeDecodedStream.destroy();
+        clearTimeout(retryTimeout);
+    };
+    stream._destroy = (...args) => {
+        stream.destroyed = true;
+        if (activeRequest) {
+            streamDestroy(...args);
+        }
+        else {
+            destroyArgs = args;
+        }
+    };
+    stream.text = () => new Promise((resolve, reject) => {
+        let body = '';
+        stream.setEncoding('utf8');
+        stream.on('data', chunk => body += chunk);
+        stream.on('end', () => resolve(body));
+        stream.on('error', reject);
+    });
+    process.nextTick(doDownload);
+    return stream;
+}
+module.exports = Miniget;
+//# sourceMappingURL=index.js.map