init

providers/primewire/index.ts

@@ -0,0 +1,14 @@
+import {pwCatalogList, pwGenresList} from './pwCatalogl';
+import {pwGetPosts, pwGetPostsSearch} from './pwGetPosts';
+import {pwGetInfo} from './pwGetInfo';
+import {pwGetStream} from './pwGetStream';
+import {ProviderType} from '../types';
+
+export const primewire: ProviderType = {
+  catalog: pwCatalogList,
+  genres: pwGenresList,
+  GetMetaData: pwGetInfo,
+  GetHomePosts: pwGetPosts,
+  GetStream: pwGetStream,
+  GetSearchPosts: pwGetPostsSearch,
+};

providers/primewire/pwCatalogl.ts

@@ -0,0 +1,16 @@
+export const pwCatalogList = [
+  {
+    title: 'Recently Added',
+    filter: '/filter?sort=Just+Added&free_links=true',
+  },
+  {
+    title: 'TV Shows',
+    filter: '/filter?sort=Trending+Today&type=tv',
+  },
+  {
+    title: 'Movies',
+    filter: '/filter?sort=Trending+Today&type=movie',
+  },
+];
+
+export const pwGenresList = [];

providers/primewire/pwGetInfo.ts

@@ -0,0 +1,82 @@
+import {Info, Link, ProviderContext} from '../types';
+
+export const pwGetInfo = async function ({
+  link,
+  providerContext,
+}: {
+  link: string;
+  providerContext: ProviderContext;
+}): Promise<Info> {
+  try {
+    const {axios, cheerio} = providerContext;
+    const url = link;
+    const baseUrl = link.split('/').slice(0, 3).join('/');
+    const res = await axios.get(url);
+    const html = await res.data;
+    const $ = cheerio.load(html);
+    const imdbId =
+      $('.movie_info')
+        .find('a[href*="imdb.com/title/tt"]:not([href*="imdb.com/title/tt/"])')
+        .attr('href')
+        ?.split('/')[4] || '';
+    const type = $('.show_season').html() ? 'series' : 'movie';
+    const linkList: Link[] = [];
+    $('.show_season').each((i, element) => {
+      const seasonTitle = 'Season ' + $(element).attr('data-id');
+      const episodes: Link['directLinks'] = [];
+      $(element)
+        .children()
+        .each((i, element2) => {
+          const episodeTitle = $(element2)
+            .find('a')
+            .children()
+            .remove()
+            .end()
+            .text()
+            .trim()
+            .replace('E', 'Epiosode ');
+          const episodeLink = baseUrl + $(element2).find('a').attr('href');
+          if (episodeTitle && episodeLink) {
+            episodes.push({
+              title: episodeTitle,
+              link: episodeLink,
+            });
+          }
+        });
+      linkList.push({
+        title: seasonTitle,
+        directLinks: episodes,
+      });
+    });
+    if (type === 'movie') {
+      linkList.push({
+        title: 'Movie',
+        directLinks: [
+          {
+            link: link,
+            title: 'Movie',
+            type: 'movie',
+          },
+        ],
+      });
+    }
+    return {
+      title: '',
+      image: '',
+      imdbId: imdbId,
+      synopsis: '',
+      type: type,
+      linkList: linkList,
+    };
+  } catch (error) {
+    console.error(error);
+    return {
+      title: '',
+      image: '',
+      imdbId: '',
+      synopsis: '',
+      linkList: [],
+      type: 'uhd',
+    };
+  }
+};

providers/primewire/pwGetPosts.ts

@@ -0,0 +1,82 @@
+import {Post, ProviderContext} from '../types';
+
+export const pwGetPosts = async function ({
+  filter,
+  page,
+  signal,
+  providerContext,
+}: {
+  filter: string;
+  page: number;
+  providerValue: string;
+  signal: AbortSignal;
+  providerContext: ProviderContext;
+}): Promise<Post[]> {
+  const {getBaseUrl, axios, cheerio} = providerContext;
+
+  const baseUrl = await getBaseUrl('primewire');
+  const url = `${baseUrl + filter}&page=${page}`;
+  return posts({baseUrl, url, signal, axios, cheerio});
+};
+
+export const pwGetPostsSearch = async function ({
+  searchQuery,
+  page,
+  signal,
+  providerContext,
+}: {
+  searchQuery: string;
+  page: number;
+  providerValue: string;
+  signal: AbortSignal;
+  providerContext: ProviderContext;
+}): Promise<Post[]> {
+  const {getBaseUrl, axios, cheerio, Aes} = providerContext;
+  const getSHA256ofJSON = async function (input: any) {
+    return await Aes.sha1(input);
+  };
+  const baseUrl = await getBaseUrl('primewire');
+  const hash = await getSHA256ofJSON(searchQuery + 'JyjId97F9PVqUPuMO0');
+  const url = `${baseUrl}/filter?s=${searchQuery}&page=${page}&ds=${hash.slice(
+    0,
+    10,
+  )}`;
+  return posts({baseUrl, url, signal, axios, cheerio});
+};
+
+async function posts({
+  baseUrl,
+  url,
+  signal,
+  axios,
+  cheerio,
+}: {
+  baseUrl: string;
+  url: string;
+  signal: AbortSignal;
+  axios: ProviderContext['axios'];
+  cheerio: ProviderContext['cheerio'];
+}): Promise<Post[]> {
+  try {
+    const res = await axios.get(url, {signal});
+    const data = res.data;
+    const $ = cheerio.load(data);
+    const catalog: Post[] = [];
+    $('.index_item.index_item_ie').map((i, element) => {
+      const title = $(element).find('a').attr('title');
+      const link = $(element).find('a').attr('href');
+      const image = $(element).find('img').attr('src') || '';
+      if (title && link) {
+        catalog.push({
+          title: title,
+          link: baseUrl + link,
+          image: image,
+        });
+      }
+    });
+    return catalog;
+  } catch (err) {
+    console.error('primewire error ', err);
+    return [];
+  }
+}

