aka paul
687 lines
17 KiB
JavaScript
687 lines
17 KiB
JavaScript
// ShizaProject module for Sora (AsyncJS)
|
|
// Author: emp0ry
|
|
// Version: 1.0.0
|
|
|
|
const SITE_BASES = [
|
|
"https://shizaproject.com",
|
|
"https://shiza-project.com"
|
|
];
|
|
|
|
const SITE_BASE = SITE_BASES[0];
|
|
const DEFAULT_SUBTITLE = "https://none.com";
|
|
|
|
function _ua() {
|
|
return "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
|
|
}
|
|
|
|
function _safeJsonParse(value, fallback) {
|
|
try {
|
|
return JSON.parse(value);
|
|
} catch (_) {
|
|
return fallback;
|
|
}
|
|
}
|
|
|
|
function _cleanBase(base) {
|
|
const raw = String(base || SITE_BASE).trim().replace(/\/+$/, "");
|
|
return raw || SITE_BASE;
|
|
}
|
|
|
|
function _normalizeUrl(url) {
|
|
const raw = String(url || "").trim();
|
|
if (!raw) return "";
|
|
if (raw.startsWith("//")) return "https:" + raw;
|
|
return raw;
|
|
}
|
|
|
|
function _packRelease(payload) {
|
|
return "shizaproject-release:" + encodeURIComponent(JSON.stringify(payload || {}));
|
|
}
|
|
|
|
function _unpackRelease(href) {
|
|
const raw = String(href || "");
|
|
if (!raw.startsWith("shizaproject-release:")) return null;
|
|
return _safeJsonParse(decodeURIComponent(raw.slice("shizaproject-release:".length)), null);
|
|
}
|
|
|
|
function _packEpisode(payload) {
|
|
return "shizaproject:" + encodeURIComponent(JSON.stringify(payload || {}));
|
|
}
|
|
|
|
function _unpackEpisode(href) {
|
|
const raw = String(href || "");
|
|
if (!raw.startsWith("shizaproject:")) return null;
|
|
return _safeJsonParse(decodeURIComponent(raw.slice("shizaproject:".length)), null);
|
|
}
|
|
|
|
function _extractSlug(input) {
|
|
const packed = _unpackRelease(input);
|
|
if (packed?.slug) return String(packed.slug);
|
|
|
|
const raw = String(input || "").trim();
|
|
if (!raw) return "";
|
|
|
|
try {
|
|
const u = new URL(raw);
|
|
const parts = u.pathname.split("/").filter(Boolean);
|
|
return parts[parts.length - 1] || raw;
|
|
} catch (_) {}
|
|
|
|
return raw;
|
|
}
|
|
|
|
function _extractPreferredBase(input) {
|
|
const packed = _unpackRelease(input);
|
|
if (packed?.siteBase) return _cleanBase(packed.siteBase);
|
|
|
|
const raw = String(input || "").trim();
|
|
if (!raw) return SITE_BASE;
|
|
|
|
try {
|
|
const u = new URL(raw);
|
|
return _cleanBase(u.origin);
|
|
} catch (_) {}
|
|
|
|
return SITE_BASE;
|
|
}
|
|
|
|
function _orderedBases(preferredBase) {
|
|
const out = [];
|
|
|
|
const add = (base) => {
|
|
const clean = _cleanBase(base);
|
|
if (clean && !out.includes(clean)) out.push(clean);
|
|
};
|
|
|
|
if (preferredBase) add(preferredBase);
|
|
for (const base of SITE_BASES) add(base);
|
|
|
|
return out;
|
|
}
|
|
|
|
function _graphqlHeaders(base) {
|
|
const site = _cleanBase(base);
|
|
|
|
return {
|
|
"Content-Type": "application/json",
|
|
"Accept": "application/json",
|
|
"User-Agent": _ua(),
|
|
"Origin": site,
|
|
"Referer": site + "/"
|
|
};
|
|
}
|
|
|
|
async function _graphqlOnBase(base, operationName, variables, query) {
|
|
const site = _cleanBase(base);
|
|
const body = JSON.stringify({ operationName, variables, query });
|
|
|
|
const response = await fetchv2(site + "/graphql", _graphqlHeaders(site), "POST", body);
|
|
const data = await response.json();
|
|
|
|
if (data?.errors?.length) throw new Error("GraphQL error");
|
|
|
|
return {
|
|
data: data?.data || {},
|
|
siteBase: site
|
|
};
|
|
}
|
|
|
|
async function _graphql(operationName, variables, query, preferredBase) {
|
|
let lastError = null;
|
|
|
|
for (const base of _orderedBases(preferredBase)) {
|
|
try {
|
|
return await _graphqlOnBase(base, operationName, variables, query);
|
|
} catch (e) {
|
|
lastError = e;
|
|
}
|
|
}
|
|
|
|
throw lastError || new Error("All ShizaProject domains failed");
|
|
}
|
|
|
|
const SEARCH_QUERY = `
|
|
query search($query: String!, $type: SearchType!) {
|
|
search(query: $query, type: $type, first: 10) {
|
|
edges {
|
|
node {
|
|
id
|
|
__typename
|
|
... on Release {
|
|
id
|
|
slug
|
|
name
|
|
originalName
|
|
airedOn
|
|
releasedOn
|
|
publishedAt
|
|
announcement
|
|
episodesCount
|
|
episodesAired
|
|
episodeDuration
|
|
season
|
|
seasonYear
|
|
seasonNumber
|
|
status
|
|
activity
|
|
type
|
|
rating
|
|
viewCount
|
|
score
|
|
genres {
|
|
id
|
|
slug
|
|
name
|
|
__typename
|
|
}
|
|
__typename
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}`;
|
|
|
|
const RELEASE_QUERY = `
|
|
query releaseAllSafe($slug: String!) {
|
|
release(slug: $slug) {
|
|
__typename
|
|
id
|
|
slug
|
|
name
|
|
originalName
|
|
airedOn
|
|
releasedOn
|
|
publishedAt
|
|
announcement
|
|
episodesCount
|
|
episodesAired
|
|
episodeDuration
|
|
season
|
|
seasonYear
|
|
seasonNumber
|
|
status
|
|
activity
|
|
type
|
|
rating
|
|
viewCount
|
|
score
|
|
genres {
|
|
id
|
|
slug
|
|
name
|
|
__typename
|
|
}
|
|
episodes {
|
|
__typename
|
|
id
|
|
number
|
|
name
|
|
duration
|
|
videos {
|
|
id
|
|
embedUrl
|
|
__typename
|
|
}
|
|
}
|
|
}
|
|
}`;
|
|
|
|
async function _getRelease(slug, preferredBase) {
|
|
const result = await _graphql(
|
|
"releaseAllSafe",
|
|
{ slug: String(slug || "") },
|
|
RELEASE_QUERY,
|
|
preferredBase
|
|
);
|
|
|
|
return {
|
|
release: result?.data?.release || null,
|
|
siteBase: result?.siteBase || _cleanBase(preferredBase)
|
|
};
|
|
}
|
|
|
|
function _releaseAliases(release) {
|
|
const parts = [];
|
|
|
|
if (release?.originalName) parts.push(`Original: ${release.originalName}`);
|
|
if (release?.type) parts.push(`Type: ${release.type}`);
|
|
if (Number.isFinite(release?.episodesCount)) parts.push(`Episodes: ${release.episodesCount}`);
|
|
if (Number.isFinite(release?.episodeDuration)) parts.push(`Duration: ${release.episodeDuration}m`);
|
|
if (release?.announcement) parts.push(String(release.announcement));
|
|
|
|
if (Array.isArray(release?.genres) && release.genres.length) {
|
|
parts.push(`Genres: ${release.genres.map(g => g?.name).filter(Boolean).join(", ")}`);
|
|
}
|
|
|
|
return parts.join(" | ");
|
|
}
|
|
|
|
function _scoreTitle(title, keyword) {
|
|
const t = String(title || "").toLowerCase().trim();
|
|
const k = String(keyword || "").toLowerCase().trim();
|
|
|
|
if (!t || !k) return 99;
|
|
if (t === k) return 0;
|
|
if (t.startsWith(k)) return 1;
|
|
if (t.includes(k)) return 2;
|
|
|
|
return 3;
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// Search -> JSON string
|
|
// ------------------------------------------------------------
|
|
async function searchResults(keyword) {
|
|
try {
|
|
const query = String(keyword || "").trim();
|
|
if (!query) return JSON.stringify([]);
|
|
|
|
const result = await _graphql("search", { query, type: "RELEASE" }, SEARCH_QUERY);
|
|
const siteBase = result?.siteBase || SITE_BASE;
|
|
const edges = Array.isArray(result?.data?.search?.edges) ? result.data.search.edges : [];
|
|
|
|
const out = edges
|
|
.map(edge => edge?.node)
|
|
.filter(node => node?.__typename === "Release" && node?.slug)
|
|
.map(release => {
|
|
const title = release?.name || release?.originalName || "Unknown title";
|
|
|
|
return {
|
|
title,
|
|
href: _packRelease({
|
|
slug: release.slug,
|
|
id: release.id,
|
|
title,
|
|
originalName: release?.originalName || "",
|
|
airedOn: release?.airedOn || release?.releasedOn || "",
|
|
siteBase
|
|
}),
|
|
_score: Math.min(
|
|
_scoreTitle(release?.name || "", query),
|
|
_scoreTitle(release?.originalName || "", query)
|
|
)
|
|
};
|
|
});
|
|
|
|
out.sort((a, b) => a._score - b._score);
|
|
return JSON.stringify(out.map(({ _score, ...rest }) => rest));
|
|
} catch (_) {
|
|
return JSON.stringify([]);
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// Details -> JSON string
|
|
// ------------------------------------------------------------
|
|
async function extractDetails(href) {
|
|
try {
|
|
const slug = _extractSlug(href);
|
|
const preferredBase = _extractPreferredBase(href);
|
|
|
|
if (!slug) return JSON.stringify([]);
|
|
|
|
const result = await _getRelease(slug, preferredBase);
|
|
const release = result?.release;
|
|
|
|
if (!release) return JSON.stringify([]);
|
|
|
|
const titleLine = release?.originalName && release?.originalName !== release?.name
|
|
? `${release.name} / ${release.originalName}`
|
|
: (release?.name || release?.originalName || "ShizaProject");
|
|
|
|
const statusLine = [release?.status, release?.activity]
|
|
.filter(Boolean)
|
|
.join(" / ");
|
|
|
|
const description = [titleLine, statusLine]
|
|
.filter(Boolean)
|
|
.join("\n");
|
|
|
|
return JSON.stringify([{
|
|
description: description || "No description available.",
|
|
aliases: _releaseAliases(release) || "ShizaProject",
|
|
airdate: release?.airedOn || release?.releasedOn || "Unknown"
|
|
}]);
|
|
} catch (_) {
|
|
return JSON.stringify([]);
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// Episodes -> JSON string
|
|
// ------------------------------------------------------------
|
|
async function extractEpisodes(href) {
|
|
try {
|
|
const slug = _extractSlug(href);
|
|
const preferredBase = _extractPreferredBase(href);
|
|
|
|
if (!slug) return JSON.stringify([]);
|
|
|
|
const result = await _getRelease(slug, preferredBase);
|
|
const release = result?.release;
|
|
const siteBase = result?.siteBase || preferredBase || SITE_BASE;
|
|
|
|
if (!release) return JSON.stringify([]);
|
|
|
|
const episodes = Array.isArray(release?.episodes) ? release.episodes : [];
|
|
|
|
const out = episodes
|
|
.map((ep, index) => {
|
|
const videos = Array.isArray(ep?.videos) ? ep.videos : [];
|
|
|
|
const embedUrls = videos
|
|
.map(v => _normalizeUrl(v?.embedUrl || ""))
|
|
.filter(Boolean);
|
|
|
|
if (!embedUrls.length) return null;
|
|
|
|
const number = Number.isFinite(ep?.number) ? ep.number : (index + 1);
|
|
const title = ep?.name ? String(ep.name) : `Episode ${number}`;
|
|
|
|
const entry = {
|
|
href: _packEpisode({
|
|
releaseSlug: release.slug,
|
|
episodeId: ep?.id || "",
|
|
number,
|
|
title,
|
|
embedUrls,
|
|
fallbackEmbedUrl: embedUrls[0],
|
|
siteBase
|
|
}),
|
|
number,
|
|
title
|
|
};
|
|
|
|
if (Number.isFinite(ep?.duration)) {
|
|
entry.duration = ep.duration * 60;
|
|
}
|
|
|
|
return entry;
|
|
})
|
|
.filter(Boolean)
|
|
.sort((a, b) => Number(a.number) - Number(b.number));
|
|
|
|
return JSON.stringify(out);
|
|
} catch (_) {
|
|
return JSON.stringify([]);
|
|
}
|
|
}
|
|
|
|
function _qualityNumber(key) {
|
|
const n = parseInt(String(key || "").replace(/[^\d]/g, ""), 10);
|
|
return Number.isFinite(n) ? n : 0;
|
|
}
|
|
|
|
function _pickQualityUrl(qualities, target) {
|
|
for (const key in qualities || {}) {
|
|
const q = _qualityNumber(key);
|
|
const src = _normalizeUrl(qualities?.[key]?.src || "");
|
|
if (q === target && src) return src;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
function _streamHeaders(siteBase) {
|
|
const site = _cleanBase(siteBase || SITE_BASE);
|
|
|
|
return {
|
|
"User-Agent": _ua(),
|
|
"Referer": site + "/",
|
|
"Origin": site
|
|
};
|
|
}
|
|
|
|
function _buildStreamsFromQualities(qualities, siteBase) {
|
|
const url1080 = _pickQualityUrl(qualities, 1080);
|
|
const url720 = _pickQualityUrl(qualities, 720);
|
|
const url480 = _pickQualityUrl(qualities, 480);
|
|
const url360 = _pickQualityUrl(qualities, 360);
|
|
|
|
const known = {
|
|
1080: url1080,
|
|
720: url720,
|
|
480: url480,
|
|
360: url360
|
|
};
|
|
|
|
const headers = _streamHeaders(siteBase);
|
|
const streams = [];
|
|
|
|
for (const quality of [1080, 720, 480, 360]) {
|
|
const streamUrl = known[quality];
|
|
if (!streamUrl) continue;
|
|
|
|
streams.push({
|
|
title: `${quality}p`,
|
|
streamUrl,
|
|
url1080,
|
|
url720,
|
|
url480,
|
|
url360,
|
|
headers
|
|
});
|
|
}
|
|
|
|
if (!streams.length) {
|
|
let bestQuality = 0;
|
|
let bestUrl = "";
|
|
|
|
for (const key in qualities || {}) {
|
|
const q = _qualityNumber(key);
|
|
const src = _normalizeUrl(qualities?.[key]?.src || "");
|
|
if (!src) continue;
|
|
|
|
if (q > bestQuality) {
|
|
bestQuality = q;
|
|
bestUrl = src;
|
|
}
|
|
}
|
|
|
|
if (bestUrl) {
|
|
streams.push({
|
|
title: bestQuality ? `${bestQuality}p` : "Kodik",
|
|
streamUrl: bestUrl,
|
|
url1080: bestQuality >= 1080 ? bestUrl : null,
|
|
url720: bestQuality >= 720 && bestQuality < 1080 ? bestUrl : null,
|
|
url480: bestQuality >= 480 && bestQuality < 720 ? bestUrl : null,
|
|
url360: bestQuality >= 360 && bestQuality < 480 ? bestUrl : null,
|
|
headers
|
|
});
|
|
}
|
|
}
|
|
|
|
return streams;
|
|
}
|
|
|
|
function _isKodikUrl(url) {
|
|
const raw = String(url || "").toLowerCase();
|
|
return raw.includes("kodikplayer.com") || raw.includes("kodik.info");
|
|
}
|
|
|
|
// ------------------------------------------------------------
|
|
// Stream -> quality picker JSON
|
|
// ------------------------------------------------------------
|
|
async function extractStreamUrl(href) {
|
|
try {
|
|
const payload = _unpackEpisode(href);
|
|
|
|
if (!payload) {
|
|
return JSON.stringify({
|
|
streams: [],
|
|
subtitle: DEFAULT_SUBTITLE
|
|
});
|
|
}
|
|
|
|
const siteBase = _cleanBase(payload?.siteBase || SITE_BASE);
|
|
|
|
const embedUrls = Array.isArray(payload?.embedUrls)
|
|
? payload.embedUrls.map(_normalizeUrl).filter(Boolean)
|
|
: [_normalizeUrl(payload?.fallbackEmbedUrl)].filter(Boolean);
|
|
|
|
const streams = [];
|
|
|
|
for (const embedUrl of embedUrls) {
|
|
if (!_isKodikUrl(embedUrl)) continue;
|
|
|
|
try {
|
|
const qualitiesJson = await kodikParser(embedUrl, siteBase);
|
|
const qualities = _safeJsonParse(qualitiesJson, {});
|
|
const parsedStreams = _buildStreamsFromQualities(qualities, siteBase);
|
|
streams.push(...parsedStreams);
|
|
} catch (_) {}
|
|
}
|
|
|
|
return JSON.stringify({
|
|
streams,
|
|
subtitle: DEFAULT_SUBTITLE
|
|
});
|
|
} catch (_) {
|
|
return JSON.stringify({
|
|
streams: [],
|
|
subtitle: DEFAULT_SUBTITLE
|
|
});
|
|
}
|
|
}
|
|
|
|
// Kodik parser adapted from yummyanime/onwave-style logic.
|
|
async function kodikParser(url, siteBase) {
|
|
try {
|
|
const site = _cleanBase(siteBase || SITE_BASE);
|
|
const embedUrl = _normalizeUrl(url);
|
|
|
|
const headers = {
|
|
"Referer": site + "/",
|
|
"User-Agent": _ua()
|
|
};
|
|
|
|
const response = await fetchv2(embedUrl, headers);
|
|
const htmlText = await response.text();
|
|
|
|
const urlParamsMatch = htmlText.match(/var\s+urlParams\s*=\s*'([^']+)'/);
|
|
const videoInfoTypeMatch = htmlText.match(/vInfo\.type\s*=\s*'([^']+)'/);
|
|
const videoInfoHashMatch = htmlText.match(/vInfo\.hash\s*=\s*'([^']+)'/);
|
|
const videoInfoIdMatch = htmlText.match(/vInfo\.id\s*=\s*'([^']+)'/);
|
|
|
|
const urlParams = urlParamsMatch ? _safeJsonParse(urlParamsMatch[1], {}) : {};
|
|
const videoInfoType = videoInfoTypeMatch ? videoInfoTypeMatch[1] : "";
|
|
const videoInfoHash = videoInfoHashMatch ? videoInfoHashMatch[1] : "";
|
|
const videoInfoId = videoInfoIdMatch ? videoInfoIdMatch[1] : "";
|
|
|
|
const finalData =
|
|
`d=${urlParams.d || ""}` +
|
|
`&d_sign=${urlParams.d_sign || ""}` +
|
|
`&pd=${urlParams.pd || ""}` +
|
|
`&pd_sign=${urlParams.pd_sign || ""}` +
|
|
`&ref=${urlParams.ref || ""}` +
|
|
`&ref_sign=${urlParams.ref_sign || ""}` +
|
|
`&bad_user=false&cdn_is_working=true` +
|
|
`&type=${encodeURIComponent(videoInfoType)}` +
|
|
`&hash=${encodeURIComponent(videoInfoHash)}` +
|
|
`&id=${encodeURIComponent(videoInfoId)}` +
|
|
`&info=%7B%7D`;
|
|
|
|
const headers2 = {
|
|
"Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
|
|
"Referer": site + "/",
|
|
"User-Agent": _ua(),
|
|
"X-Requested-With": "XMLHttpRequest"
|
|
};
|
|
|
|
const apiResponse = await fetchv2(
|
|
"https://kodikplayer.com/ftor",
|
|
headers2,
|
|
"POST",
|
|
finalData
|
|
);
|
|
|
|
const apiJson = await apiResponse.json();
|
|
|
|
const qualities = {};
|
|
|
|
if (apiJson?.links) {
|
|
for (const quality in apiJson.links) {
|
|
const qualityArray = apiJson.links[quality];
|
|
const first = Array.isArray(qualityArray) ? qualityArray[0] : null;
|
|
|
|
if (!first?.src) continue;
|
|
|
|
qualities[quality] = {
|
|
src: decode(first.src),
|
|
type: first.type || "application/x-mpegURL"
|
|
};
|
|
}
|
|
}
|
|
|
|
return JSON.stringify(qualities, null, 2);
|
|
} catch (_) {
|
|
return JSON.stringify({});
|
|
}
|
|
}
|
|
|
|
function decode(input) {
|
|
const map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
let out = "";
|
|
let buffer = 0;
|
|
let count = 0;
|
|
|
|
const rotated = [];
|
|
const source = String(input || "");
|
|
|
|
for (let i = 0; i < source.length; i++) {
|
|
const ch = source[i];
|
|
|
|
if (/[a-zA-Z]/.test(ch)) {
|
|
const code = ch.charCodeAt(0);
|
|
const max = ch <= "Z" ? 90 : 122;
|
|
const shifted = code + 18;
|
|
|
|
rotated.push(String.fromCharCode(shifted <= max ? shifted : shifted - 26));
|
|
} else {
|
|
rotated.push(ch);
|
|
}
|
|
}
|
|
|
|
const rot = rotated.join("");
|
|
|
|
for (let j = 0; j < rot.length; j++) {
|
|
const ch = rot[j];
|
|
|
|
if (ch === "=") break;
|
|
|
|
const val = map.indexOf(ch);
|
|
if (val === -1) continue;
|
|
|
|
buffer = (buffer << 6) | val;
|
|
count += 6;
|
|
|
|
if (count >= 8) {
|
|
count -= 8;
|
|
out += String.fromCharCode((buffer >> count) & 0xff);
|
|
}
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
function _defaultExport() {
|
|
return {
|
|
searchResults,
|
|
extractDetails,
|
|
extractEpisodes,
|
|
extractStreamUrl
|
|
};
|
|
}
|
|
|
|
try {
|
|
globalThis.default = _defaultExport;
|
|
} catch (_) {}
|
|
|
|
try {
|
|
this.default = _defaultExport;
|
|
} catch (_) {}
|
|
|
|
try {
|
|
globalThis.module = globalThis.module || {};
|
|
globalThis.module.exports = { default: _defaultExport };
|
|
} catch (_) {} |