q-fi-core 2.3.1

package/dist/lib/fast-lru.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Fast LRU & TTL cache
+ * @param  {Integer} options.max		- Max entries in the cache. @default Infinity
+ * @param  {Integer} options.ttl		- Timeout before removing entries. @default Infinity
+ */
+class FastLRU {
+    constructor({ maxSize = Infinity, ttl = 0 }) {
+        // Default options
+        this._max = maxSize;
+        this._ttl = ttl;
+        this._cache = new Map();
+        // Metadata for entries
+        this._meta = {};
+    }
+    /**
+     * Add new entry
+     */
+    set(key, value, ttl = this._ttl) {
+        // Execution time
+        const time = Date.now();
+        // Remvove least recently used elements if exceeds max bytes
+        if (this._cache.size >= this._max) {
+            const items = Object.values(this._meta);
+            if (this._ttl > 0) {
+                for (const item of items) {
+                    if (item.expire < time) {
+                        this.delete(item.key);
+                    }
+                }
+            }
+            if (this._cache.size >= this._max) {
+                const least = items.sort((a, b) => a.hits - b.hits)[0];
+                this.delete(least.key);
+            }
+        }
+        // Override if key already set
+        this._cache.set(key, value);
+        this._meta[key] = {
+            key,
+            hits: 0,
+            expire: time + ttl,
+        };
+    }
+    /**
+     * Get entry
+     */
+    get(key) {
+        if (this._cache.has(key)) {
+            const item = this._cache.get(key);
+            if (this._ttl > 0) {
+                const time = Date.now();
+                if (this._meta[key].expire < time) {
+                    this.delete(key);
+                    return undefined;
+                }
+            }
+            this._meta[key].hits++;
+            return item;
+        }
+    }
+    /**
+     * Get without hitting hits
+     */
+    peek(key) {
+        return this._cache.get(key);
+    }
+    /**
+     * Remove entry
+     */
+    delete(key) {
+        delete this._meta[key];
+        this._cache.delete(key);
+    }
+    /**
+     * Remove all entries
+     */
+    clear() {
+        this._cache.clear();
+        this._meta = {};
+    }
+    /**
+     * Check has entry
+     */
+    has(key) {
+        return this._cache.has(key);
+    }
+    /**
+     * Get all kies
+     * @returns {Iterator} Iterator on all kies
+     */
+    keys() {
+        return this._cache.keys();
+    }
+    /**
+     * Iterate over values
+     */
+    values() {
+        return this._cache.values();
+    }
+    /**
+     * Iterate over entries
+     */
+    entries() {
+        return this._cache.entries();
+    }
+    /**
+     * For each
+     */
+    forEach(cb) {
+        return this._cache.forEach(cb);
+    }
+    /**
+     * Entries total size
+     */
+    get size() {
+        return this._cache.size;
+    }
+}
+exports.default = FastLRU;

package/dist/lib/get-url.d.ts

@@ -0,0 +1,16 @@
+import type { trackType } from '../types';
+export declare class WrongLicense extends Error {
+    constructor(format: string);
+}
+export declare class GeoBlocked extends Error {
+    constructor(country: string);
+}
+/**
+ * @param track Track info json returned from `getTrackInfo`
+ * @param quality 1 = 128kbps, 3 = 320kbps and 9 = flac (around 1411kbps)
+ */
+export declare const getTrackDownloadUrl: (track: trackType, quality: number) => Promise<{
+    trackUrl: string;
+    isEncrypted: boolean;
+    fileSize: number;
+} | null>;

