janisslsm/john-nuvio
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
27a87191c3d2d544a8585c50cb6a34ab4f1566e7
john-nuvio/providers/flixer.js
T

764 lines
26 KiB
JavaScript
Raw Blame History

/**
* flixer - Built from src/flixer/
* Generated: 2026-07-19T17:21:01.894Z
*/
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __async = (__this, __arguments, generator) => {
return new Promise((resolve, reject) => {
var fulfilled = (value) => {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
};
var rejected = (value) => {
try {
step(generator.throw(value));
} catch (e) {
reject(e);
}
};
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
step((generator = generator.apply(__this, __arguments)).next());
});
};
// src/flixer/http.js
var SITE_URL = "https://flixer.gd";
var API_URL = "https://plsdontscrapemelove.flixer.gd";
var HEADERS = {
"Accept": "text/plain",
"Origin": SITE_URL,
"Referer": `${SITE_URL}/`,
"User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36"
};
var BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
var SHA256_CONSTANTS = [
1116352408,
1899447441,
3049323471,
3921009573,
961987163,
1508970993,
2453635748,
2870763221,
3624381080,
310598401,
607225278,
1426881987,
1925078388,
2162078206,
2614888103,
3248222580,
3835390401,
4022224774,
264347078,
604807628,
770255983,
1249150122,
1555081692,
1996064986,
2554220882,
2821834349,
2952996808,
3210313671,
3336571891,
3584528711,
113926993,
338241895,
666307205,
773529912,
1294757372,
1396182291,
1695183700,
1986661051,
2177026350,
2456956037,
2730485921,
2820302411,
3259730800,
3345764771,
3516065817,
3600352804,
4094571909,
275423344,
430227734,
506948616,
659060556,
883997877,
958139571,
1322822218,
1537002063,
1747873779,
1955562222,
2024104815,
2227730452,
2361852424,
2428436474,
2756734187,
3204031479,
3329325298
];
function encodeUtf8(value) {
const bytes = [];
for (let index = 0; index < value.length; index++) {
let codePoint = value.charCodeAt(index);
if (codePoint >= 55296 && codePoint <= 56319 && index + 1 < value.length) {
const trailing = value.charCodeAt(index + 1);
if (trailing >= 56320 && trailing <= 57343) {
codePoint = 65536 + (codePoint - 55296 << 10) + trailing - 56320;
index++;
}
}
if (codePoint < 128)
bytes.push(codePoint);
else if (codePoint < 2048)
bytes.push(192 | codePoint >> 6, 128 | codePoint & 63);
else if (codePoint < 65536)
bytes.push(224 | codePoint >> 12, 128 | codePoint >> 6 & 63, 128 | codePoint & 63);
else
bytes.push(240 | codePoint >> 18, 128 | codePoint >> 12 & 63, 128 | codePoint >> 6 & 63, 128 | codePoint & 63);
}
return new Uint8Array(bytes);
}
function rotateRight(value, amount) {
return value >>> amount | value << 32 - amount;
}
function sha256(input) {
const bitLength = input.length * 8;
const paddedLength = Math.ceil((input.length + 9) / 64) * 64;
const bytes = new Uint8Array(paddedLength);
bytes.set(input);
bytes[input.length] = 128;
const high = Math.floor(bitLength / 4294967296);
const low = bitLength >>> 0;
const end = paddedLength - 8;
bytes[end] = high >>> 24 & 255;
bytes[end + 1] = high >>> 16 & 255;
bytes[end + 2] = high >>> 8 & 255;
bytes[end + 3] = high & 255;
bytes[end + 4] = low >>> 24 & 255;
bytes[end + 5] = low >>> 16 & 255;
bytes[end + 6] = low >>> 8 & 255;
bytes[end + 7] = low & 255;
const hash = [1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225];
const words = new Uint32Array(64);
for (let offset = 0; offset < bytes.length; offset += 64) {
for (let index = 0; index < 16; index++) {
const position = offset + index * 4;
words[index] = (bytes[position] << 24 | bytes[position + 1] << 16 | bytes[position + 2] << 8 | bytes[position + 3]) >>> 0;
}
for (let index = 16; index < 64; index++) {
const first = rotateRight(words[index - 15], 7) ^ rotateRight(words[index - 15], 18) ^ words[index - 15] >>> 3;
const second = rotateRight(words[index - 2], 17) ^ rotateRight(words[index - 2], 19) ^ words[index - 2] >>> 10;
words[index] = words[index - 16] + first + words[index - 7] + second >>> 0;
}
let [a, b, c, d, e, f, g, h] = hash;
for (let index = 0; index < 64; index++) {
const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
const choice = e & f ^ ~e & g;
const temporary1 = h + sum1 + choice + SHA256_CONSTANTS[index] + words[index] >>> 0;
const sum0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
const majority = a & b ^ a & c ^ b & c;
const temporary2 = sum0 + majority >>> 0;
h = g;
g = f;
f = e;
e = d + temporary1 >>> 0;
d = c;
c = b;
b = a;
a = temporary1 + temporary2 >>> 0;
}
hash[0] = hash[0] + a >>> 0;
hash[1] = hash[1] + b >>> 0;
hash[2] = hash[2] + c >>> 0;
hash[3] = hash[3] + d >>> 0;
hash[4] = hash[4] + e >>> 0;
hash[5] = hash[5] + f >>> 0;
hash[6] = hash[6] + g >>> 0;
hash[7] = hash[7] + h >>> 0;
}
const output = new Uint8Array(32);
for (let index = 0; index < hash.length; index++) {
output[index * 4] = hash[index] >>> 24 & 255;
output[index * 4 + 1] = hash[index] >>> 16 & 255;
output[index * 4 + 2] = hash[index] >>> 8 & 255;
output[index * 4 + 3] = hash[index] & 255;
}
return output;
}
function hmacSha256(key, message) {
let keyBytes = key instanceof Uint8Array ? key : encodeUtf8(String(key));
if (keyBytes.length > 64)
keyBytes = sha256(keyBytes);
const messageBytes = message instanceof Uint8Array ? message : encodeUtf8(String(message));
const inner = new Uint8Array(64 + messageBytes.length);
const outer = new Uint8Array(96);
for (let index = 0; index < 64; index++) {
const value = index < keyBytes.length ? keyBytes[index] : 0;
inner[index] = value ^ 54;
outer[index] = value ^ 92;
}
inner.set(messageBytes, 64);
outer.set(sha256(inner), 64);
return sha256(outer);
}
function encodeBase64(bytes) {
let output = "";
for (let index = 0; index < bytes.length; index += 3) {
const secondExists = index + 1 < bytes.length;
const thirdExists = index + 2 < bytes.length;
const value = bytes[index] << 16 | (secondExists ? bytes[index + 1] : 0) << 8 | (thirdExists ? bytes[index + 2] : 0);
output += BASE64_ALPHABET[value >>> 18 & 63];
output += BASE64_ALPHABET[value >>> 12 & 63];
output += secondExists ? BASE64_ALPHABET[value >>> 6 & 63] : "=";
output += thirdExists ? BASE64_ALPHABET[value & 63] : "=";
}
return output;
}
function createNonce() {
const bytes = new Uint8Array(16);
for (let index = 0; index < bytes.length; index++)
bytes[index] = Math.floor(Math.random() * 256);
return encodeBase64(bytes).replace(/[/+=]/g, "").slice(0, 22);
}
var serverTimeOffset = 0;
var serverTimeFetchedAt = 0;
function getServerTimestamp() {
return __async(this, null, function* () {
const now = Date.now();
if (serverTimeFetchedAt && now - serverTimeFetchedAt < 3e5) {
return Math.floor((now + serverTimeOffset) / 1e3);
}
try {
const startedAt = Date.now();
const response = yield fetch(`${API_URL}/api/time?t=${startedAt}`, {
headers: __spreadProps(__spreadValues({}, HEADERS), { "Cache-Control": "no-cache" })
});
if (!response.ok)
throw new Error(`HTTP ${response.status}`);
const payload = yield response.json();
if (!payload || typeof payload.timestamp !== "number")
throw new Error("invalid response");
const finishedAt = Date.now();
serverTimeOffset = payload.timestamp * 1e3 + (finishedAt - startedAt) / 2 - finishedAt;
serverTimeFetchedAt = finishedAt;
return Math.floor((finishedAt + serverTimeOffset) / 1e3);
} catch (_) {
return Math.floor(Date.now() / 1e3);
}
});
}
function createSecureHeaders(apiKey, path) {
return __async(this, null, function* () {
const timestamp = yield getServerTimestamp();
const nonce = createNonce();
const message = `${apiKey}:${timestamp}:${nonce}:${path}`;
return {
"X-Api-Key": apiKey,
"X-Request-Timestamp": String(timestamp),
"X-Request-Nonce": nonce,
"X-Request-Signature": encodeBase64(hmacSha256(apiKey, message)),
"X-Client-Fingerprint": "zerlgt",
"X-Fingerprint-Lite": "e9136c41504646444"
};
});
}
function fetchText(_0) {
return __async(this, arguments, function* (url, options = {}) {
const response = yield fetch(url, __spreadProps(__spreadValues({}, options), {
headers: __spreadValues(__spreadValues({}, HEADERS), options.headers || {})
}));
if (!response.ok)
throw new Error(`HTTP ${response.status} for ${url}`);
return yield response.text();
});
}
// src/flixer/decoder.js
var CANVAS_FINGERPRINT = "iVBORw0KGgoAAAANSUhEUgAAAMgAAAAyCAYAAAAZUZThAAAQAE";
function concatBytes(...values) {
let length = 0;
for (const value of values)
length += value.length;
const result = new Uint8Array(length);
let offset = 0;
for (const value of values) {
result.set(value, offset);
offset += value.length;
}
return result;
}
function toHex(bytes) {
let result = "";
for (const value of bytes)
result += value.toString(16).padStart(2, "0");
return result;
}
function decodeBase64(value) {
const binary = atob(value);
const bytes = new Uint8Array(binary.length);
for (let index = 0; index < binary.length; index++)
bytes[index] = binary.charCodeAt(index);
return bytes;
}
function decodeUtf8(bytes) {
let result = "";
for (let index = 0; index < bytes.length; ) {
const first = bytes[index++];
let codePoint;
if (first < 128)
codePoint = first;
else if ((first & 224) === 192)
codePoint = (first & 31) << 6 | bytes[index++] & 63;
else if ((first & 240) === 224) {
codePoint = (first & 15) << 12 | (bytes[index++] & 63) << 6 | bytes[index++] & 63;
} else {
codePoint = (first & 7) << 18 | (bytes[index++] & 63) << 12 | (bytes[index++] & 63) << 6 | bytes[index++] & 63;
}
if (codePoint <= 65535)
result += String.fromCharCode(codePoint);
else {
codePoint -= 65536;
result += String.fromCharCode(55296 | codePoint >>> 10, 56320 | codePoint & 1023);
}
}
return result;
}
function multiplyByte(first, second) {
let result = 0;
for (let index = 0; index < 8; index++) {
if (second & 1)
result ^= first;
first = (first << 1 ^ (first & 128 ? 283 : 0)) & 255;
second >>>= 1;
}
return result;
}
function inverseByte(value) {
if (!value)
return 0;
let result = 1;
let base = value;
let power = 254;
while (power) {
if (power & 1)
result = multiplyByte(result, base);
base = multiplyByte(base, base);
power >>>= 1;
}
return result;
}
function rotateByte(value, amount) {
return (value << amount | value >>> 8 - amount) & 255;
}
var AES_SBOX = (() => {
const result = new Uint8Array(256);
for (let index = 0; index < 256; index++) {
const value = inverseByte(index);
result[index] = value ^ rotateByte(value, 1) ^ rotateByte(value, 2) ^ rotateByte(value, 3) ^ rotateByte(value, 4) ^ 99;
}
return result;
})();
function expandAes256Key(key) {
if (key.length !== 32)
throw new Error("Invalid AES-256 key");
const words = new Uint32Array(60);
for (let index = 0; index < 8; index++) {
const offset = index * 4;
words[index] = (key[offset] << 24 | key[offset + 1] << 16 | key[offset + 2] << 8 | key[offset + 3]) >>> 0;
}
let roundConstant = 1;
for (let index = 8; index < words.length; index++) {
let temporary = words[index - 1];
if (index % 8 === 0) {
temporary = (temporary << 8 | temporary >>> 24) >>> 0;
temporary = (AES_SBOX[temporary >>> 24] << 24 | AES_SBOX[temporary >>> 16 & 255] << 16 | AES_SBOX[temporary >>> 8 & 255] << 8 | AES_SBOX[temporary & 255]) >>> 0;
temporary ^= roundConstant << 24;
roundConstant = (roundConstant << 1 ^ (roundConstant & 128 ? 283 : 0)) & 255;
} else if (index % 8 === 4) {
temporary = (AES_SBOX[temporary >>> 24] << 24 | AES_SBOX[temporary >>> 16 & 255] << 16 | AES_SBOX[temporary >>> 8 & 255] << 8 | AES_SBOX[temporary & 255]) >>> 0;
}
words[index] = (words[index - 8] ^ temporary) >>> 0;
}
return words;
}
function addRoundKey(state, words, round) {
for (let column = 0; column < 4; column++) {
const word = words[round * 4 + column];
state[column * 4] ^= word >>> 24;
state[column * 4 + 1] ^= word >>> 16 & 255;
state[column * 4 + 2] ^= word >>> 8 & 255;
state[column * 4 + 3] ^= word & 255;
}
}
function encryptAesBlock(input, words) {
const state = new Uint8Array(input);
const shifted = new Uint8Array(16);
addRoundKey(state, words, 0);
for (let round = 1; round <= 14; round++) {
for (let index = 0; index < 16; index++)
state[index] = AES_SBOX[state[index]];
for (let row = 0; row < 4; row++) {
for (let column = 0; column < 4; column++) {
shifted[row + column * 4] = state[row + (column + row & 3) * 4];
}
}
state.set(shifted);
if (round !== 14) {
for (let column = 0; column < 4; column++) {
const offset = column * 4;
const first = state[offset];
const second = state[offset + 1];
const third = state[offset + 2];
const fourth = state[offset + 3];
const combined = first ^ second ^ third ^ fourth;
state[offset] ^= combined ^ multiplyByte(first ^ second, 2);
state[offset + 1] ^= combined ^ multiplyByte(second ^ third, 2);
state[offset + 2] ^= combined ^ multiplyByte(third ^ fourth, 2);
state[offset + 3] ^= combined ^ multiplyByte(fourth ^ first, 2);
}
}
addRoundKey(state, words, round);
}
return state;
}
function bytesToWords(bytes) {
const result = new Uint32Array(4);
for (let index = 0; index < 4; index++) {
const offset = index * 4;
result[index] = (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
}
return result;
}
function wordsToBytes(words) {
const result = new Uint8Array(16);
for (let index = 0; index < 4; index++) {
result[index * 4] = words[index] >>> 24;
result[index * 4 + 1] = words[index] >>> 16 & 255;
result[index * 4 + 2] = words[index] >>> 8 & 255;
result[index * 4 + 3] = words[index] & 255;
}
return result;
}
function multiplyGhash(first, second) {
const result = new Uint32Array(4);
const value = new Uint32Array(second);
for (let bit = 0; bit < 128; bit++) {
if (first[bit >>> 5] >>> 31 - (bit & 31) & 1) {
for (let index = 0; index < 4; index++)
result[index] ^= value[index];
}
const lowBit = value[3] & 1;
value[3] = (value[3] >>> 1 | (value[2] & 1) << 31) >>> 0;
value[2] = (value[2] >>> 1 | (value[1] & 1) << 31) >>> 0;
value[1] = (value[1] >>> 1 | (value[0] & 1) << 31) >>> 0;
value[0] >>>= 1;
if (lowBit)
value[0] = (value[0] ^ 3774873600) >>> 0;
}
return result;
}
function calculateGhash(ciphertext, hashKey) {
let state = new Uint32Array(4);
for (let offset = 0; offset < ciphertext.length; offset += 16) {
const block = new Uint8Array(16);
block.set(ciphertext.subarray(offset, Math.min(offset + 16, ciphertext.length)));
const words = bytesToWords(block);
for (let index = 0; index < 4; index++)
state[index] ^= words[index];
state = multiplyGhash(state, hashKey);
}
const lengthBlock = new Uint8Array(16);
const bitLength = ciphertext.length * 8;
const view = new DataView(lengthBlock.buffer);
view.setUint32(12, bitLength >>> 0);
view.setUint32(8, Math.floor(bitLength / 4294967296));
const lengths = bytesToWords(lengthBlock);
for (let index = 0; index < 4; index++)
state[index] ^= lengths[index];
return multiplyGhash(state, hashKey);
}
function incrementCounter(counter) {
for (let index = 15; index >= 12; index--) {
counter[index] = counter[index] + 1 & 255;
if (counter[index])
break;
}
}
function decryptAesGcm(payload, key) {
if (payload.length < 28)
throw new Error("Invalid encrypted payload");
const nonce = payload.subarray(0, 12);
const ciphertext = payload.subarray(12, payload.length - 16);
const expectedTag = payload.subarray(payload.length - 16);
const words = expandAes256Key(key);
const zero = new Uint8Array(16);
const hashKey = bytesToWords(encryptAesBlock(zero, words));
const initialCounter = new Uint8Array(16);
initialCounter.set(nonce);
initialCounter[15] = 1;
const authentication = wordsToBytes(calculateGhash(ciphertext, hashKey));
const encryptedCounter = encryptAesBlock(initialCounter, words);
let mismatch = 0;
for (let index = 0; index < 16; index++)
mismatch |= authentication[index] ^ encryptedCounter[index] ^ expectedTag[index];
if (mismatch)
throw new Error("Invalid encrypted payload tag");
const output = new Uint8Array(ciphertext.length);
const counter = new Uint8Array(initialCounter);
for (let offset = 0; offset < ciphertext.length; offset += 16) {
incrementCounter(counter);
const stream = encryptAesBlock(counter, words);
const length = Math.min(16, ciphertext.length - offset);
for (let index = 0; index < length; index++)
output[offset + index] = ciphertext[offset + index] ^ stream[index];
}
return output;
}
function derivePayloadKey(apiKey, now) {
const hour = Math.floor(now / 36e5);
const dynamic = new Uint8Array(16);
for (let index = 0; index < dynamic.length; index++) {
dynamic[index] = index + 1 ^ Math.floor(hour / 2 ** (index & 7)) & 255;
}
let derived = concatBytes(encodeUtf8(apiKey), dynamic);
for (let iteration = 0; iteration < 600; iteration++)
derived = sha256(derived);
const timeBucket = Math.floor(now / 3e5);
return hmacSha256(derived, `${timeBucket}${apiKey}`);
}
function initDecoder() {
return true;
}
function get_img_key() {
const timestamp = Math.floor(Date.now() / 1e3);
const fingerprint = `1365x768:24:Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36:Linux x86_64:en-US:-180:${timestamp}:${CANVAS_FINGERPRINT}`;
return toHex(sha256(encodeUtf8(toHex(sha256(encodeUtf8(fingerprint))))));
}
function process_img_data(value, apiKey) {
const key = derivePayloadKey(apiKey, Date.now());
return decodeUtf8(decryptAesGcm(decodeBase64(value), key));
}
// src/flixer/extractor.js
var NATO_ORDER = [
"alpha",
"bravo",
"charlie",
"delta",
"echo",
"foxtrot",
"golf",
"hotel",
"india",
"juliet",
"kilo",
"lima",
"mike",
"november",
"oscar",
"papa",
"quebec",
"romeo",
"sierra",
"tango",
"uniform",
"victor",
"whiskey",
"xray",
"yankee",
"zulu"
];
var SERVER_LABELS = {
bravo: "Balder",
delta: "Dionysus",
echo: "Eros",
golf: "Gaia",
hotel: "Hades",
india: "Isis",
juliet: "Juno",
kilo: "Kronos",
lima: "Loki"
};
var TMDB_ID_CACHE = {};
function resolveTmdbId(id, mediaType) {
return __async(this, null, function* () {
if (/^\d+$/.test(id))
return id;
if (!/^tt\d+$/i.test(id))
return null;
const cacheKey = `${mediaType}:${id.toLowerCase()}`;
if (TMDB_ID_CACHE[cacheKey])
return TMDB_ID_CACHE[cacheKey];
const catalogType = mediaType === "movie" ? "movie" : "series";
try {
const raw = yield fetchText(`https://v3-cinemeta.strem.io/meta/${catalogType}/${encodeURIComponent(id)}.json`, {
headers: { "Accept": "application/json" }
});
const payload = JSON.parse(raw);
const resolved = payload && payload.meta && payload.meta.moviedb_id;
if (!resolved || !/^\d+$/.test(String(resolved)))
return null;
TMDB_ID_CACHE[cacheKey] = String(resolved);
console.log(`[Flixer] Resolved ${id} to TMDB ${resolved}`);
return TMDB_ID_CACHE[cacheKey];
} catch (error) {
console.warn(`[Flixer] Could not resolve IMDb ID ${id}: ${error && error.message ? error.message : String(error)}`);
return null;
}
});
}
function buildApiPath(tmdbId, mediaType, season, episode) {
if (mediaType === "movie")
return `/api/tmdb/movie/${encodeURIComponent(tmdbId)}/images`;
return `/api/tmdb/tv/${encodeURIComponent(tmdbId)}/season/${season}/episode/${episode}/images`;
}
function decryptPayload(encrypted, apiKey) {
return __async(this, null, function* () {
const clearText = yield process_img_data(encrypted, apiKey);
return JSON.parse(clearText);
});
}
function getServers(payload) {
const values = [];
if (payload && Array.isArray(payload.sources)) {
for (const source of payload.sources) {
const server = source && String(source.server || "").toLowerCase();
if (server && !values.includes(server))
values.push(server);
}
}
if (payload && payload.servers && typeof payload.servers === "object") {
for (const server of Object.keys(payload.servers)) {
const normalized = server.toLowerCase();
if (!values.includes(normalized))
values.push(normalized);
}
}
return NATO_ORDER.filter((server) => values.includes(server)).concat(values.filter((server) => !NATO_ORDER.includes(server)));
}
function findUrl(payload, server) {
if (payload && Array.isArray(payload.sources)) {
const exact = payload.sources.find((source) => source && String(source.server || "").toLowerCase() === server);
const candidate = exact || payload.sources.find((source) => source && source.url);
return candidate && typeof candidate.url === "string" ? candidate.url.trim() : "";
}
if (payload && payload.sources && typeof payload.sources === "object") {
const value = payload.sources.file || payload.sources.url;
return typeof value === "string" ? value.trim() : "";
}
return "";
}
function getQuality(url) {
const match = String(url).match(/(?:^|[^0-9])(2160|1440|1080|720|480|360)p?(?:[^0-9]|$)/i);
return match ? `${match[1]}p` : "Auto";
}
function fetchServerPayload(apiUrl, apiPath, apiKey, server) {
return __async(this, null, function* () {
const secureHeaders = yield createSecureHeaders(apiKey, apiPath);
return yield fetchText(apiUrl, {
headers: __spreadProps(__spreadValues({}, secureHeaders), {
"X-Only-Sources": "1",
"X-Server": server
})
});
});
}
function extractStreams(tmdbId, mediaType, season, episode) {
return __async(this, null, function* () {
const id = String(tmdbId || "").trim();
if (mediaType !== "movie" && mediaType !== "tv")
return [];
if (mediaType === "tv" && (!Number.isInteger(Number(season)) || !Number.isInteger(Number(episode)) || Number(season) < 1 || Number(episode) < 1))
return [];
const resolvedId = yield resolveTmdbId(id, mediaType);
if (!resolvedId)
return [];
initDecoder();
const apiKey = get_img_key();
const apiPath = buildApiPath(resolvedId, mediaType, Number(season), Number(episode));
const apiUrl = `${API_URL}${apiPath}`;
const secureHeaders = yield createSecureHeaders(apiKey, apiPath);
const serverPayload = yield fetchText(apiUrl, {
headers: __spreadProps(__spreadValues({}, secureHeaders), { bW90aGFmYWth: "1" })
});
const servers = getServers(yield decryptPayload(serverPayload, apiKey));
const encryptedResponses = yield Promise.all(servers.map((server) => __async(this, null, function* () {
try {
return { server, encrypted: yield fetchServerPayload(apiUrl, apiPath, apiKey, server) };
} catch (error) {
console.warn(`[Flixer] ${server} request failed: ${error && error.message ? error.message : String(error)}`);
return { server, encrypted: "" };
}
})));
const streams = [];
const seenUrls = {};
for (const response of encryptedResponses) {
if (!response.encrypted)
continue;
try {
const url = findUrl(yield decryptPayload(response.encrypted, apiKey), response.server);
if (!url || seenUrls[url])
continue;
seenUrls[url] = true;
const label = SERVER_LABELS[response.server] || response.server.charAt(0).toUpperCase() + response.server.slice(1);
const quality = getQuality(url);
streams.push({
name: `Flixer \xB7 ${label}`,
title: `${label} \xB7 ${quality}`,
url,
quality,
headers: {
"Referer": `${SITE_URL}/`,
"Origin": SITE_URL,
"User-Agent": HEADERS["User-Agent"]
}
});
} catch (error) {
const message = error && error.message ? error.message : String(error);
if (!/^E5[678]$/.test(message)) {
console.warn(`[Flixer] ${response.server} decode failed: ${message}`);
}
}
}
return streams;
});
}
// src/flixer/index.js
function getStreams(tmdbId, mediaType, season, episode) {
return __async(this, null, function* () {
try {
console.log(`[Flixer] Request: ${mediaType} ${tmdbId}`);
const streams = yield extractStreams(tmdbId, mediaType, season, episode);
console.log(`[Flixer] Found ${streams.length} stream(s)`);
return streams;
} catch (error) {
console.error(`[Flixer] Error: ${error.message}`);
return [];
}
});
}
module.exports = { getStreams };
Reference in new issue View Git Blame Copy Permalink