gerdur-core 0.0.0-probe → 1.0.0

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;

package/dist/lib/metaflac-js.d.ts

@@ -0,0 +1,124 @@
+/// <reference types="node" />
+declare class Metaflac {
+    buffer: Buffer;
+    marker: string;
+    streamInfo: any;
+    blocks: any[];
+    padding: any;
+    vorbisComment: any;
+    vendorString: string;
+    tags: any;
+    pictures: Buffer[];
+    picturesSpecs: object[];
+    picturesDatas: string[];
+    framesOffset: number;
+    constructor(flac: Buffer);
+    init(): void;
+    parseVorbisComment(): void;
+    parsePictureBlock(): void;
+    getPicturesSpecs(): object[];
+    /**
+     * Get the MD5 signature from the STREAMINFO block.
+     */
+    getMd5sum(): any;
+    /**
+     * Get the minimum block size from the STREAMINFO block.
+     */
+    getMinBlocksize(): any;
+    /**
+     * Get the maximum block size from the STREAMINFO block.
+     */
+    getMaxBlocksize(): any;
+    /**
+     * Get the minimum frame size from the STREAMINFO block.
+     */
+    getMinFramesize(): any;
+    /**
+     * Get the maximum frame size from the STREAMINFO block.
+     */
+    getMaxFramesize(): any;
+    /**
+     * Get the sample rate from the STREAMINFO block.
+     */
+    getSampleRate(): number;
+    /**
+     * Get the number of channels from the STREAMINFO block.
+     */
+    getChannels(): number;
+    /**
+     * Get the # of bits per sample from the STREAMINFO block.
+     */
+    getBps(): number;
+    /**
+     * Get the total # of samples from the STREAMINFO block.
+     */
+    getTotalSamples(): number;
+    /**
+     * Show the vendor string from the VORBIS_COMMENT block.
+     */
+    getVendorTag(): string;
+    /**
+     * Get all tags where the the field name matches NAME.
+     *
+     * @param {string} name
+     */
+    getTag(name: string): any;
+    /**
+     * Remove all tags whose field name is NAME.
+     *
+     * @param {string} name
+     */
+    removeTag(name: string): void;
+    /**
+     * Remove first tag whose field name is NAME.
+     *
+     * @param {string} name
+     */
+    removeFirstTag(name: string): void;
+    /**
+     * Remove all tags, leaving only the vendor string.
+     */
+    removeAllTags(): void;
+    /**
+     * Add a tag.
+     * The FIELD must comply with the Vorbis comment spec, of the form NAME=VALUE. If there is currently no tag block, one will be created.
+     *
+     * @param {string} field
+     */
+    setTag(field: string): void;
+    /**
+     * Import a picture and store it in a PICTURE metadata block.
+     *
+     * @param {string} filename
+     */
+    importPicture(picture: Buffer, dimension: number, mime: 'image/jpeg' | 'image/png'): void;
+    /**
+     * Return all tags.
+     */
+    getAllTags(): any;
+    buildSpecification(spec?: {}): {
+        type: number;
+        mime: string;
+        description: string;
+        width: number;
+        height: number;
+        depth: number;
+        colors: number;
+    };
+    /**
+     * Build a picture block.
+     *
+     * @param {Buffer} picture
+     * @param {Object} specification
+     * @returns {Buffer}
+     */
+    buildPictureBlock(picture: Buffer, specification?: any): Buffer;
+    buildMetadataBlock(type: number, block: Buffer, isLast?: boolean): Buffer;
+    buildMetadata(): Buffer[];
+    buildStream(): Buffer[];
+    /**
+     * Save changes to buffer and return changed buffer
+     */
+    getBuffer(): Buffer;
+}
+export default Metaflac;