providers/primewire/pwGetStream.ts

@@ -0,0 +1,155 @@
+import {Stream, ProviderContext} from '../types';
+
+export const pwGetStream = async function ({
+  link: url,
+  type,
+  providerContext,
+}: {
+  link: string;
+  type: string;
+  providerContext: ProviderContext;
+}): Promise<Stream[]> {
+  const {axios, cheerio} = providerContext;
+  try {
+    console.log('pwGetStream', type, url);
+    const baseUrl = url.split('/').slice(0, 3).join('/');
+    const streamLinks: Stream[] = [];
+    const urls: {id: string; size: string}[] = [];
+    const res = await axios.get(url);
+    const data = res.data;
+    const $ = cheerio.load(data);
+    $('tr:contains("mixdrop")').map((i, element) => {
+      const id = $(element).find('.wp-menu-btn').attr('data-wp-menu');
+      const size = $(element).find('.wp-menu-btn').next().text();
+      if (id) {
+        urls.push({id: baseUrl + '/links/go/' + id, size});
+      }
+    });
+
+    console.log('urls', urls);
+
+    for (const url of urls) {
+      const res2 = await axios.head(url.id);
+      const location = res2.request?.responseURL.replace('/f/', '/e/');
+
+      const res3 = await fetch(location, {
+        credentials: 'include',
+        headers: {
+          'User-Agent':
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:101.0) Gecko/20100101 Firefox/101.0',
+          Accept:
+            'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8',
+          'Accept-Language': 'en-US,en;q=0.5',
+          'Upgrade-Insecure-Requests': '1',
+          'Sec-Fetch-Dest': 'iframe',
+          'Sec-Fetch-Mode': 'navigate',
+          'Sec-Fetch-Site': 'same-origin',
+          Pragma: 'no-cache',
+          'Cache-Control': 'no-cache',
+          referer: res2.request?.responseURL,
+        },
+        referrer: res2.request?.responseURL,
+        method: 'GET',
+        mode: 'cors',
+      });
+      const data3 = await res3.text();
+
+      // let MDCore: any = {};
+      // Step 1: Extract the function parameters and the encoded string
+      var functionRegex =
+        /eval\(function\((.*?)\)\{.*?return p\}.*?\('(.*?)'\.split/;
+      var match = functionRegex.exec(data3);
+      let p = '';
+      if (match) {
+        // var params = match[1].split(',').map(param => param.trim());
+        var encodedString = match[2];
+        console.log('Encoded String:', encodedString);
+
+        // console.log('Parameters:', params);
+        // console.log('Encoded String:', encodedString.split("',36,")[0], '🔥🔥');
+
+        const base = Number(
+          encodedString.split(",'|MDCore|")[0].split(',')[
+            encodedString.split(",'|MDCore|")[0].split(',').length - 1
+          ],
+        );
+        console.log('Base:', base);
+
+        p = encodedString.split(`',${base},`)?.[0].trim();
+        let a = base;
+        let c = encodedString.split(`',${base},`)[1].slice(2).split('|').length;
+        let k = encodedString.split(`',${base},`)[1].slice(2).split('|');
+
+        // console.log('p:', p);
+        // console.log('a:', a);
+        // console.log('c:', c);
+        // console.log('k:', k);
+
+        const decode = function (
+          p: any,
+          a: any,
+          c: any,
+          k: any,
+          e: any,
+          d: any,
+        ) {
+          e = function (c: any) {
+            return c.toString(36);
+          };
+          if (!''.replace(/^/, String)) {
+            while (c--) {
+              d[c.toString(a)] = k[c] || c.toString(a);
+            }
+            k = [
+              function (e: any) {
+                return d[e];
+              },
+            ];
+            e = function () {
+              return '\\w+';
+            };
+            c = 1;
+          }
+          while (c--) {
+            if (k[c]) {
+              p = p.replace(new RegExp('\\b' + e(c) + '\\b', 'g'), k[c]);
+            }
+          }
+          return p;
+        };
+
+        const decoded = decode(p, a, c, k, 0, {});
+        // get MDCore.wurl=
+        const wurl = decoded.match(/MDCore\.wurl="([^"]+)"/)?.[1];
+        console.log('wurl:', wurl);
+        const streamUrl = 'https:' + wurl;
+        console.log('streamUrl:', streamUrl);
+        streamLinks.push({
+          server: 'Mixdrop ' + url.size,
+          link: streamUrl,
+          type: 'mp4',
+          headers: {
+            'User-Agent':
+              'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:101.0) Gecko/20100101 Firefox/101.0',
+            Accept:
+              'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Upgrade-Insecure-Requests': '1',
+            'Sec-Fetch-Dest': 'iframe',
+            'Sec-Fetch-Mode': 'navigate',
+            'Sec-Fetch-Site': 'same-origin',
+            Pragma: 'no-cache',
+            'Cache-Control': 'no-cache',
+            referer: res2.request?.responseURL,
+          },
+        });
+      } else {
+        console.log('No match found');
+      }
+    }
+    return streamLinks;
+  } catch (err) {
+    console.error(err);
+    return [];
+  }
+};