gerdur-core 0.0.0-probe → 1.0.0

package/dist/converter/tidal.js

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.playlist2Deezer = exports.artist2Deezer = exports.albumArtToUrl = exports.getPlaylistTracks = exports.getPlaylist = exports.getArtistTopTracks = exports.getArtistAlbums = exports.getAlbumTracks = exports.album2deezer = exports.getAlbum = exports.track2deezer = exports.getTrack = void 0;
+const p_queue_1 = __importDefault(require("p-queue"));
+const deezer_1 = require("./deezer");
+const http_1 = require("../lib/http");
+const client = new http_1.HttpClient({
+    baseURL: 'https://api.tidal.com/v1/',
+    timeout: 15000,
+    headers: {
+        'user-agent': 'TIDAL/3704 CFNetwork/1220.1 Darwin/20.3.0',
+        'x-tidal-token': 'i4ZDjcyhed7Mu47q',
+    },
+    params: { limit: 500, countryCode: 'US' },
+});
+const queue = new p_queue_1.default({ concurrency: 25 });
+/**
+ * Get a track by its id
+ * @param string} id - track id
+ * @example tidal.getTrack('64975224')
+ */
+const getTrack = async (id) => {
+    const { data } = await client.get(`tracks/${id}`);
+    return data;
+};
+exports.getTrack = getTrack;
+/**
+ * Convert a tidal track to deezer
+ * @param {string} id - track id
+ */
+const track2deezer = async (id) => {
+    const track = await (0, exports.getTrack)(id);
+    return await (0, deezer_1.isrc2deezer)(track.title, track.isrc);
+};
+exports.track2deezer = track2deezer;
+/**
+ * Get an album by its id
+ * @param {string} id - album id
+ * @example tidal.getAlbum('80216363')
+ */
+const getAlbum = async (id) => {
+    const { data } = await client.get(`albums/${id}`);
+    return data;
+};
+exports.getAlbum = getAlbum;
+/**
+ * Convert a tidal albums to deezer
+ * @param {string} id - album id
+ */
+const album2deezer = async (id) => {
+    const album = await (0, exports.getAlbum)(id);
+    return await (0, deezer_1.upc2deezer)(album.title, album.upc);
+};
+exports.album2deezer = album2deezer;
+/**
+ * Get album tracks by album id
+ * @param {string} id - album id
+ * @example tidal.getAlbumTracks('80216363')
+ */
+const getAlbumTracks = async (id) => {
+    const { data } = await client.get(`albums/${id}/tracks`);
+    return data;
+};
+exports.getAlbumTracks = getAlbumTracks;
+/**
+ * Get artist albums by artist id
+ * @param {string} id - artist id
+ * @example tidal.getArtistAlbums('3575680')
+ */
+const getArtistAlbums = async (id) => {
+    const { data } = await client.get(`artists/${id}/albums`);
+    data.items = data.items.filter((item) => item.artist.id.toString() === id);
+    return data;
+};
+exports.getArtistAlbums = getArtistAlbums;
+/**
+ * Get top tracks by artist
+ * @param {string} id - artist id
+ * @example tidal.getArtistTopTracks('3575680')
+ */
+const getArtistTopTracks = async (id) => {
+    const { data } = await client.get(`artists/${id}/toptracks`);
+    data.items = data.items.filter((item) => item.artist.id.toString() === id);
+    return data;
+};
+exports.getArtistTopTracks = getArtistTopTracks;
+/**
+ * Get a playlist by its uuid
+ * @param {string} uuid - playlist uuid
+ * @example tidal.getPlaylist('1c5d01ed-4f05-40c4-bd28-0f73099e9648')
+ */
+const getPlaylist = async (uuid) => {
+    const { data } = await client.get(`playlists/${uuid}`);
+    return data;
+};
+exports.getPlaylist = getPlaylist;
+/**
+ * Get playlist tracks by playlist uuid
+ * @param {string} uuid - playlist uuid
+ * @example tidal.getPlaylistTracks('1c5d01ed-4f05-40c4-bd28-0f73099e9648')
+ */
+const getPlaylistTracks = async (uuid) => {
+    const { data } = await client.get(`playlists/${uuid}/tracks`);
+    return data;
+};
+exports.getPlaylistTracks = getPlaylistTracks;
+/**
+ * Get valid urls to album art
+ * @param {string} uuid - album art uuid (can be found as cover property in album object)
+ * @example tidal.albumArtToUrl('9a56f482-e9cf-46c3-bb21-82710e7854d4')
+ * @returns {Object}
+ */
+const albumArtToUrl = (uuid) => {
+    const baseUrl = `https://resources.tidal.com/images/${uuid.replace(/-/g, '/')}`;
+    return {
+        sm: `${baseUrl}/160x160.jpg`,
+        md: `${baseUrl}/320x320.jpg`,
+        lg: `${baseUrl}/640x640.jpg`,
+        xl: `${baseUrl}/1280x1280.jpg`,
+    };
+};
+exports.albumArtToUrl = albumArtToUrl;
+/**
+ * Find tidal artists tracks on deezer
+ * @param {string} id - artist id
+ * @example tidal.artist2Deezer('3575680')
+ */
+const artist2Deezer = async (id, onError) => {
+    const { items } = await (0, exports.getArtistTopTracks)(id);
+    const tracks = [];
+    await queue.addAll(items.map((item, index) => {
+        return async () => {
+            try {
+                const track = await (0, deezer_1.isrc2deezer)(item.title, item.isrc);
+                // console.log(signale.success(`Track #${index}: ${item.name}`));
+                tracks.push(track);
+            }
+            catch (err) {
+                if (onError) {
+                    onError(item, index, err);
+                }
+            }
+        };
+    }));
+    return tracks;
+};
+exports.artist2Deezer = artist2Deezer;
+/**
+ * Find same set of playlist tracks on deezer
+ * @param {string} uuid - playlist uuid
+ * @example tidal.playlist2Deezer('1c5d01ed-4f05-40c4-bd28-0f73099e9648')
+ */
+const playlist2Deezer = async (uuid, onError) => {
+    const body = await (0, exports.getPlaylist)(uuid);
+    const { items } = await (0, exports.getPlaylistTracks)(uuid);
+    const tracks = [];
+    await queue.addAll(items.map((item, index) => {
+        return async () => {
+            try {
+                const track = await (0, deezer_1.isrc2deezer)(item.title, item.isrc);
+                // console.log(signale.success(`Track #${index}: ${item.track.name}`));
+                track.TRACK_POSITION = index + 1;
+                tracks.push(track);
+            }
+            catch (err) {
+                if (onError) {
+                    onError(item, index, err);
+                }
+            }
+        };
+    }));
+    const userId = body.creator.id.toString();
+    const playlistInfoData = {
+        PLAYLIST_ID: body.uuid,
+        PARENT_USERNAME: userId,
+        PARENT_USER_ID: userId,
+        PICTURE_TYPE: 'cover',
+        PLAYLIST_PICTURE: body.image,
+        TITLE: body.title,
+        TYPE: '0',
+        STATUS: '0',
+        USER_ID: userId,
+        DATE_ADD: body.created,
+        DATE_MOD: body.lastUpdated,
+        DATE_CREATE: body.created,
+        NB_SONG: body.numberOfTracks,
+        NB_FAN: 0,
+        CHECKSUM: body.created,
+        HAS_ARTIST_LINKED: false,
+        IS_SPONSORED: false,
+        IS_EDITO: false,
+        __TYPE__: 'playlist',
+    };
+    return [playlistInfoData, tracks];
+};
+exports.playlist2Deezer = playlist2Deezer;