package/dist/lib/get-url.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTrackDownloadUrl = exports.GeoBlocked = exports.WrongLicense = void 0;
+const decrypt_1 = require("../lib/decrypt");
+const http_1 = require("../lib/http");
+const request_1 = __importDefault(require("../lib/request"));
+class WrongLicense extends Error {
+    constructor(format) {
+        super();
+        this.name = 'WrongLicense';
+        this.message = `Your account can't stream ${format} tracks`;
+    }
+}
+exports.WrongLicense = WrongLicense;
+class GeoBlocked extends Error {
+    constructor(country) {
+        super();
+        this.name = 'GeoBlocked';
+        this.message = `This track is not available in your country (${country})`;
+    }
+}
+exports.GeoBlocked = GeoBlocked;
+let user_data = null;
+const getTrackFileSize = (track, quality) => {
+    switch (quality) {
+        case 9:
+            return Number(track.FILESIZE_FLAC);
+        case 3:
+            return Number(track.FILESIZE_MP3_320);
+        case 1:
+            return Number(track.FILESIZE_MP3_128);
+        default:
+            return 0;
+    }
+};
+const dzAuthenticate = async () => {
+    const { data } = await request_1.default.get('https://www.deezer.com/ajax/gw-light.php', {
+        params: {
+            method: 'deezer.getUserData',
+            api_version: '1.0',
+            api_token: 'null',
+        },
+    });
+    user_data = {
+        license_token: data.results.USER.OPTIONS.license_token,
+        can_stream_lossless: data.results.USER.OPTIONS.web_lossless || data.results.USER.OPTIONS.mobile_loseless,
+        can_stream_hq: data.results.USER.OPTIONS.web_hq || data.results.USER.OPTIONS.mobile_hq,
+        country: data.results.COUNTRY,
+    };
+    return user_data;
+};
+const getTrackUrlFromServer = async (track_token, format) => {
+    const user = user_data ? user_data : await dzAuthenticate();
+    if ((format === 'FLAC' && !user.can_stream_lossless) || (format === 'MP3_320' && !user.can_stream_hq)) {
+        throw new WrongLicense(format);
+    }
+    const { data } = await request_1.default.post('https://media.deezer.com/v1/get_url', {
+        license_token: user.license_token,
+        media: [
+            {
+                type: 'FULL',
+                formats: [{ format, cipher: 'BF_CBC_STRIPE' }],
+            },
+        ],
+        track_tokens: [track_token],
+    });
+    if (data.data.length > 0) {
+        if (data.data[0].errors) {
+            if (data.data[0].errors[0].code === 2002) {
+                throw new GeoBlocked(user.country);
+            }
+            throw new Error(Object.entries(data.data[0].errors[0]).join(', '));
+        }
+        return data.data[0].media.length > 0 ? data.data[0].media[0].sources[0].url : null;
+    }
+    return null;
+};
+/**
+ * @param track Track info json returned from `getTrackInfo`
+ * @param quality 1 = 128kbps, 3 = 320kbps and 9 = flac (around 1411kbps)
+ */
+const getTrackDownloadUrl = async (track, quality) => {
+    let wrongLicense = null;
+    let geoBlocked = null;
+    let formatName;
+    switch (quality) {
+        case 9:
+            formatName = 'FLAC';
+            break;
+        case 3:
+            formatName = 'MP3_320';
+            break;
+        case 1:
+            formatName = 'MP3_128';
+            break;
+        default:
+            throw new Error(`Unknown quality ${quality}`);
+    }
+    // Get URL with the official API
+    try {
+        const url = await getTrackUrlFromServer(track.TRACK_TOKEN, formatName);
+        if (url) {
+            return {
+                trackUrl: url,
+                isEncrypted: url.includes('/mobile/') || url.includes('/media/'),
+                fileSize: getTrackFileSize(track, quality),
+            };
+        }
+    }
+    catch (err) {
+        if (err instanceof WrongLicense) {
+            wrongLicense = err;
+        }
+        else if (err instanceof GeoBlocked) {
+            geoBlocked = err;
+        }
+        else {
+            throw err;
+        }
+    }
+    // Fallback to the old method
+    if (track.MD5_ORIGIN) {
+        const filename = (0, decrypt_1.getSongFileName)(track, quality); // encrypted file name
+        const url = `https://e-cdns-proxy-${track.MD5_ORIGIN[0]}.dzcdn.net/mobile/1/${filename}`;
+        const fileSize = await testUrl(url);
+        if (fileSize > 0) {
+            return {
+                trackUrl: url,
+                isEncrypted: url.includes('/mobile/') || url.includes('/media/'),
+                fileSize: fileSize,
+            };
+        }
+    }
+    if (wrongLicense) {
+        throw wrongLicense;
+    }
+    if (geoBlocked) {
+        throw geoBlocked;
+    }
+    return null;
+};
+exports.getTrackDownloadUrl = getTrackDownloadUrl;
+const testUrl = async (url) => {
+    try {
+        const { headers } = await (0, http_1.headRequest)(url);
+        return Number(headers['content-length']);
+    }
+    catch (err) {
+        return 0;
+    }
+};

