☰

Greasy Fork 还支持 简体中文。

theYNC.com Underground bypass

Watch theYNC Underground videos without needing an account

目前為 2025-01-17 提交的版本，檢視 最新版本。

  1. // ==UserScript==
  2. // @name        theYNC.com Underground bypass
  3. // @description Watch theYNC Underground videos without needing an account
  4. // @namespace   Violentmonkey Scripts
  5. // @match       *://*.theync.com/*
  6. // @match       *://theync.com/*
  7. // @match       *://*.theync.net/*
  8. // @match       *://theync.net/*
  9. // @match       *://*.theync.org/*
  10. // @match       *://theync.org/*
  11. // @match       *://archive.ph/*
  12. // @match       *://archive.today/*
  13. // @include     /https?:\/\/web\.archive\.org\/web\/\d+?\/https?:\/\/theync\.(?:com|org|net)/
  14. // @require     https://update.greasyfork.org/scripts/523012/1519437/WaitForKeyElement.js
  15. // @grant       GM.xmlHttpRequest
  16. // @connect     media.theync.com
  17. // @connect     archive.org
  18. // @grant       GM_addStyle
  19. // @grant       GM_log
  20. // @grant       GM_addElement
  21. // @version     8.6
  22. // @supportURL  https://greasyfork.org/en/scripts/520352-theync-com-underground-bypass/feedback
  23. // @license     MIT
  24. // @author      https://greasyfork.org/en/users/1409235-paywalldespiser
  25. // ==/UserScript==
  26.  
  27. /**
  28.  * Fetches available archives of a given address and retrieves their URLs.
  29.  *
  30.  * @param {string} address
  31.  * @returns {Promise<string>}
  32.  */
  33. function queryArchive(address) {
  34.     try {
  35.         const url = new URL('https://archive.org/wayback/available');
  36.         url.searchParams.append('url', address);
  37.  
  38.         return GM.xmlHttpRequest({
  39.             method: 'GET',
  40.             url,
  41.             redirect: 'follow',
  42.             responseType: 'json',
  43.         })
  44.             .then((result) => {
  45.                 if (result.status >= 300) {
  46.                     console.error(result.status);
  47.                     return Promise.reject(result);
  48.                 }
  49.                 return result;
  50.             })
  51.             .then((result) => result.response)
  52.             .then((result) => {
  53.                 if (
  54.                     result.archived_snapshots &&
  55.                     result.archived_snapshots.closest
  56.                 ) {
  57.                     return result.archived_snapshots.closest.url;
  58.                 }
  59.                 return Promise.reject();
  60.             });
  61.     } catch (e) {
  62.         return Promise.reject();
  63.     }
  64. }
  65.  
  66. /**
  67.  * Checks whether a URL is valid and accessible.
  68.  *
  69.  * @param {string} address
  70.  * @returns {Promise<string>}
  71.  */
  72. function isValidURL(address) {
  73.     if (!address) {
  74.         return Promise.reject(address);
  75.     }
  76.     try {
  77.         const url = new URL(address);
  78.         return GM.xmlHttpRequest({ url, method: 'HEAD' }).then((result) => {
  79.             if (result.status === 404) {
  80.                 return Promise.reject(address);
  81.             }
  82.             return address;
  83.         });
  84.     } catch {
  85.         return Promise.reject(address);
  86.     }
  87. }
  88.  
  89. /**
  90.  * Tries to guess the video URL of a given theYNC video via the thumbnail URL.
  91.  * Only works on videos published before around May 2023.
  92.  *
  93.  * @param {Element} element
  94.  * @returns {string | undefined}
  95.  */
  96. function getTheYNCVideoURL(element) {
  97.     const thumbnailURL = element.querySelector('.image > img')?.src;
  98.     if (!thumbnailURL) return;
  99.     for (const [, group_url] of thumbnailURL.matchAll(
  100.         /^https?:\/\/(?:media\.theync\.(?:com|org|net)|(www\.)?theync\.(?:com|org|net)\/media)\/thumbs\/(.+?)\.(?:flv|mpg|wmv|avi|3gp|qt|mp4|mov|m4v|f4v)/gim
  101.     )) {
  102.         if (group_url) {
  103.             return `https://media.theync.com/videos/${group_url}.mp4`;
  104.         }
  105.     }
  106. }
  107.  
  108. /**
  109.  * Retrieves the video URL from a theYNC video page
  110.  *
  111.  * @param {Element} element
  112.  * @returns {string | undefined}
  113.  */
  114. function retrieveVideoURL(element = document) {
  115.     if (location.host === 'archive.ph' || location.host === 'archive.today') {
  116.         const videoElement = element.querySelector(
  117.             '[id="thisPlayer"] video[old-src]'
  118.         );
  119.         if (videoElement) {
  120.             return videoElement.getAttribute('old-src');
  121.         }
  122.     }
  123.     const videoSrc = element.querySelector(
  124.         '.stage-video > .inner-stage video[src]'
  125.     )?.src;
  126.     if (videoSrc) {
  127.         return videoSrc;
  128.     }
  129.     const playerSetupScript = element.querySelector(
  130.         '[id=thisPlayer] + script'
  131.     )?.textContent;
  132.     if (playerSetupScript) {
  133.         // TODO: Find a non-regex solution to this that doesn't involve eval
  134.         for (const [, videoURL] of playerSetupScript.matchAll(
  135.             /(?<=file\:) *?"(?:https?:\/\/web.archive.org\/web\/\d+?\/)?(https?:\/\/(?:(?:www\.)?theync\.(?:com|org|net)\/media|media.theync\.(?:com|org|net))\/videos\/.+?\.(?:flv|mpg|wmv|avi|3gp|qt|mp4|mov|m4v|f4v))"/gim
  136.         )) {
  137.             if (videoURL) {
  138.                 return decodeURIComponent(videoURL);
  139.             }
  140.         }
  141.     }
  142. }
  143.  
  144. /**
  145.  * Retrieves the video URL from an archived YNC URL
  146.  *
  147.  * @param {string} archiveURL
  148.  * @returns {Promise<string>}
  149.  */
  150. function getVideoURLFromArchive(archiveURL) {
  151.     return GM.xmlHttpRequest({ url: archiveURL, method: 'GET' })
  152.         .then((result) => {
  153.             if (result.status >= 300) {
  154.                 console.error(result.status);
  155.                 return Promise.reject(result);
  156.             }
  157.             return result;
  158.         })
  159.  
  160.         .then((result) => {
  161.             // Initialize the DOM parser
  162.             const parser = new DOMParser();
  163.  
  164.             // Parse the text
  165.             const doc = parser.parseFromString(
  166.                 result.responseText,
  167.                 'text/html'
  168.             );
  169.  
  170.             // You can now even select part of that html as you would in the regular DOM
  171.             // Example:
  172.             // const docArticle = doc.querySelector('article').innerHTML
  173.             const videoURL = retrieveVideoURL(doc);
  174.             if (videoURL) {
  175.                 return videoURL;
  176.             }
  177.             return Promise.reject();
  178.         });
  179. }
  180.  
  181. /**
  182.  * set Link of element
  183.  *
  184.  * @param {HTMLLinkElement} element
  185.  * @param {string} url
  186.  */
  187. function setElementLink(element, url) {
  188.     element.href = url;
  189. }
  190.  
  191. (function () {
  192.     'use strict';
  193.  
  194.     const allowedExtensions = [
  195.         'flv',
  196.         'mpg',
  197.         'wmv',
  198.         'avi',
  199.         '3gp',
  200.         'qt',
  201.         'mp4',
  202.         'mov',
  203.         'm4v',
  204.         'f4v',
  205.     ];
  206.  
  207.     GM_addStyle(`
  208.         .loader {
  209.             border: 0.25em solid #f3f3f3;
  210.             border-top: 0.25em solid rgba(0, 0, 0, 0);
  211.             border-radius: 50%;
  212.             width: 1em;
  213.             height: 1em;
  214.             animation: spin 2s linear infinite;
  215.         }
  216.         
  217.         @keyframes spin {
  218.             0% {
  219.                 transform: rotate(0deg);
  220.             }
  221.         
  222.             100% {
  223.                 transform: rotate(360deg);
  224.             }
  225.         }
  226.         
  227.         .border-gold {
  228.             display: flex !important;
  229.             align-items: center;
  230.             justify-content: center;
  231.             gap: 1em;
  232.         }
  233.         `);
  234.  
  235.     waitForKeyElement(
  236.         '[id="content"],[id="related-videos"] .content-block'
  237.     ).then((contentBlock) => {
  238.         for (const element of contentBlock.querySelectorAll(
  239.             '.upgrade-profile > .upgrade-info-block > .image-block'
  240.         )) {
  241.             isValidURL(getTheYNCVideoURL(element)).then(
  242.                 (url) => (location.href = url)
  243.             );
  244.         }
  245.         for (const element of contentBlock.querySelectorAll(
  246.             '.inner-block > a'
  247.         )) {
  248.             const undergroundLogo = element.querySelector(
  249.                 '.item-info > .border-gold'
  250.             );
  251.             if (!undergroundLogo) {
  252.                 continue;
  253.             }
  254.             const loadingElement = GM_addElement('div');
  255.             loadingElement.classList.add('loader');
  256.             undergroundLogo.appendChild(loadingElement);
  257.             isValidURL(getTheYNCVideoURL(element))
  258.                 .then(
  259.                     (url) => ({
  260.                         url: url,
  261.                         text: 'BYPASSED',
  262.                         color: 'green',
  263.                     }),
  264.                     () => {
  265.                         const match = element.href.match(
  266.                             /(^https?:\/\/(?:www\.)?theync\.)(?:com|org|net)(\/.*$)/im
  267.                         );
  268.                         if (!match || !match[1]) {
  269.                             return Promise.reject(
  270.                                 `Error with the URL: ${element.href}`
  271.                             );
  272.                         }
  273.                         const [, secondLevelDomain, path] = match;
  274.  
  275.                         return ['com', 'org', 'net']
  276.                             .reduce(
  277.                                 (accumulator, currentTLD) =>
  278.                                     accumulator.catch(() =>
  279.                                         queryArchive(
  280.                                             secondLevelDomain +
  281.                                                 currentTLD +
  282.                                                 path
  283.                                         )
  284.                                     ),
  285.                                 Promise.reject()
  286.                             )
  287.                             .then((archiveURL) =>
  288.                                 getVideoURLFromArchive(archiveURL).then(
  289.                                     (videoURL) => ({
  290.                                         url: videoURL,
  291.                                         text: 'ARCHIVED',
  292.                                         color: 'blue',
  293.                                     }),
  294.                                     () => ({
  295.                                         url: archiveURL,
  296.                                         text: 'MAYBE ARCHIVED',
  297.                                         color: 'aqua',
  298.                                     })
  299.                                 )
  300.                             );
  301.                     }
  302.                 )
  303.                 .catch(() => ({
  304.                     url:
  305.                         'https://archive.ph/' +
  306.                         encodeURIComponent(element.href),
  307.                     text: 'Try archive.today',
  308.                     color: 'red',
  309.                 }))
  310.                 .then(({ url, text, color }) => {
  311.                     undergroundLogo.textContent = text;
  312.                     undergroundLogo.style.backgroundColor = color;
  313.                     element.href = url;
  314.                 })
  315.                 .finally(() => loadingElement.remove());
  316.         }
  317.     });
  318.     waitForKeyElement('[id="stage"]:has([id="thisPlayer"])').then((stage) => {
  319.         const videoURL = retrieveVideoURL();
  320.         if (videoURL) {
  321.             stage.innerHTML = '';
  322.             stage.style.textAlign = 'center';
  323.  
  324.             const video = GM_addElement(stage, 'video', {
  325.                 controls: 'controls',
  326.             });
  327.             video.style.width = 'auto';
  328.             video.style.height = '100%';
  329.             const source = GM_addElement(video, 'source');
  330.             source.src = videoURL;
  331.             source.type = 'video/mp4';
  332.         }
  333.     });
  334. })();
  335. // ==UserScript==
  336. // @name        theYNC.com Underground bypass
  337. // @description Watch theYNC Underground videos without needing an account
  338. // @namespace   Violentmonkey Scripts
  339. // @match       *://*.theync.com/*
  340. // @match       *://theync.com/*
  341. // @match       *://*.theync.net/*
  342. // @match       *://theync.net/*
  343. // @match       *://*.theync.org/*
  344. // @match       *://theync.org/*
  345. // @match       *://archive.ph/*
  346. // @match       *://archive.today/*
  347. // @include     /https?:\/\/web\.archive\.org\/web\/\d+?\/https?:\/\/theync\.(?:com|org|net)/
  348. // @require     https://update.greasyfork.org/scripts/523012/1519437/WaitForKeyElement.js
  349. // @grant       GM.xmlHttpRequest
  350. // @connect     media.theync.com
  351. // @connect     archive.org
  352. // @grant       GM_addStyle
  353. // @grant       GM_log
  354. // @grant       GM_addElement
  355. // @version     8.6
  356. // @supportURL  https://greasyfork.org/en/scripts/520352-theync-com-underground-bypass/feedback
  357. // @license     MIT
  358. // @author      https://greasyfork.org/en/users/1409235-paywalldespiser
  359. // ==/UserScript==
  360.  
  361. /**
  362.  * Fetches available archives of a given address and retrieves their URLs.
  363.  *
  364.  * @param {string} address
  365.  * @returns {Promise<string>}
  366.  */
  367. function queryArchive(address) {
  368.     try {
  369.         const url = new URL('https://archive.org/wayback/available');
  370.         url.searchParams.append('url', address);
  371.  
  372.         return GM.xmlHttpRequest({
  373.             method: 'GET',
  374.             url,
  375.             redirect: 'follow',
  376.             responseType: 'json',
  377.         })
  378.             .then((result) => {
  379.                 if (result.status >= 300) {
  380.                     console.error(result.status);
  381.                     return Promise.reject(result);
  382.                 }
  383.                 return result;
  384.             })
  385.             .then((result) => result.response)
  386.             .then((result) => {
  387.                 if (
  388.                     result.archived_snapshots &&
  389.                     result.archived_snapshots.closest
  390.                 ) {
  391.                     return result.archived_snapshots.closest.url;
  392.                 }
  393.                 return Promise.reject();
  394.             });
  395.     } catch (e) {
  396.         return Promise.reject();
  397.     }
  398. }
  399.  
  400. /**
  401.  * Checks whether a URL is valid and accessible.
  402.  *
  403.  * @param {string} address
  404.  * @returns {Promise<string>}
  405.  */
  406. function isValidURL(address) {
  407.     if (!address) {
  408.         return Promise.reject(address);
  409.     }
  410.     try {
  411.         const url = new URL(address);
  412.         return GM.xmlHttpRequest({ url, method: 'HEAD' }).then((result) => {
  413.             if (result.status === 404) {
  414.                 return Promise.reject(address);
  415.             }
  416.             return address;
  417.         });
  418.     } catch {
  419.         return Promise.reject(address);
  420.     }
  421. }
  422.  
  423. /**
  424.  * Tries to guess the video URL of a given theYNC video via the thumbnail URL.
  425.  * Only works on videos published before around May 2023.
  426.  *
  427.  * @param {Element} element
  428.  * @returns {string | undefined}
  429.  */
  430. function getTheYNCVideoURL(element) {
  431.     const thumbnailURL = element.querySelector('.image > img')?.src;
  432.     if (!thumbnailURL) return;
  433.     for (const [, group_url] of thumbnailURL.matchAll(
  434.         /^https?:\/\/(?:media\.theync\.(?:com|org|net)|(www\.)?theync\.(?:com|org|net)\/media)\/thumbs\/(.+?)\.(?:flv|mpg|wmv|avi|3gp|qt|mp4|mov|m4v|f4v)/gim
  435.     )) {
  436.         if (group_url) {
  437.             return `https://media.theync.com/videos/${group_url}.mp4`;
  438.         }
  439.     }
  440. }
  441.  
  442. /**
  443.  * Retrieves the video URL from a theYNC video page
  444.  *
  445.  * @param {Element} element
  446.  * @returns {string | undefined}
  447.  */
  448. function retrieveVideoURL(element = document) {
  449.     if (location.host === 'archive.ph' || location.host === 'archive.today') {
  450.         const videoElement = element.querySelector(
  451.             '[id="thisPlayer"] video[old-src]'
  452.         );
  453.         if (videoElement) {
  454.             return videoElement.getAttribute('old-src');
  455.         }
  456.     }
  457.     const videoSrc = element.querySelector(
  458.         '.stage-video > .inner-stage video[src]'
  459.     )?.src;
  460.     if (videoSrc) {
  461.         return videoSrc;
  462.     }
  463.     const playerSetupScript = element.querySelector(
  464.         '[id=thisPlayer] + script'
  465.     )?.textContent;
  466.     if (playerSetupScript) {
  467.         // TODO: Find a non-regex solution to this that doesn't involve eval
  468.         for (const [, videoURL] of playerSetupScript.matchAll(
  469.             /(?<=file\:) *?"(?:https?:\/\/web.archive.org\/web\/\d+?\/)?(https?:\/\/(?:(?:www\.)?theync\.(?:com|org|net)\/media|media.theync\.(?:com|org|net))\/videos\/.+?\.(?:flv|mpg|wmv|avi|3gp|qt|mp4|mov|m4v|f4v))"/gim
  470.         )) {
  471.             if (videoURL) {
  472.                 return decodeURIComponent(videoURL);
  473.             }
  474.         }
  475.     }
  476. }
  477.  
  478. /**
  479.  * Retrieves the video URL from an archived YNC URL
  480.  *
  481.  * @param {string} archiveURL
  482.  * @returns {Promise<string>}
  483.  */
  484. function getVideoURLFromArchive(archiveURL) {
  485.     return GM.xmlHttpRequest({ url: archiveURL, method: 'GET' })
  486.         .then((result) => {
  487.             if (result.status >= 300) {
  488.                 console.error(result.status);
  489.                 return Promise.reject(result);
  490.             }
  491.             return result;
  492.         })
  493.  
  494.         .then((result) => {
  495.             // Initialize the DOM parser
  496.             const parser = new DOMParser();
  497.  
  498.             // Parse the text
  499.             const doc = parser.parseFromString(
  500.                 result.responseText,
  501.                 'text/html'
  502.             );
  503.  
  504.             // You can now even select part of that html as you would in the regular DOM
  505.             // Example:
  506.             // const docArticle = doc.querySelector('article').innerHTML
  507.             const videoURL = retrieveVideoURL(doc);
  508.             if (videoURL) {
  509.                 return videoURL;
  510.             }
  511.             return Promise.reject();
  512.         });
  513. }
  514.  
  515. /**
  516.  * set Link of element
  517.  *
  518.  * @param {HTMLLinkElement} element
  519.  * @param {string} url
  520.  */
  521. function setElementLink(element, url) {
  522.     element.href = url;
  523. }
  524.  
  525. (function () {
  526.     'use strict';
  527.  
  528.     const allowedExtensions = [
  529.         'flv',
  530.         'mpg',
  531.         'wmv',
  532.         'avi',
  533.         '3gp',
  534.         'qt',
  535.         'mp4',
  536.         'mov',
  537.         'm4v',
  538.         'f4v',
  539.     ];
  540.  
  541.     GM_addStyle(`
  542.         .loader {
  543.             border: 0.25em solid #f3f3f3;
  544.             border-top: 0.25em solid rgba(0, 0, 0, 0);
  545.             border-radius: 50%;
  546.             width: 1em;
  547.             height: 1em;
  548.             animation: spin 2s linear infinite;
  549.         }
  550.         
  551.         @keyframes spin {
  552.             0% {
  553.                 transform: rotate(0deg);
  554.             }
  555.         
  556.             100% {
  557.                 transform: rotate(360deg);
  558.             }
  559.         }
  560.         
  561.         .border-gold {
  562.             display: flex !important;
  563.             align-items: center;
  564.             justify-content: center;
  565.             gap: 1em;
  566.         }
  567.         `);
  568.  
  569.     waitForKeyElement(
  570.         '[id="content"],[id="related-videos"] .content-block'
  571.     ).then((contentBlock) => {
  572.         for (const element of contentBlock.querySelectorAll(
  573.             '.upgrade-profile > .upgrade-info-block > .image-block'
  574.         )) {
  575.             isValidURL(getTheYNCVideoURL(element)).then(
  576.                 (url) => (location.href = url)
  577.             );
  578.         }
  579.         for (const element of contentBlock.querySelectorAll(
  580.             '.inner-block > a'
  581.         )) {
  582.             const undergroundLogo = element.querySelector(
  583.                 '.item-info > .border-gold'
  584.             );
  585.             if (!undergroundLogo) {
  586.                 continue;
  587.             }
  588.             const loadingElement = GM_addElement('div');
  589.             loadingElement.classList.add('loader');
  590.             undergroundLogo.appendChild(loadingElement);
  591.             isValidURL(getTheYNCVideoURL(element))
  592.                 .then(
  593.                     (url) => ({
  594.                         url: url,
  595.                         text: 'BYPASSED',
  596.                         color: 'green',
  597.                     }),
  598.                     () => {
  599.                         const match = element.href.match(
  600.                             /(^https?:\/\/(?:www\.)?theync\.)(?:com|org|net)(\/.*$)/im
  601.                         );
  602.                         if (!match || !match[1]) {
  603.                             return Promise.reject(
  604.                                 `Error with the URL: ${element.href}`
  605.                             );
  606.                         }
  607.                         const [, secondLevelDomain, path] = match;
  608.  
  609.                         return ['com', 'org', 'net']
  610.                             .reduce(
  611.                                 (accumulator, currentTLD) =>
  612.                                     accumulator.catch(() =>
  613.                                         queryArchive(
  614.                                             secondLevelDomain +
  615.                                                 currentTLD +
  616.                                                 path
  617.                                         )
  618.                                     ),
  619.                                 Promise.reject()
  620.                             )
  621.                             .then((archiveURL) =>
  622.                                 getVideoURLFromArchive(archiveURL).then(
  623.                                     (videoURL) => ({
  624.                                         url: videoURL,
  625.                                         text: 'ARCHIVED',
  626.                                         color: 'blue',
  627.                                     }),
  628.                                     () => ({
  629.                                         url: archiveURL,
  630.                                         text: 'MAYBE ARCHIVED',
  631.                                         color: 'aqua',
  632.                                     })
  633.                                 )
  634.                             );
  635.                     }
  636.                 )
  637.                 .catch(() => ({
  638.                     url:
  639.                         'https://archive.ph/' +
  640.                         encodeURIComponent(element.href),
  641.                     text: 'Try archive.today',
  642.                     color: 'red',
  643.                 }))
  644.                 .then(({ url, text, color }) => {
  645.                     undergroundLogo.textContent = text;
  646.                     undergroundLogo.style.backgroundColor = color;
  647.                     element.href = url;
  648.                 })
  649.                 .finally(() => loadingElement.remove());
  650.         }
  651.     });
  652.     waitForKeyElement('[id="stage"]:has([id="thisPlayer"])').then((stage) => {
  653.         const videoURL = retrieveVideoURL();
  654.         if (videoURL) {
  655.             stage.innerHTML = '';
  656.             stage.style.textAlign = 'center';
  657.  
  658.             const video = GM_addElement(stage, 'video', {
  659.                 controls: 'controls',
  660.             });
  661.             video.style.width = 'auto';
  662.             video.style.height = '100%';
  663.             const source = GM_addElement(video, 'source');
  664.             source.src = videoURL;
  665.             source.type = 'video/mp4';
  666.         }
  667.     });
  668. })();