package/dist/converter/youtube.d.ts

@@ -0,0 +1,6 @@
+import type { trackType } from '../types';
+/**
+ * Convert a youtube video to track by video id
+ * @param {String} id - video id
+ */
+export declare const track2deezer: (id: string) => Promise<trackType>;

package/dist/converter/youtube.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.track2deezer = void 0;
+const node_html_parser_1 = require("node-html-parser");
+const api_1 = require("../api");
+const http_1 = require("../lib/http");
+const parseInlineObject = (document, variableName) => {
+    const prefix = `${variableName} = `;
+    const start = document.indexOf(prefix);
+    if (start === -1) {
+        return null;
+    }
+    const jsonStart = start + prefix.length;
+    let depth = 0;
+    let isInString = false;
+    let isEscaped = false;
+    for (let index = jsonStart; index < document.length; index++) {
+        const char = document[index];
+        if (isInString) {
+            if (isEscaped) {
+                isEscaped = false;
+            }
+            else if (char === '\\') {
+                isEscaped = true;
+            }
+            else if (char === '"') {
+                isInString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            isInString = true;
+            continue;
+        }
+        if (char === '{') {
+            depth += 1;
+        }
+        else if (char === '}') {
+            depth -= 1;
+            if (depth === 0) {
+                return JSON.parse(document.slice(jsonStart, index + 1));
+            }
+        }
+    }
+    return null;
+};
+const searchTrackByTitle = async (title) => {
+    const normalizedTitle = title
+        .toLowerCase()
+        .replace(/\(off.*\)/i, '')
+        .replace(/official video/gi, '')
+        .replace(/lyrics?/gi, '')
+        .replace(/ft.*/i, '')
+        .replace(/[,-.]/g, ' ')
+        .replace(/  +/g, ' ')
+        .trim();
+    if (!normalizedTitle) {
+        return undefined;
+    }
+    const { TRACK } = await (0, api_1.searchMusic)(normalizedTitle, ['TRACK'], 20);
+    const filteredTracks = TRACK.data.filter((track) => normalizedTitle.includes(track.ART_NAME.toLowerCase()));
+    return filteredTracks[0] || TRACK.data[0];
+};
+const getTrack = async (id) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
+    const response = await (0, http_1.getText)(`https://www.youtube.com/watch?v=${id}&hl=en`);
+    const scripts = (0, node_html_parser_1.parse)(response)
+        .querySelectorAll('script')
+        .map((script) => script.text)
+        .join('\n');
+    const playerResponse = parseInlineObject(scripts, 'var ytInitialPlayerResponse');
+    const initialData = parseInlineObject(scripts, 'var ytInitialData');
+    const rows = (_j = (_h = (_g = (_f = (_e = (_d = (_c = (_b = (_a = initialData === null || initialData === void 0 ? void 0 : initialData.contents) === null || _a === void 0 ? void 0 : _a.twoColumnWatchNextResults) === null || _b === void 0 ? void 0 : _b.results) === null || _c === void 0 ? void 0 : _c.results) === null || _d === void 0 ? void 0 : _d.contents) === null || _e === void 0 ? void 0 : _e.find((content) => Boolean(content.videoSecondaryInfoRenderer))) === null || _f === void 0 ? void 0 : _f.videoSecondaryInfoRenderer) === null || _g === void 0 ? void 0 : _g.metadataRowContainer) === null || _h === void 0 ? void 0 : _h.metadataRowContainerRenderer) === null || _j === void 0 ? void 0 : _j.rows;
+    if (rows && rows.length > 0) {
+        const song = rows.find((row) => { var _a, _b; return ((_b = (_a = row.metadataRowRenderer) === null || _a === void 0 ? void 0 : _a.title) === null || _b === void 0 ? void 0 : _b.simpleText) === 'Song'; });
+        const artist = rows.find((row) => { var _a, _b; return ((_b = (_a = row.metadataRowRenderer) === null || _a === void 0 ? void 0 : _a.title) === null || _b === void 0 ? void 0 : _b.simpleText) === 'Artist'; });
+        const songName = (_m = (_l = (_k = song === null || song === void 0 ? void 0 : song.metadataRowRenderer) === null || _k === void 0 ? void 0 : _k.contents) === null || _l === void 0 ? void 0 : _l[0]) === null || _m === void 0 ? void 0 : _m.simpleText;
+        const artistName = (_s = (_r = (_q = (_p = (_o = artist === null || artist === void 0 ? void 0 : artist.metadataRowRenderer) === null || _o === void 0 ? void 0 : _o.contents) === null || _p === void 0 ? void 0 : _p[0]) === null || _q === void 0 ? void 0 : _q.runs) === null || _r === void 0 ? void 0 : _r[0]) === null || _s === void 0 ? void 0 : _s.text;
+        if (songName && artistName) {
+            const { TRACK } = await (0, api_1.searchAlternative)(artistName, songName, 1);
+            if (TRACK.data[0]) {
+                return TRACK.data[0];
+            }
+        }
+    }
+    if ((_t = playerResponse === null || playerResponse === void 0 ? void 0 : playerResponse.videoDetails) === null || _t === void 0 ? void 0 : _t.title) {
+        return await searchTrackByTitle(playerResponse.videoDetails.title);
+    }
+    return undefined;
+};
+/**
+ * Convert a youtube video to track by video id
+ * @param {String} id - video id
+ */
+const track2deezer = async (id) => {
+    const track = await getTrack(id);
+    if (track) {
+        return track;
+    }
+    throw new Error('No track found for youtube video ' + id);
+};
+exports.track2deezer = track2deezer;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { initDeezerApi } from './lib/request';
+export * from './api';
+export * from './converter';
+export * from './lib/decrypt';
+export * from './lib/get-url';
+export * from './metadata-writer';

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initDeezerApi = void 0;
+var request_1 = require("./lib/request");
+Object.defineProperty(exports, "initDeezerApi", { enumerable: true, get: function () { return request_1.initDeezerApi; } });
+__exportStar(require("./api"), exports);
+__exportStar(require("./converter"), exports);
+__exportStar(require("./lib/decrypt"), exports);
+__exportStar(require("./lib/get-url"), exports);
+__exportStar(require("./metadata-writer"), exports);