package/dist/lib/http.d.ts

@@ -0,0 +1,66 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IncomingHttpHeaders } from 'http';
+type HttpMethod = 'GET' | 'POST' | 'HEAD';
+type ResponseType = 'buffer' | 'json' | 'text';
+type QueryValue = string | number | boolean | null | undefined;
+type QueryInput = QueryValue | QueryValue[];
+export type HttpHeaders = Record<string, string>;
+export type HttpQuery = Record<string, QueryInput>;
+export interface HttpRequestConfig {
+    headers?: HttpHeaders;
+    params?: HttpQuery;
+    timeout?: number;
+    responseType?: ResponseType;
+}
+interface RequestDescriptor {
+    data?: unknown;
+    headers?: HttpHeaders;
+    method: HttpMethod;
+    params?: HttpQuery;
+    responseType: ResponseType;
+    timeout: number;
+    url: string;
+}
+export interface HttpResponse<T> {
+    config: RequestDescriptor;
+    data: T;
+    headers: IncomingHttpHeaders;
+    request: {
+        res: {
+            responseUrl: string;
+        };
+    };
+    status: number;
+}
+export declare class HttpStatusError extends Error {
+    body: Buffer;
+    headers: IncomingHttpHeaders;
+    statusCode: number;
+    constructor(statusCode: number, headers: IncomingHttpHeaders, body: Buffer);
+}
+export declare class HttpClient {
+    defaults: {
+        baseURL?: string;
+        headers: HttpHeaders;
+        maxRedirects: number;
+        params: HttpQuery;
+        timeout: number;
+    };
+    constructor(defaults?: {
+        baseURL?: string;
+        headers?: HttpHeaders;
+        maxRedirects?: number;
+        params?: HttpQuery;
+        timeout?: number;
+    });
+    get<T = unknown>(url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+    post<T = unknown>(url: string, body?: unknown, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+    head(url: string, config?: Omit<HttpRequestConfig, 'responseType'>): Promise<HttpResponse<Buffer>>;
+    private request;
+}
+export declare const getBuffer: (url: string, config?: HttpRequestConfig) => Promise<Buffer>;
+export declare const getJson: <T = unknown>(url: string, config?: HttpRequestConfig) => Promise<T>;
+export declare const getText: (url: string, config?: HttpRequestConfig) => Promise<string>;
+export declare const headRequest: (url: string, config?: Omit<HttpRequestConfig, 'responseType'>) => Promise<HttpResponse<Buffer>>;
+export {};

package/dist/lib/http.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.headRequest = exports.getText = exports.getJson = exports.getBuffer = exports.HttpClient = exports.HttpStatusError = void 0;
+const http_1 = require("http");
+const https_1 = require("https");
+const zlib_1 = require("zlib");
+const httpAgent = new http_1.Agent({ keepAlive: true });
+const httpsAgent = new https_1.Agent({ keepAlive: true });
+class HttpStatusError extends Error {
+    constructor(statusCode, headers, body) {
+        super(`Request failed with status code ${statusCode}`);
+        this.name = 'HttpStatusError';
+        this.statusCode = statusCode;
+        this.headers = headers;
+        this.body = body;
+    }
+}
+exports.HttpStatusError = HttpStatusError;
+class HttpClient {
+    constructor(defaults = {}) {
+        var _a, _b;
+        this.defaults = {
+            baseURL: defaults.baseURL,
+            headers: defaults.headers ? normalizeHeaders(defaults.headers) : {},
+            maxRedirects: (_a = defaults.maxRedirects) !== null && _a !== void 0 ? _a : 5,
+            params: defaults.params ? { ...defaults.params } : {},
+            timeout: (_b = defaults.timeout) !== null && _b !== void 0 ? _b : 15000,
+        };
+    }
+    get(url, config = {}) {
+        return this.request('GET', url, undefined, config);
+    }
+    post(url, body, config = {}) {
+        return this.request('POST', url, body, config);
+    }
+    head(url, config = {}) {
+        return this.request('HEAD', url, undefined, { ...config, responseType: 'buffer' });
+    }
+    async request(method, url, body, config = {}) {
+        var _a, _b;
+        const responseType = (_a = config.responseType) !== null && _a !== void 0 ? _a : 'json';
+        const timeout = (_b = config.timeout) !== null && _b !== void 0 ? _b : this.defaults.timeout;
+        const headers = normalizeHeaders({ ...this.defaults.headers, ...config.headers });
+        const params = { ...this.defaults.params, ...config.params };
+        const rawResponse = await requestRaw({
+            baseURL: this.defaults.baseURL,
+            body,
+            headers,
+            maxRedirects: this.defaults.maxRedirects,
+            method,
+            params,
+            timeout,
+            url,
+        });
+        return {
+            config: {
+                data: body,
+                headers,
+                method,
+                params,
+                responseType,
+                timeout,
+                url,
+            },
+            data: parseResponseBody(rawResponse, responseType),
+            headers: rawResponse.headers,
+            request: {
+                res: {
+                    responseUrl: rawResponse.url,
+                },
+            },
+            status: rawResponse.status,
+        };
+    }
+}
+exports.HttpClient = HttpClient;
+const requestRaw = async (config, redirectCount = 0) => {
+    const requestUrl = buildUrl(config.url, config.baseURL, config.params);
+    const headers = normalizeHeaders(config.headers);
+    const serializedBody = serializeBody(config.body, headers);
+    if (serializedBody && !headers['content-length']) {
+        headers['content-length'] = String(serializedBody.length);
+    }
+    return await new Promise((resolve, reject) => {
+        var _a;
+        const isHttps = requestUrl.protocol === 'https:';
+        const requestFn = isHttps ? https_1.request : http_1.request;
+        const req = requestFn({
+            agent: isHttps ? httpsAgent : httpAgent,
+            headers,
+            hostname: requestUrl.hostname,
+            method: config.method,
+            path: requestUrl.pathname + requestUrl.search,
+            port: requestUrl.port,
+            protocol: requestUrl.protocol,
+        }, (response) => {
+            var _a, _b;
+            const status = (_a = response.statusCode) !== null && _a !== void 0 ? _a : 0;
+            const locationHeader = response.headers.location;
+            const location = Array.isArray(locationHeader) ? locationHeader[0] : locationHeader;
+            if (location && isRedirectStatus(status) && redirectCount < ((_b = config.maxRedirects) !== null && _b !== void 0 ? _b : 5)) {
+                response.resume();
+                const redirectedMethod = status === 303 || ((status === 301 || status === 302) && config.method === 'POST') ? 'GET' : config.method;
+                const redirectedHeaders = { ...headers };
+                if (redirectedMethod === 'GET' || redirectedMethod === 'HEAD') {
+                    delete redirectedHeaders['content-length'];
+                    delete redirectedHeaders['content-type'];
+                }
+                requestRaw({
+                    ...config,
+                    baseURL: undefined,
+                    body: redirectedMethod === 'POST' ? config.body : undefined,
+                    headers: redirectedHeaders,
+                    method: redirectedMethod,
+                    url: new URL(location, requestUrl).toString(),
+                }, redirectCount + 1)
+                    .then(resolve)
+                    .catch(reject);
+                return;
+            }
+            const chunks = [];
+            response.on('data', (chunk) => {
+                chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            });
+            response.on('end', () => {
+                try {
+                    const body = decodeResponseBuffer(Buffer.concat(chunks), response.headers['content-encoding']);
+                    if (status < 200 || status >= 300) {
+                        reject(new HttpStatusError(status, response.headers, body));
+                        return;
+                    }
+                    resolve({
+                        body,
+                        headers: response.headers,
+                        status,
+                        url: requestUrl.toString(),
+                    });
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        });
+        req.on('error', reject);
+        req.setTimeout((_a = config.timeout) !== null && _a !== void 0 ? _a : 15000, () => {
+            var _a;
+            req.destroy(new Error(`Request timed out after ${(_a = config.timeout) !== null && _a !== void 0 ? _a : 15000}ms`));
+        });
+        if (serializedBody) {
+            req.write(serializedBody);
+        }
+        req.end();
+    });
+};
+const buildUrl = (url, baseURL, params) => {
+    const parsedUrl = new URL(resolveUrl(url, baseURL));
+    if (params) {
+        for (const [key, input] of Object.entries(params)) {
+            if (Array.isArray(input)) {
+                for (const value of input) {
+                    if (value !== undefined && value !== null) {
+                        parsedUrl.searchParams.append(key, String(value));
+                    }
+                }
+            }
+            else if (input !== undefined && input !== null) {
+                parsedUrl.searchParams.set(key, String(input));
+            }
+        }
+    }
+    return parsedUrl;
+};
+const resolveUrl = (url, baseURL) => {
+    if (!baseURL || isAbsoluteUrl(url)) {
+        return url;
+    }
+    return `${baseURL.replace(/\/+$/, '')}/${url.replace(/^\/+/, '')}`;
+};
+const normalizeHeaders = (headers = {}) => {
+    const normalizedHeaders = {};
+    for (const [key, value] of Object.entries(headers)) {
+        normalizedHeaders[key.toLowerCase()] = value;
+    }
+    return normalizedHeaders;
+};
+const serializeBody = (body, headers) => {
+    if (body === undefined) {
+        return undefined;
+    }
+    if (Buffer.isBuffer(body)) {
+        return body;
+    }
+    if (typeof body === 'string') {
+        return Buffer.from(body);
+    }
+    if (!headers['content-type']) {
+        headers['content-type'] = 'application/json; charset=UTF-8';
+    }
+    return Buffer.from(JSON.stringify(body));
+};
+const decodeResponseBuffer = (buffer, contentEncoding) => {
+    var _a, _b;
+    const encoding = (_b = (_a = (Array.isArray(contentEncoding) ? contentEncoding[0] : contentEncoding)) === null || _a === void 0 ? void 0 : _a.split(',')[0]) === null || _b === void 0 ? void 0 : _b.trim();
+    switch (encoding) {
+        case 'br':
+            return (0, zlib_1.brotliDecompressSync)(buffer);
+        case 'deflate':
+            return (0, zlib_1.inflateSync)(buffer);
+        case 'gzip':
+            return (0, zlib_1.gunzipSync)(buffer);
+        default:
+            return buffer;
+    }
+};
+const parseResponseBody = (response, responseType) => {
+    if (responseType === 'buffer') {
+        return response.body;
+    }
+    const text = response.body.toString('utf-8');
+    if (responseType === 'text') {
+        return text;
+    }
+    return JSON.parse(text);
+};
+const isRedirectStatus = (status) => [301, 302, 303, 307, 308].includes(status);
+const isAbsoluteUrl = (url) => /^[a-z][a-z\d+\-.]*:\/\//i.test(url);
+const defaultClient = new HttpClient();
+const getBuffer = async (url, config = {}) => (await defaultClient.get(url, { ...config, responseType: 'buffer' })).data;
+exports.getBuffer = getBuffer;
+const getJson = async (url, config = {}) => (await defaultClient.get(url, { ...config, responseType: 'json' })).data;
+exports.getJson = getJson;
+const getText = async (url, config = {}) => (await defaultClient.get(url, { ...config, responseType: 'text' })).data;
+exports.getText = getText;
+const headRequest = async (url, config = {}) => await defaultClient.head(url, config);
+exports.headRequest = headRequest;