mwoffliner 1.14.2 → 1.15.0

package/lib/Downloader.js

@@ -1,11 +1,11 @@
 import * as backoff from 'backoff';
 import { config } from './config.js';
-import { contains } from './util/index.js';
+import { contains, normalizeMwResponse, DB_ERROR, WEAK_ETAG_REGEX, stripHttpFromUrl, isBitmapImageMimeType, isWebpCandidateImageMimeType } from './util/index.js';
 import deepmerge from 'deepmerge';
 import * as domino from 'domino';
 import { default as imagemin } from 'imagemin';
 import imageminAdvPng from 'imagemin-advpng';
-import axios from 'axios';
+import axios, { AxiosError } from 'axios';
 import { default as imageminPngquant } from 'imagemin-pngquant';
 import imageminGifsicle from 'imagemin-gifsicle';
 import imageminJpegoptim from 'imagemin-jpegoptim';
@@ -14,11 +14,12 @@ import sharp from 'sharp';
 import http from 'http';
 import https from 'https';
 import { fileTypeFromBuffer } from 'file-type';
-import { normalizeMwResponse, DB_ERROR, WEAK_ETAG_REGEX, stripHttpFromUrl, isBitmapImageMimeType, isWebpCandidateImageMimeType } from './util/index.js';
 import * as logger from './Logger.js';
 import MediaWiki from './MediaWiki.js';
 import ApiURLDirector from './util/builders/url/api.director.js';
 import urlHelper from './util/url.helper.js';
+import { findFirstMatchingRule, renderDownloadError } from './error.manager.js';
+import RedisStore from './RedisStore.js';
 const imageminOptions = new Map();
 imageminOptions.set('default', new Map());
 imageminOptions.set('webp', new Map());