package/dist/lib/decrypt.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import type { trackType } from '../types';
+export declare const getSongFileName: ({ MD5_ORIGIN, SNG_ID, MEDIA_VERSION }: trackType, quality: number) => string;
+/**
+ *
+ * @param source Downloaded song from `getTrackDownloadUrl`
+ * @param trackId Song ID as string
+ */
+export declare const decryptDownload: (source: Buffer, trackId: string) => Buffer;

package/dist/lib/decrypt.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decryptDownload = exports.getSongFileName = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const md5 = (data, type = 'ascii') => {
+    const md5sum = crypto_1.default.createHash('md5');
+    md5sum.update(data.toString(), type);
+    return md5sum.digest('hex');
+};
+const getSongFileName = ({ MD5_ORIGIN, SNG_ID, MEDIA_VERSION }, quality) => {
+    if (!MD5_ORIGIN) {
+        throw new Error(`Missing MD5_ORIGIN for track ${SNG_ID}`);
+    }
+    const step1 = [MD5_ORIGIN, quality, SNG_ID, MEDIA_VERSION].join('¤');
+    let step2 = md5(step1) + '¤' + step1 + '¤';
+    while (step2.length % 16 > 0)
+        step2 += ' ';
+    return crypto_1.default.createCipheriv('aes-128-ecb', 'jo6aey6haid2Teih', '').update(step2, 'ascii', 'hex');
+};
+exports.getSongFileName = getSongFileName;
+const getBlowfishKey = (trackId) => {
+    const SECRET = 'g4el58wc' + '0zvf9na1';
+    const idMd5 = md5(trackId);
+    let bfKey = '';
+    for (let i = 0; i < 16; i++) {
+        bfKey += String.fromCharCode(idMd5.charCodeAt(i) ^ idMd5.charCodeAt(i + 16) ^ SECRET.charCodeAt(i));
+    }
+    return bfKey;
+};
+const decryptChunk = (chunk, blowFishKey) => {
+    const cipher = crypto_1.default.createDecipheriv('bf-cbc', blowFishKey, Buffer.from([0, 1, 2, 3, 4, 5, 6, 7]));
+    cipher.setAutoPadding(false);
+    return Buffer.concat([cipher.update(chunk), cipher.final()]);
+};
+/**
+ *
+ * @param source Downloaded song from `getTrackDownloadUrl`
+ * @param trackId Song ID as string
+ */
+const decryptDownload = (source, trackId) => {
+    const chunkSize = 2048;
+    const blowFishKey = getBlowfishKey(trackId);
+    let chunkIndex = 0;
+    let position = 0;
+    const destBuffer = Buffer.alloc(source.length);
+    while (position < source.length) {
+        const currentChunkSize = Math.min(chunkSize, source.length - position);
+        const sourceChunk = source.subarray(position, position + currentChunkSize);
+        if (chunkIndex % 3 > 0 || currentChunkSize < chunkSize) {
+            sourceChunk.copy(destBuffer, position);
+        }
+        else {
+            decryptChunk(sourceChunk, blowFishKey).copy(destBuffer, position);
+        }
+        position += currentChunkSize;
+        chunkIndex++;
+    }
+    return destBuffer;
+};
+exports.decryptDownload = decryptDownload;

