discord-player-deezer 2.0.0-dev.9 → 2.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.ts +5 -1
- package/dist/index.js +15 -8
- package/package.json +5 -3
- package/readme.md +0 -8
- package/src/DeezerExtractor.ts +131 -0
- package/src/index.ts +2 -0
- package/src/utils/util.ts +194 -0
package/dist/index.d.ts
CHANGED
|
@@ -21,6 +21,10 @@ type DeezerUserInfo = {
|
|
|
21
21
|
csrfToken: string;
|
|
22
22
|
mediaUrl: string;
|
|
23
23
|
};
|
|
24
|
+
declare const Warnings: {
|
|
25
|
+
readonly MissingDecryption: "Decryption Key missing! This is needed for extracting streams.";
|
|
26
|
+
};
|
|
27
|
+
type Warnings = (typeof Warnings)[keyof typeof Warnings];
|
|
24
28
|
declare class DeezerExtractor extends BaseExtractor<DeezerExtractorOptions> {
|
|
25
29
|
static identifier: string;
|
|
26
30
|
userInfo: DeezerUserInfo;
|
|
@@ -63,4 +67,4 @@ declare const deezerRegex: {
|
|
|
63
67
|
};
|
|
64
68
|
declare function validate(query: string): boolean;
|
|
65
69
|
|
|
66
|
-
export { type ArrayOrObject, DeezerExtractor, type DeezerExtractorOptions, type DeezerSearchTrackResponse, type DeezerUserInfo, buildTrackFromSearch, deezerRegex, extractTrackId, getCrypto, searchOneTrack, streamTrack, validate };
|
|
70
|
+
export { type ArrayOrObject, DeezerExtractor, type DeezerExtractorOptions, type DeezerSearchTrackResponse, type DeezerUserInfo, Warnings, buildTrackFromSearch, deezerRegex, extractTrackId, getCrypto, searchOneTrack, streamTrack, validate };
|
package/dist/index.js
CHANGED
|
@@ -31,6 +31,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
|
|
|
31
31
|
var src_exports = {};
|
|
32
32
|
__export(src_exports, {
|
|
33
33
|
DeezerExtractor: () => DeezerExtractor,
|
|
34
|
+
Warnings: () => Warnings,
|
|
34
35
|
buildTrackFromSearch: () => buildTrackFromSearch,
|
|
35
36
|
deezerRegex: () => deezerRegex,
|
|
36
37
|
extractTrackId: () => extractTrackId,
|
|
@@ -48,6 +49,7 @@ var import_deezer_music_metadata = require("@mithron/deezer-music-metadata");
|
|
|
48
49
|
// src/utils/util.ts
|
|
49
50
|
var import_discord_player = require("discord-player");
|
|
50
51
|
var import_stream = require("stream");
|
|
52
|
+
var import_blowfish_node = __toESM(require("blowfish-node"));
|
|
51
53
|
var IV = Buffer.from(Array.from({ length: 8 }, (_, x) => x));
|
|
52
54
|
var rawCrypto;
|
|
53
55
|
async function getCrypto() {
|
|
@@ -155,16 +157,13 @@ async function streamTrack(track, ext) {
|
|
|
155
157
|
} else {
|
|
156
158
|
buffer = Buffer.concat([buffer, chunk]);
|
|
157
159
|
}
|
|
160
|
+
const blowfishDecrypter = new import_blowfish_node.default(new Uint8Array(trackKey), import_blowfish_node.default.MODE.CBC, import_blowfish_node.default.PADDING.NULL);
|
|
161
|
+
blowfishDecrypter.setIv(new Uint8Array(IV));
|
|
158
162
|
while (buffer.length >= bufferSize) {
|
|
159
163
|
const bufferSized = buffer.subarray(0, bufferSize);
|
|
160
164
|
if (i % 3 === 0) {
|
|
161
|
-
const decipher =
|
|
162
|
-
|
|
163
|
-
trackKey,
|
|
164
|
-
IV
|
|
165
|
-
).setAutoPadding(false);
|
|
166
|
-
passThrough.write(decipher.update(bufferSized));
|
|
167
|
-
passThrough.write(decipher.final());
|
|
165
|
+
const decipher = Buffer.from(blowfishDecrypter.decode(new Uint8Array(bufferSized), import_blowfish_node.default.TYPE.UINT8_ARRAY));
|
|
166
|
+
passThrough.write(decipher);
|
|
168
167
|
} else {
|
|
169
168
|
passThrough.write(bufferSized);
|
|
170
169
|
}
|
|
@@ -185,9 +184,12 @@ function validate(query) {
|
|
|
185
184
|
}
|
|
186
185
|
|
|
187
186
|
// src/DeezerExtractor.ts
|
|
187
|
+
var Warnings = {
|
|
188
|
+
MissingDecryption: "Decryption Key missing! This is needed for extracting streams."
|
|
189
|
+
};
|
|
188
190
|
var DeezerExtractor = class extends import_discord_player2.BaseExtractor {
|
|
189
191
|
async activate() {
|
|
190
|
-
if (!this.options.decryptionKey) process.emitWarning(
|
|
192
|
+
if (!this.options.decryptionKey) process.emitWarning(Warnings.MissingDecryption);
|
|
191
193
|
else {
|
|
192
194
|
const crypto = await getCrypto();
|
|
193
195
|
const randomToken = crypto.randomBytes(16).toString("hex");
|
|
@@ -229,6 +231,10 @@ var DeezerExtractor = class extends import_discord_player2.BaseExtractor {
|
|
|
229
231
|
});
|
|
230
232
|
}
|
|
231
233
|
async handle(query, context) {
|
|
234
|
+
if (deezerRegex.share.test(query)) {
|
|
235
|
+
const redirect = await fetch(query);
|
|
236
|
+
query = redirect.url;
|
|
237
|
+
}
|
|
232
238
|
const metadata = await (0, import_deezer_music_metadata.getData)(query);
|
|
233
239
|
if (metadata?.type === "song") return this.createResponse(null, [this.buildTrack(metadata, context)]);
|
|
234
240
|
if (metadata?.type === "playlist" || metadata?.type === "album") {
|
|
@@ -263,6 +269,7 @@ DeezerExtractor.identifier = "com.retrouser955.discord-player.deezr-ext";
|
|
|
263
269
|
// Annotate the CommonJS export names for ESM import in node:
|
|
264
270
|
0 && (module.exports = {
|
|
265
271
|
DeezerExtractor,
|
|
272
|
+
Warnings,
|
|
266
273
|
buildTrackFromSearch,
|
|
267
274
|
deezerRegex,
|
|
268
275
|
extractTrackId,
|
package/package.json
CHANGED
|
@@ -1,13 +1,14 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "discord-player-deezer",
|
|
3
|
-
"version": "2.
|
|
3
|
+
"version": "2.1.0",
|
|
4
4
|
"description": "A custom extractor made for discord-player that enables you to extract from Deezer.",
|
|
5
5
|
"main": "dist/index.js",
|
|
6
6
|
"author": "retro_ig",
|
|
7
7
|
"license": "MIT",
|
|
8
8
|
"private": false,
|
|
9
9
|
"dependencies": {
|
|
10
|
-
"@mithron/deezer-music-metadata": "^1.0.3"
|
|
10
|
+
"@mithron/deezer-music-metadata": "^1.0.3",
|
|
11
|
+
"blowfish-node": "^1.1.4"
|
|
11
12
|
},
|
|
12
13
|
"devDependencies": {
|
|
13
14
|
"@discord-player/extractor": "^4.5.1",
|
|
@@ -21,7 +22,8 @@
|
|
|
21
22
|
"scripts": {
|
|
22
23
|
"build": "yarn lint && tsup",
|
|
23
24
|
"lint": "tslint -p tsconfig.json",
|
|
24
|
-
"npm:publish": "yarn build && npm publish --access public"
|
|
25
|
+
"npm:publish": "yarn build && npm publish --access public",
|
|
26
|
+
"prepare": "tsup"
|
|
25
27
|
},
|
|
26
28
|
"repository": {
|
|
27
29
|
"type": "git",
|
package/readme.md
CHANGED
|
@@ -32,12 +32,4 @@ const player = new Player(...)
|
|
|
32
32
|
await player.extractors.register(DeezerExtractor, {
|
|
33
33
|
decryptionKey: "master-decryption-key"
|
|
34
34
|
})
|
|
35
|
-
```
|
|
36
|
-
|
|
37
|
-
# Important information
|
|
38
|
-
|
|
39
|
-
As Node has migrated from openssl for decryption, we must use the `--openssl-legacy-provider` flag when starting our application with stream extraction
|
|
40
|
-
|
|
41
|
-
```bash
|
|
42
|
-
$ node --openssl-legacy-provider yourfile.js
|
|
43
35
|
```
|
|
@@ -0,0 +1,131 @@
|
|
|
1
|
+
import { BaseExtractor, ExtractorSearchContext, ExtractorStreamable, Track, Playlist, Util as DPUtil, ExtractorInfo } from "discord-player"
|
|
2
|
+
import { Playlist as DeezerPlaylist, Track as DeezerTrack, getData } from "@mithron/deezer-music-metadata";
|
|
3
|
+
import { buildTrackFromSearch, deezerRegex, getCrypto, searchOneTrack, streamTrack, validate } from "./utils/util";
|
|
4
|
+
|
|
5
|
+
/**
|
|
6
|
+
* -------------------------------NOTICE-------------------------------------
|
|
7
|
+
* STREAMING CODE IS MAINLY TAKEN FROM https://github.com/PerformanC/NodeLink
|
|
8
|
+
* WHICH HAS THE "BSD 2-Clause "Simplified" License"
|
|
9
|
+
*
|
|
10
|
+
* PLEASE SHOW THE ORIGINAL AUTHOR SUPPORT BY STARING HIS GITHUB REPO
|
|
11
|
+
* --------------------------------------------------------------------------
|
|
12
|
+
*/
|
|
13
|
+
|
|
14
|
+
export type DeezerExtractorOptions = {
|
|
15
|
+
decryptionKey?: string; // needed for decrypting deezer songs
|
|
16
|
+
createStream?: (track: Track, ext: DeezerExtractor) => Promise<ExtractorStreamable>
|
|
17
|
+
}
|
|
18
|
+
|
|
19
|
+
export type DeezerUserInfo = {
|
|
20
|
+
cookie: string;
|
|
21
|
+
licenseToken: string;
|
|
22
|
+
csrfToken: string;
|
|
23
|
+
mediaUrl: string;
|
|
24
|
+
}
|
|
25
|
+
|
|
26
|
+
export const Warnings = {
|
|
27
|
+
MissingDecryption: "Decryption Key missing! This is needed for extracting streams."
|
|
28
|
+
} as const
|
|
29
|
+
export type Warnings = (typeof Warnings)[keyof typeof Warnings]
|
|
30
|
+
|
|
31
|
+
export class DeezerExtractor extends BaseExtractor<DeezerExtractorOptions> {
|
|
32
|
+
static identifier: string = "com.retrouser955.discord-player.deezr-ext"
|
|
33
|
+
userInfo!: DeezerUserInfo
|
|
34
|
+
|
|
35
|
+
async activate(): Promise<void> {
|
|
36
|
+
if(!this.options.decryptionKey) process.emitWarning(Warnings.MissingDecryption)
|
|
37
|
+
else {
|
|
38
|
+
// extract deezer username
|
|
39
|
+
// dynamically load crypto because some might not want streaming
|
|
40
|
+
const crypto = await getCrypto()
|
|
41
|
+
const randomToken = crypto.randomBytes(16).toString("hex")
|
|
42
|
+
const deezerUsrDataUrl = `https://www.deezer.com/ajax/gw-light.php?method=deezer.getUserData&input=3&api_version=1.0&api_token=${randomToken}`
|
|
43
|
+
|
|
44
|
+
const usrDataRes = await fetch(deezerUsrDataUrl)
|
|
45
|
+
const usrData = await usrDataRes.json()
|
|
46
|
+
|
|
47
|
+
const licenseToken = usrData.results.USER.OPTIONS.license_token
|
|
48
|
+
if(typeof licenseToken !== "string") throw new Error("Unable to get licenseToken")
|
|
49
|
+
|
|
50
|
+
const csrfToken = usrData.results.checkForm
|
|
51
|
+
if(typeof csrfToken !== "string") throw new Error("Unable to get csrf token which is required for decryption")
|
|
52
|
+
|
|
53
|
+
this.userInfo = {
|
|
54
|
+
mediaUrl: usrData.results.URL_MEDIA || "https://media.deezer.com",
|
|
55
|
+
cookie: usrDataRes.headers.get("set-cookie")!,
|
|
56
|
+
licenseToken,
|
|
57
|
+
csrfToken
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
this.context.player.debug('USER INFO EXT: ' + JSON.stringify(this.userInfo))
|
|
61
|
+
}
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
async validate(query: string): Promise<boolean> {
|
|
65
|
+
return validate(query)
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
buildPlaylistData(data: DeezerPlaylist, handleContext: ExtractorSearchContext) {
|
|
69
|
+
const raw: string[] = data.url.split("/")
|
|
70
|
+
const identifier: string = raw[raw.length - 1].split("?")[0]
|
|
71
|
+
|
|
72
|
+
return new Playlist(this.context.player, {
|
|
73
|
+
title: data.name,
|
|
74
|
+
thumbnail: data.thumbnail[0].url,
|
|
75
|
+
author: {
|
|
76
|
+
name: data.artist.name,
|
|
77
|
+
url: data.artist.url
|
|
78
|
+
},
|
|
79
|
+
type: data.type,
|
|
80
|
+
tracks: data.tracks.map((v) => this.buildTrack(v, handleContext)),
|
|
81
|
+
description: "",
|
|
82
|
+
source: "arbitrary",
|
|
83
|
+
id: identifier,
|
|
84
|
+
url: data.url
|
|
85
|
+
})
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
async handle(query: string, context: ExtractorSearchContext): Promise<ExtractorInfo> {
|
|
89
|
+
if (deezerRegex.share.test(query)) {
|
|
90
|
+
const redirect = await fetch(query);
|
|
91
|
+
query = redirect.url; // follow the redirect of deezer page links
|
|
92
|
+
}
|
|
93
|
+
const metadata = await getData(query)
|
|
94
|
+
|
|
95
|
+
if(metadata?.type === "song") return this.createResponse(null, [this.buildTrack(metadata, context)])
|
|
96
|
+
if(metadata?.type === "playlist" || metadata?.type === "album") {
|
|
97
|
+
const playlist = this.buildPlaylistData(metadata, context)
|
|
98
|
+
|
|
99
|
+
return this.createResponse(playlist, playlist.tracks)
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
throw new Error("Unable to get data from Deezer")
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
buildTrack(track: DeezerTrack, { requestedBy }: ExtractorSearchContext) {
|
|
106
|
+
return new Track(this.context.player, {
|
|
107
|
+
title: track.name,
|
|
108
|
+
author: track.author.map((v) => v.name).join(", "),
|
|
109
|
+
url: track.url,
|
|
110
|
+
source: "arbitrary",
|
|
111
|
+
thumbnail: track.thumbnail[0].url,
|
|
112
|
+
duration: DPUtil.buildTimeCode(DPUtil.parseMS(track.duration)),
|
|
113
|
+
requestedBy
|
|
114
|
+
})
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
async bridge(track: Track): Promise<ExtractorStreamable | null> {
|
|
118
|
+
const deezerTrack = await searchOneTrack(`${track.author} ${track.source === "youtube" ? track.cleanTitle : track.title}`)
|
|
119
|
+
|
|
120
|
+
if(!deezerTrack) return null
|
|
121
|
+
const dpTrack = buildTrackFromSearch(deezerTrack, this.context.player, track.requestedBy)
|
|
122
|
+
|
|
123
|
+
const stream = this.stream(dpTrack[0])
|
|
124
|
+
|
|
125
|
+
return stream
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
stream(info: Track): Promise<ExtractorStreamable> {
|
|
129
|
+
return streamTrack(info, this)
|
|
130
|
+
}
|
|
131
|
+
}
|
package/src/index.ts
ADDED
|
@@ -0,0 +1,194 @@
|
|
|
1
|
+
import { type Player, Track, Util } from "discord-player";
|
|
2
|
+
import type { DeezerExtractor } from "../DeezerExtractor";
|
|
3
|
+
import { Readable, PassThrough } from 'stream'
|
|
4
|
+
import type { BinaryLike, CipherGCMTypes, CipherKey, Decipher } from "crypto";
|
|
5
|
+
import Blowfish from "blowfish-node";
|
|
6
|
+
|
|
7
|
+
const IV = Buffer.from(Array.from({ length: 8 }, (_, x) => x))
|
|
8
|
+
|
|
9
|
+
let rawCrypto: typeof import("crypto")
|
|
10
|
+
|
|
11
|
+
export async function getCrypto() {
|
|
12
|
+
if (!rawCrypto) {
|
|
13
|
+
rawCrypto = await import("crypto")
|
|
14
|
+
return rawCrypto
|
|
15
|
+
}
|
|
16
|
+
|
|
17
|
+
return rawCrypto
|
|
18
|
+
}
|
|
19
|
+
|
|
20
|
+
const DeezerAPIRoutes = {
|
|
21
|
+
searchTrack(query: string, limit?: number) {
|
|
22
|
+
const url = `https://api.deezer.com/search/track?q=${encodeURIComponent(query)}&${limit ? `limit=${limit}` : ""}`
|
|
23
|
+
|
|
24
|
+
return url
|
|
25
|
+
}
|
|
26
|
+
} as const
|
|
27
|
+
|
|
28
|
+
export type ArrayOrObject<T> = T | T[]
|
|
29
|
+
|
|
30
|
+
export interface DeezerSearchTrackResponse {
|
|
31
|
+
data: {
|
|
32
|
+
link: string,
|
|
33
|
+
title: string,
|
|
34
|
+
album: {
|
|
35
|
+
cover_xl?: string,
|
|
36
|
+
cover_medium?: string,
|
|
37
|
+
cover_small?: string,
|
|
38
|
+
cover?: string
|
|
39
|
+
},
|
|
40
|
+
artist: {
|
|
41
|
+
name: string
|
|
42
|
+
},
|
|
43
|
+
duration: number, // in seconds
|
|
44
|
+
type: "track"
|
|
45
|
+
}[]
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
export function buildTrackFromSearch(track: DeezerSearchTrackResponse, player: Player, requestedBy?: Track['requestedBy']) {
|
|
49
|
+
const tracks = track.data.map((v) => new Track(player, {
|
|
50
|
+
source: "arbitrary",
|
|
51
|
+
duration: Util.buildTimeCode(Util.parseMS(v.duration * 1000)),
|
|
52
|
+
author: Array.isArray(v.artist) ? v.artist.map(a => a.name).join(", ") : v.artist.name,
|
|
53
|
+
url: v.link,
|
|
54
|
+
title: v.title,
|
|
55
|
+
thumbnail: v.album.cover_xl || v.album.cover_medium || v.album.cover || v.album.cover_small || "https://play-lh.googleusercontent.com/xtIOV8iPeAY4GrldTDo3CbLAEpbea2DqnfxaB4Nn2p5qz6KAiumY74qH86pgu1HA1A",
|
|
56
|
+
live: false,
|
|
57
|
+
requestedBy
|
|
58
|
+
}))
|
|
59
|
+
|
|
60
|
+
return tracks
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
export function extractTrackId(query: string) {
|
|
64
|
+
if (!validate(query)) throw new Error("Invalid track url")
|
|
65
|
+
const trackIdWithUrlParams = query.split("/").at(-1)
|
|
66
|
+
if (!trackIdWithUrlParams) throw new Error("Cannot find track ID")
|
|
67
|
+
return trackIdWithUrlParams.split("?")[0]
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
// used for bridging
|
|
71
|
+
export async function searchOneTrack(query: string) {
|
|
72
|
+
const url = DeezerAPIRoutes.searchTrack(query, 1)
|
|
73
|
+
|
|
74
|
+
const trackRes = await fetch(url)
|
|
75
|
+
if (trackRes.status !== 200) throw new Error("Fetch failed")
|
|
76
|
+
|
|
77
|
+
const trackData = await trackRes.json() as DeezerSearchTrackResponse | undefined
|
|
78
|
+
return trackData
|
|
79
|
+
}
|
|
80
|
+
|
|
81
|
+
export async function streamTrack(track: Track, ext: DeezerExtractor) {
|
|
82
|
+
const decryptionKey = ext.options.decryptionKey
|
|
83
|
+
if (!decryptionKey) throw new Error("MISSING DEEZER DECRYPTION KEY") // cant decrypt due to missing key
|
|
84
|
+
|
|
85
|
+
const crypto = await getCrypto()
|
|
86
|
+
const trackId = extractTrackId(track.url)
|
|
87
|
+
|
|
88
|
+
const trackHash = crypto.createHash("md5").update(trackId, "ascii").digest("hex")
|
|
89
|
+
const trackKey = Buffer.alloc(16)
|
|
90
|
+
|
|
91
|
+
for (let iter = 0; iter < 16; iter++)
|
|
92
|
+
/* tslint:disable-next-line no-bitwise */
|
|
93
|
+
trackKey.writeInt8(trackHash[iter].charCodeAt(0) ^ trackHash[iter + 16].charCodeAt(0) ^ decryptionKey[iter].charCodeAt(0), iter)
|
|
94
|
+
|
|
95
|
+
const trackInfoRes = await fetch(`https://www.deezer.com/ajax/gw-light.php?method=song.getListData&input=3&api_version=1.0&api_token=${ext.userInfo.csrfToken}`, {
|
|
96
|
+
method: "POST",
|
|
97
|
+
headers: {
|
|
98
|
+
Cookie: ext.userInfo.cookie,
|
|
99
|
+
'User-Agent': "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:120.0) Gecko/20100101 Firefox/120.0",
|
|
100
|
+
'DNT': '1'
|
|
101
|
+
},
|
|
102
|
+
body: JSON.stringify({
|
|
103
|
+
sng_ids: [trackId]
|
|
104
|
+
})
|
|
105
|
+
})
|
|
106
|
+
|
|
107
|
+
const songInfo = (await trackInfoRes.json()).results.data[0]
|
|
108
|
+
|
|
109
|
+
const streamInfoRes = await fetch('https://media.deezer.com/v1/get_url', {
|
|
110
|
+
method: "POST",
|
|
111
|
+
body: JSON.stringify({
|
|
112
|
+
license_token: ext.userInfo.licenseToken,
|
|
113
|
+
media: [{
|
|
114
|
+
type: 'FULL',
|
|
115
|
+
formats: [{
|
|
116
|
+
cipher: 'BF_CBC_STRIPE',
|
|
117
|
+
format: 'FLAC'
|
|
118
|
+
}, {
|
|
119
|
+
cipher: 'BF_CBC_STRIPE',
|
|
120
|
+
format: 'MP3_256'
|
|
121
|
+
}, {
|
|
122
|
+
cipher: 'BF_CBC_STRIPE',
|
|
123
|
+
format: 'MP3_128'
|
|
124
|
+
}, {
|
|
125
|
+
cipher: 'BF_CBC_STRIPE',
|
|
126
|
+
format: 'MP3_MISC'
|
|
127
|
+
}]
|
|
128
|
+
}],
|
|
129
|
+
track_tokens: [songInfo.TRACK_TOKEN]
|
|
130
|
+
})
|
|
131
|
+
})
|
|
132
|
+
const streamInfo = await streamInfoRes.json()
|
|
133
|
+
|
|
134
|
+
const trackMediaUrl = streamInfo.data[0].media[0].sources[0].url
|
|
135
|
+
|
|
136
|
+
ext.context.player.debug("DEEZER FOUND MEDIA URL " + trackMediaUrl)
|
|
137
|
+
|
|
138
|
+
const trackReq = await fetch(trackMediaUrl)
|
|
139
|
+
// @ts-ignore
|
|
140
|
+
const readable = Readable.fromWeb(trackReq.body)
|
|
141
|
+
let buffer = Buffer.alloc(0)
|
|
142
|
+
let i = 0
|
|
143
|
+
|
|
144
|
+
const bufferSize = 2048 // 2mb
|
|
145
|
+
|
|
146
|
+
const passThrough = new PassThrough()
|
|
147
|
+
|
|
148
|
+
readable.on("readable", () => {
|
|
149
|
+
let chunk = null;
|
|
150
|
+
while (true) {
|
|
151
|
+
chunk = readable.read(bufferSize)
|
|
152
|
+
|
|
153
|
+
if (!chunk) {
|
|
154
|
+
if (readable.readableLength) {
|
|
155
|
+
chunk = readable.read(readable.readableLength)
|
|
156
|
+
buffer = Buffer.concat([buffer, chunk])
|
|
157
|
+
}
|
|
158
|
+
break;
|
|
159
|
+
} else {
|
|
160
|
+
buffer = Buffer.concat([buffer, chunk])
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
const blowfishDecrypter = new Blowfish(new Uint8Array(trackKey), Blowfish.MODE.CBC, Blowfish.PADDING.NULL)
|
|
164
|
+
blowfishDecrypter.setIv(new Uint8Array(IV))
|
|
165
|
+
|
|
166
|
+
while (buffer.length >= bufferSize) {
|
|
167
|
+
const bufferSized = buffer.subarray(0, bufferSize)
|
|
168
|
+
|
|
169
|
+
if (i % 3 === 0) {
|
|
170
|
+
const decipher = Buffer.from(blowfishDecrypter.decode(new Uint8Array(bufferSized), Blowfish.TYPE.UINT8_ARRAY))
|
|
171
|
+
passThrough.write(decipher)
|
|
172
|
+
} else {
|
|
173
|
+
passThrough.write(bufferSized)
|
|
174
|
+
}
|
|
175
|
+
|
|
176
|
+
i++
|
|
177
|
+
|
|
178
|
+
buffer = buffer.subarray(bufferSize)
|
|
179
|
+
}
|
|
180
|
+
}
|
|
181
|
+
})
|
|
182
|
+
|
|
183
|
+
return passThrough
|
|
184
|
+
}
|
|
185
|
+
|
|
186
|
+
export const deezerRegex = {
|
|
187
|
+
track: /(^https:)\/\/(www\.)?deezer.com\/([a-zA-Z]+\/)?track\/[0-9]+/,
|
|
188
|
+
playlistNalbums: /(^https:)\/\/(www\.)?deezer.com\/[a-zA-Z]+\/(playlist|album)\/[0-9]+(\?)?(.*)/,
|
|
189
|
+
share: /(^https:)\/\/deezer\.page\.link\/[A-Za-z0-9]+/
|
|
190
|
+
} as const;
|
|
191
|
+
|
|
192
|
+
export function validate(query: string) {
|
|
193
|
+
return deezerRegex.track.test(query) ?? deezerRegex.playlistNalbums.test(query) ?? deezerRegex.share.test(query)
|
|
194
|
+
}
|