@@ -37,19 +38,44 @@ imageminOptions.get('webp').set('image/png', {
 imageminOptions.get('webp').set('image/jpeg', {
     plugins: [imageminWebp({ quality: 50, method: 6 })],
 });
+export class DownloadError extends Error {
+    urlCalled;
+    httpReturnCode;
+    responseContentType;
+    responseData;
+    constructor(message, urlCalled, httpReturnCode, responseContentType, responseData) {
+        super(message);
+        this.name = 'DownloadError';
+        this.urlCalled = urlCalled;
+        this.httpReturnCode = httpReturnCode;
+        this.responseContentType = responseContentType;
+        this.responseData = responseData;
+        if ('captureStackTrace' in Error) {
+            // Avoid DownloadError itself in the stack trace
+            Error.captureStackTrace(this, DownloadError);
+        }
+    }
+}
 /**
  * Downloader is a class providing content retrieval functionalities for both Mediawiki and S3 remote instances.
  */
 class Downloader {
+    static instance;
+    static getInstance() {
+        if (!Downloader.instance) {
+            Downloader.instance = new Downloader();
+        }
+        return Downloader.instance;
+    }
     loginCookie = '';
-    speed;
+    _speed;
     cssDependenceUrls = {};
-    webp = false;
-    requestTimeout;
-    basicRequestOptions;
-    arrayBufferRequestOptions;
-    jsonRequestOptions;
-    streamRequestOptions;
+    _webp = false;
+    _requestTimeout;
+    _basicRequestOptions;
+    _arrayBufferRequestOptions;
+    _jsonRequestOptions;
+    _streamRequestOptions;
     wikimediaMobileJsDependenciesList = [];
     wikimediaMobileStyleDependenciesList = [];
     uaString;
@@ -62,30 +88,75 @@ class Downloader {
     articleUrlDirector;
     mainPageUrlDirector;
     insecure = false;
-    constructor({ uaString, speed, reqTimeout, optimisationCacheUrl, s3, webp, backoffOptions, insecure }) {
+    get speed() {
+        return this._speed;
+    }
+    get webp() {
+        return this._webp;
+    }
+    get requestTimeout() {
+        return this._requestTimeout;
+    }
+    get basicRequestOptions() {
+        return this._basicRequestOptions;
+    }
+    get arrayBufferRequestOptions() {
+        return this._arrayBufferRequestOptions;
+    }
+    get jsonRequestOptions() {
+        return this._jsonRequestOptions;
+    }
+    get streamRequestOptions() {
+        return this._streamRequestOptions;
+    }
+    set init({ uaString, speed, reqTimeout, optimisationCacheUrl, s3, webp, backoffOptions, insecure }) {
+        this.reset();
         this.uaString = uaString;
-        this.speed = speed;
+        this._speed = speed;
         this.maxActiveRequests = speed * 10;
-        this.requestTimeout = reqTimeout;
+        this._requestTimeout = reqTimeout;
         this.loginCookie = '';
         this.optimisationCacheUrl = optimisationCacheUrl;
-        this.webp = webp;
+        this._webp = webp;
         this.s3 = s3;
         this.apiUrlDirector = new ApiURLDirector(MediaWiki.actionApiUrl.href);
         this.insecure = insecure;
         this.backoffOptions = {
-            strategy: new backoff.ExponentialStrategy(),
-            failAfter: 7,
-            retryIf: (err) => err.code === 'ECONNABORTED' || ![400, 403, 404].includes(err.response?.status),
+            // retry up to 10 times, with a minimum of 1sec, maximum of 1min
+            // this means we retry for up to about 6 mins, which is supposed
+            // to be sufficient for backend to recover from transient errors
+            strategy: new backoff.ExponentialStrategy({ initialDelay: 1000, maxDelay: 60000 }),
+            failAfter: 10,
+            retryIf: (err) => {
+                const requestedUrl = err.urlCalled || err.config?.url || 'unknown';
+                if (err instanceof AxiosError && err.code && !['ERR_BAD_REQUEST', 'ERR_BAD_RESPONSE'].includes(err.code)) {
+                    logger.log(`Retrying ${requestedUrl} URL due to ${err.code} error`);
+                    return true; // retry all connection issues
+                }
+                const httpReturnCode = err.response?.status || err.httpReturnCode;
+                if ([429].includes(httpReturnCode)) {
+                    logger.log(`Retrying ${requestedUrl} URL due to HTTP ${httpReturnCode} error`);
+                    return true; // retry these HTTP status codes
+                }
+                if ([
+                    'internal_api_error_DBConnectionError',
+                    'internal_api_error_DBUnexpectedError',
+                    'internal_api_error_Wikibase\\DataModel\\Services\\Lookup\\EntityLookupException',
+                ].includes(err.responseData?.error?.code)) {
+                    logger.log(`Retrying ${requestedUrl} URL due to ${err.responseData?.error?.code} Mediawiki error`);
+                    return true; // retry these Mediawiki codes which are known to be transient
+                }
+                return false; // don't retry other errors
+            },
             backoffHandler: (number, delay) => {
                 logger.info(`[backoff] #${number} after ${delay} ms`);
             },
             ...backoffOptions,
         };
-        this.basicRequestOptions = {
+        this._basicRequestOptions = {
             // HTTP agent pools with 'keepAlive' to reuse TCP connections, so it's faster
             httpAgent: new http.Agent({ keepAlive: true }),
-            httpsAgent: new https.Agent({ keepAlive: true, rejectUnauthorized: !this.insecure }),
+            httpsAgent: new https.Agent({ keepAlive: true, rejectUnauthorized: !this.insecure }), // rejectUnauthorized: false disables TLS
             timeout: this.requestTimeout,
             headers: {
                 'cache-control': 'public, max-stale=86400',
@@ -95,12 +166,12 @@ class Downloader {
                 return (status >= 200 && status < 300) || status === 304;
             },
         };
-        this.arrayBufferRequestOptions = {
+        this._arrayBufferRequestOptions = {
             ...this.basicRequestOptions,
             responseType: 'arraybuffer',
             method: 'GET',
         };
-        this.jsonRequestOptions = {
+        this._jsonRequestOptions = {
             ...this.basicRequestOptions,
             headers: {
                 ...this.basicRequestOptions.headers,
@@ -110,7 +181,7 @@ class Downloader {
             responseType: 'json',
             method: 'GET',
         };
-        this.streamRequestOptions = {
+        this._streamRequestOptions = {
             ...this.basicRequestOptions,
             headers: {
                 ...this.basicRequestOptions.headers,
@@ -121,6 +192,30 @@ class Downloader {
             method: 'GET',
         };
     }
+    reset() {
+        this.uaString = undefined;
+        this._speed = undefined;
+        this.maxActiveRequests = undefined;
+        this._requestTimeout = undefined;
+        this.loginCookie = '';
+        this.optimisationCacheUrl = undefined;
+        this._webp = false;
+        this.s3 = undefined;
+        this.apiUrlDirector = undefined;
+        this.insecure = false;
+        this.backoffOptions = undefined;
+        this._basicRequestOptions = undefined;
+        this._arrayBufferRequestOptions = undefined;
+        this._jsonRequestOptions = undefined;
+        this._streamRequestOptions = undefined;
+        this.cssDependenceUrls = {};
+        this.wikimediaMobileJsDependenciesList = [];
+        this.wikimediaMobileStyleDependenciesList = [];
+        this.activeRequests = 0;
+        this.maxActiveRequests = 1;
+        this.articleUrlDirector = undefined;
+        this.mainPageUrlDirector = undefined;
+    }
     getUrlDirector(renderer) {
         switch (renderer.constructor.name) {
             case 'WikimediaDesktopRenderer':
@@ -131,15 +226,16 @@ class Downloader {
                 return MediaWiki.wikimediaMobileUrlDirector;
             case 'RestApiRenderer':
                 return MediaWiki.restApiUrlDirector;
+            case 'ActionParseRenderer':
+                return MediaWiki.actionParseUrlDirector;
+            /* istanbul ignore next */
+            default:
+                throw new Error(`Unknown renderer ${renderer.constructor.name}`);
         }
     }
     setUrlsDirectors(mainPageRenderer, articlesRenderer) {
-        if (!this.articleUrlDirector) {
-            this.articleUrlDirector = this.getUrlDirector(articlesRenderer);
-        }
-        if (!this.mainPageUrlDirector) {
-            this.mainPageUrlDirector = this.getUrlDirector(mainPageRenderer);
-        }
+        this.articleUrlDirector = this.getUrlDirector(articlesRenderer);
+        this.mainPageUrlDirector = this.getUrlDirector(mainPageRenderer);
     }
     getArticleUrl(articleId) {
         return this.articleUrlDirector.buildArticleURL(articleId);
@@ -160,14 +256,14 @@ class Downloader {
             const queryOpts = {
                 ...(await this.getArticleQueryOpts(shouldGetThumbnail, true)),
                 titles: articleIds.join('|'),
-                ...((await MediaWiki.hasCoordinates(this)) ? { colimit: 'max' } : {}),
+                ...((await MediaWiki.hasCoordinates()) ? { colimit: 'max' } : {}),
                 ...(MediaWiki.getCategories
                     ? {
                         cllimit: 'max',
                         clshow: '!hidden',
                     }
                     : {}),
-                ...(continuation || {}),
+                ...continuation,
             };
             const reqUrl = this.apiUrlDirector.buildQueryURL(queryOpts);
             const resp = await this.getJSON(reqUrl);
@@ -194,7 +290,7 @@ class Downloader {
         while (true) {
             const queryOpts = {
                 ...(await this.getArticleQueryOpts()),
-                ...((await MediaWiki.hasCoordinates(this)) ? { colimit: 'max' } : {}),
+                ...((await MediaWiki.hasCoordinates()) ? { colimit: 'max' } : {}),
                 ...(MediaWiki.getCategories
                     ? {
                         cllimit: 'max',
@@ -237,22 +333,103 @@ class Downloader {
             gapContinue: gCont,
         };
     }
-    async getArticle(webp, _moduleDependencies, articleId, articleDetailXId, articleRenderer, articleUrl, dump, articleDetail, isMainPage) {
+    async getLogEvents(letype, articleId) {
+        const logEventsData = await this.getJSON(this.apiUrlDirector.buildLogEventsQuery(letype, articleId));
+        return logEventsData.query?.logevents;
+    }
+    async getArticle(articleId, articleDetailXId, articleRenderer, articleUrl, dump, articleDetail, isMainPage) {
         logger.info(`Getting article [${articleId}] from ${articleUrl}`);
-        const data = await this.getJSON(articleUrl);
-        if (data.error) {
-            throw data.error;
+        try {
+            const { data, moduleDependencies, redirects } = await articleRenderer.download({
+                articleId,
+                articleUrl,
+                articleDetail,
+            });
+            // Cope with the fact that the page we are fetching might have been moved and replaced by a redirect
+            // In such a case, the download above is expected to follow the redirect so that we have proper original
+            // content at original article path, but we probably need to add a redirect since new article location
+            // probably did not existed when listing articles (might have existed if the move occured during article
+            // listing). The redirect we add in hence in the "opposite" direction than usual, i.e. it will redirect
+            // from new location to original location. Note that only ActionParse API gives proper redirects info.
+            for (const redirect of redirects) {
+                if (!(await RedisStore.articleDetailXId.exists(redirect.to)) && !(await RedisStore.redirectsXId.exists(redirect.to))) {
+                    RedisStore.redirectsXId.set(redirect.to, { targetId: redirect.from, title: redirect.to });
+                }
+            }
+            return await articleRenderer.render({
+                data,
+                moduleDependencies,
+                articleId,
+                articleDetailXId,
+                articleDetail,
+                isMainPage,
+                dump,
+            });
+        }
+        catch (err) {
+            let downloadErrorContext;
+            if (err instanceof AxiosError) {
+                downloadErrorContext = {
+                    errorCode: err.code,
+                    urlCalled: err.config.url,
+                    httpReturnCode: err.status,
+                    responseContentType: err.response ? err.response.headers['content-type'].toString() : null,
+                    responseData: err.response?.data,
+                };
+            }
+            else if (err instanceof DownloadError) {
+                downloadErrorContext = {
+                    errorCode: null,
+                    urlCalled: err.urlCalled,
+                    httpReturnCode: err.httpReturnCode,
+                    responseContentType: err.responseContentType,
+                    responseData: err.responseData,
+                };
+            }
+            if (!downloadErrorContext) {
+                throw err;
+            }
+            logger.warn(`Article ${articleId} failed to download from '${downloadErrorContext.urlCalled}' with ` +
+                `'${downloadErrorContext.errorCode}' error code, ` +
+                `'${downloadErrorContext.httpReturnCode}' HTTP return code ` +
+                `and '${downloadErrorContext.responseContentType}' content-type ` +
+                `returned instead:\n${JSON.stringify(downloadErrorContext.responseData)}`);
+            const errorRule = findFirstMatchingRule(downloadErrorContext);
+            if (errorRule === null) {
+                logger.error('This is a fatal download error, aborting');
+                throw err;
+            }
+            if (errorRule.isHardFailure) {
+                logger.log(`This is a hard ${errorRule.detailsMessageKey} error which will be replaced by a placeholder`);
+                dump.status.articles.hardFail += 1;
+                dump.status.articles.hardFailedArticleIds.push(articleId);
+                if (dump.maxHardFailedArticles > 0 && dump.status.articles.hardFail > dump.maxHardFailedArticles) {
+                    logger.error('Too many articles failed to download, aborting');
+                    throw err;
+                }
+            }
+            else {
+                logger.log(`This is a soft ${errorRule.detailsMessageKey} error which will be replaced by a placeholder`);
+                dump.status.articles.softFail += 1;
+                dump.status.articles.softFailedArticleIds.push(articleId);
+            }
+            RedisStore.articleDetailXId.delete(articleId); // Remove article from list so that we stop creating links to this placeholder
+            const articleTitle = articleId.replace(/_/g, ' ');
+            const errorPlaceholderHtml = renderDownloadError(errorRule, dump, articleId, articleTitle);
+            return [
+                {
+                    articleId,
+                    displayTitle: articleTitle,
+                    html: errorPlaceholderHtml,
+                    imageDependencies: [],
+                    videoDependencies: [],
+                    mediaDependencies: [],
+                    moduleDependencies: [],
+                    staticFiles: config.output.downloadErrorResources,
+                    subtitles: [],
+                },
+            ];
         }
-        return articleRenderer.render({
-            data,
-            webp,
-            _moduleDependencies,
-            articleId,
-            articleDetailXId,
-            articleDetail,
-            isMainPage,
-            dump,
-        });
     }
     async getJSON(_url) {
         const url = urlHelper.deserializeUrl(_url);
@@ -261,8 +438,8 @@ class Downloader {
             this.backoffCall(this.getJSONCb, url, 'json', (err, val) => {
                 this.releaseRequest();
                 if (err) {
-                    const httpStatus = err.response && err.response.status;
-                    logger.warn(`Failed to get [${url}] [status=${httpStatus}]`);
+                    const httpStatus = (err.response && err.response.status) || err.httpReturnCode;
+                    logger.info(`Failed to get [${url}] [status=${httpStatus}]`);
                     reject(err);
                 }
                 else {
@@ -297,7 +474,10 @@ class Downloader {
         if (!_url) {
             throw new Error(`Parameter [${_url}] is not a valid url`);
         }
-        const url = urlHelper.deserializeUrl(_url);
+        let url = urlHelper.deserializeUrl(_url);
+        if (url.startsWith('//')) {
+            url = `${MediaWiki.baseUrl.protocol}${url}`;
+        }
         await this.claimRequest();
         try {
             return new Promise((resolve, reject) => {
@@ -331,7 +511,7 @@ class Downloader {
             await this.request({ url, method: 'GET', ...this.arrayBufferRequestOptions });
             return true;
         }
-        catch (err) {
+        catch {
             return false;
         }
     }
@@ -345,7 +525,7 @@ class Downloader {
     }
     async getArticleQueryOpts(includePageimages = false, redirects = false) {
         const validNamespaceIds = MediaWiki.namespacesToMirror.map((ns) => MediaWiki.namespaces[ns].num);
-        const prop = `${includePageimages ? '|pageimages' : ''}${(await MediaWiki.hasCoordinates(this)) ? '|coordinates' : ''}${MediaWiki.getCategories ? '|categories' : ''}`;
+        const prop = `${includePageimages ? '|pageimages' : ''}${(await MediaWiki.hasCoordinates()) ? '|coordinates' : ''}${MediaWiki.getCategories ? '|categories' : ''}`;
         return {
             ...MediaWiki.queryOpts,
             prop: MediaWiki.queryOpts.prop.concat(prop),
@@ -384,25 +564,15 @@ class Downloader {
     getJSONCb = (url, kind, handler) => {
         logger.info(`Getting JSON from [${url}]`);
         this.request({ url, method: 'GET', ...this.jsonRequestOptions })
-            .then((a) => handler(null, a.data), handler)
-            .catch((err) => {
-            try {
-                if (err.response && err.response.status === 429) {
-                    logger.log('Received a [status=429], slowing down');
-                    const newMaxActiveRequests = Math.max(this.maxActiveRequests - 1, 1);
-                    logger.log(`Setting maxActiveRequests from [${this.maxActiveRequests}] to [${newMaxActiveRequests}]`);
-                    this.maxActiveRequests = newMaxActiveRequests;
-                    return this.getJSONCb(url, kind, handler);
-                }
-                else if (err.response && err.response.status === 404) {
-                    handler(err);
-                }
+            .then((val) => {
+            if (val.data.error) {
+                handler(new DownloadError(`Error returned while calling API`, url, val.status, val.headers['content-type'].toString(), val.data));
             }
-            catch (a) {
-                logger.log('ERR', err);
-                handler(err);
+            else {
+                handler(null, val.data);
             }
-        });
+        })
+            .catch((err) => handler(err));
     };
     async getImageMimeType(data) {
         const fileType = await fileTypeFromBuffer(data);
@@ -471,7 +641,7 @@ class Downloader {
             try {
                 this.errHandler(err, url, handler);
             }
-            catch (a) {
+            catch {
                 handler(err);
             }
         }
@@ -574,11 +744,6 @@ class Downloader {
     async getModuleDependencies(title) {
         const genericJsModules = config.output.mw.js;
         const genericCssModules = config.output.mw.css;
-        /* These vars will store the list of js and css dependencies for
-          the article we are downloading. */
-        let jsConfigVars = '';
-        let jsDependenciesList = [];
-        let styleDependenciesList = [];
         const apiUrlDirector = new ApiURLDirector(MediaWiki.actionApiUrl.href);
         const articleApiUrl = apiUrlDirector.buildArticleApiURL(title);
         const articleData = await this.getJSON(articleApiUrl);
@@ -587,34 +752,22 @@ class Downloader {
             logger.error(errorMessage);
             /* If article is missing (for example because it just has been deleted) */
             if (articleData.error.code === 'missingtitle') {
-                return { jsConfigVars, jsDependenciesList, styleDependenciesList };
+                return { jsConfigVars: '', jsDependenciesList: [], styleDependenciesList: [] };
             }
             /* Something went wrong in modules retrieval at app level (no HTTP error) */
             throw new Error(errorMessage);
         }
         const { parse: { modules, modulescripts, modulestyles, headhtml }, } = articleData;
-        jsDependenciesList = genericJsModules.concat(modules, modulescripts).filter((a) => a);
-        styleDependenciesList = [].concat(modules, modulestyles, genericCssModules).filter((a) => a);
-        styleDependenciesList = styleDependenciesList.filter((oneStyleDep) => !contains(config.filters.blackListCssModules, oneStyleDep));
+        const jsDependenciesList = genericJsModules.concat(modules, modulescripts).filter((a) => a);
+        const styleDependenciesList = []
+            .concat(modules, modulestyles, genericCssModules)
+            .filter((a) => a)
+            .filter((oneStyleDep) => !contains(config.filters.blackListCssModules, oneStyleDep));
         logger.info(`Js dependencies of ${title} : ${jsDependenciesList}`);
         logger.info(`Css dependencies of ${title} : ${styleDependenciesList}`);
-        // Saving, as a js module, the jsconfigvars that are set in the header of a wikipedia page
-        // the script below extracts the config with a regex executed on the page header returned from the api
-        const scriptTags = domino.createDocument(`${headhtml}</body></html>`).getElementsByTagName('script');
-        const regex = /mw\.config\.set\(\{.*?\}\);/gm;
-        // eslint-disable-next-line @typescript-eslint/prefer-for-of
-        for (let i = 0; i < scriptTags.length; i += 1) {
-            if (scriptTags[i].text.includes('mw.config.set')) {
-                jsConfigVars = regex.exec(scriptTags[i].text)[0] || '';
-                jsConfigVars = `(window.RLQ=window.RLQ||[]).push(function() {${jsConfigVars}});`;
-            }
-            else if (scriptTags[i].text.includes('RLCONF') || scriptTags[i].text.includes('RLSTATE') || scriptTags[i].text.includes('RLPAGEMODULES')) {
-                jsConfigVars = scriptTags[i].text;
-            }
-        }
-        jsConfigVars = jsConfigVars.replace('nosuchaction', 'view'); // to replace the wgAction config that is set to 'nosuchaction' from api but should be 'view'
+        const jsConfigVars = Downloader.extractJsConfigVars(headhtml);
         // Download mobile page dependencies only once
-        if ((await MediaWiki.hasWikimediaMobileApi(this)) && this.wikimediaMobileJsDependenciesList.length === 0 && this.wikimediaMobileStyleDependenciesList.length === 0) {
+        if ((await MediaWiki.hasWikimediaMobileApi()) && this.wikimediaMobileJsDependenciesList.length === 0 && this.wikimediaMobileStyleDependenciesList.length === 0) {
             try {
                 // TODO: An arbitrary title can be placed since all Wikimedia wikis have the same mobile offline resources
                 const mobileModulesData = await this.getJSON(`${MediaWiki.mobileModulePath}Test`);
@@ -646,6 +799,26 @@ class Downloader {
             stream.on('end', () => resolve(Buffer.concat(chunks)));
         });
     }
+    static extractJsConfigVars(headhtml) {
+        let jsConfigVars = '';
+        // Saving, as a js module, the jsconfigvars that are set in the header of a wikipedia page
+        // the script below extracts the config with a regex executed on the page header returned from the api
+        const scriptTags = domino.createDocument(`${headhtml}</body></html>`).getElementsByTagName('script');
+        const regex = /mw\.config\.set\(\{.*?\}\);/gm;
+        for (let i = 0; i < scriptTags.length; i += 1) {
+            if (scriptTags[i].text.includes('mw.config.set')) {
+                jsConfigVars = regex.exec(scriptTags[i].text)[0] || '';
+                jsConfigVars = `(window.RLQ=window.RLQ||[]).push(function() {${jsConfigVars}});`;
+            }
+            else if (scriptTags[i].text.includes('RLCONF') || scriptTags[i].text.includes('RLSTATE') || scriptTags[i].text.includes('RLPAGEMODULES')) {
+                jsConfigVars = scriptTags[i].text;
+            }
+        }
+        jsConfigVars = jsConfigVars.replace('nosuchaction', 'view'); // to replace the wgAction config that is set to 'nosuchaction' from api but should be 'view'
+        return jsConfigVars;
+    }
 }
-export default Downloader;
+export { Downloader as DownloaderClass };
+const dl = Downloader.getInstance();
+export default dl;
 //# sourceMappingURL=Downloader.js.map