package/dist/lib/fast-lru.d.ts

@@ -0,0 +1,63 @@
+/**
+ * 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
+ */
+declare class FastLRU {
+    _max: number;
+    _ttl: number;
+    _cache: Map<any, any>;
+    _meta: {
+        [key: string]: any;
+    };
+    constructor({ maxSize, ttl }: {
+        maxSize?: number | undefined;
+        ttl?: number | undefined;
+    });
+    /**
+     * Add new entry
+     */
+    set(key: string, value: any, ttl?: number): void;
+    /**
+     * Get entry
+     */
+    get(key: string): any;
+    /**
+     * Get without hitting hits
+     */
+    peek(key: string): any;
+    /**
+     * Remove entry
+     */
+    delete(key: string): void;
+    /**
+     * Remove all entries
+     */
+    clear(): void;
+    /**
+     * Check has entry
+     */
+    has(key: string): boolean;
+    /**
+     * Get all kies
+     * @returns {Iterator} Iterator on all kies
+     */
+    keys(): IterableIterator<any>;
+    /**
+     * Iterate over values
+     */
+    values(): IterableIterator<any>;
+    /**
+     * Iterate over entries
+     */
+    entries(): IterableIterator<[any, any]>;
+    /**
+     * For each
+     */
+    forEach(cb: any): void;
+    /**
+     * Entries total size
+     */
+    get size(): number;
+}
+export default FastLRU;

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>;