☰

Simple YouTube Age Restriction Bypass

Watch age restricted videos on YouTube without login and without age verification 😎

  1. // ==UserScript==
  2. // @name            Simple YouTube Age Restriction Bypass
  3. // @description     Watch age restricted videos on YouTube without login and without age verification 😎
  4. // @description:de  Schaue YouTube Videos mit Altersbeschränkungen ohne Anmeldung und ohne dein Alter zu bestätigen 😎
  5. // @description:fr  Regardez des vidéos YouTube avec des restrictions d'âge sans vous inscrire et sans confirmer votre âge 😎
  6. // @description:it  Guarda i video con restrizioni di età su YouTube senza login e senza verifica dell'età 😎
  7. // @icon            https://github.com/zerodytrash/Simple-YouTube-Age-Restriction-Bypass/raw/v2.5.4/src/extension/icon/icon_64.png
  8. // @version         2.5.9
  9. // @author          Zerody (https://github.com/zerodytrash)
  10. // @namespace       https://github.com/zerodytrash/Simple-YouTube-Age-Restriction-Bypass/
  11. // @supportURL      https://github.com/zerodytrash/Simple-YouTube-Age-Restriction-Bypass/issues
  12. // @license         MIT
  13. // @match           https://www.youtube.com/*
  14. // @match           https://www.youtube-nocookie.com/*
  15. // @match           https://m.youtube.com/*
  16. // @match           https://music.youtube.com/*
  17. // @grant           none
  18. // @run-at          document-start
  19. // @compatible      chrome
  20. // @compatible      firefox
  21. // @compatible      opera
  22. // @compatible      edge
  23. // @compatible      safari
  24. // ==/UserScript==
  25.  
  26. /*
  27.     This is a transpiled version to achieve a clean code base and better browser compatibility.
  28.     You can find the nicely readable source code at https://github.com/zerodytrash/Simple-YouTube-Age-Restriction-Bypass
  29. */
  30.  
  31. (function iife(ranOnce) {
  32.     // Trick to get around the sandbox restrictions in Greasemonkey (Firefox)
  33.     // Inject code into the main window if criteria match
  34.     if (this !== window && !ranOnce) {
  35.         window.eval('(' + iife.toString() + ')(true);');
  36.         return;
  37.     }
  38.  
  39.     // Script configuration variables
  40.     const UNLOCKABLE_PLAYABILITY_STATUSES = ['AGE_VERIFICATION_REQUIRED', 'AGE_CHECK_REQUIRED', 'CONTENT_CHECK_REQUIRED', 'LOGIN_REQUIRED'];
  41.     const VALID_PLAYABILITY_STATUSES = ['OK', 'LIVE_STREAM_OFFLINE'];
  42.  
  43.     // These are the proxy servers that are sometimes required to unlock videos with age restrictions.
  44.     // You can host your own account proxy instance. See https://github.com/zerodytrash/Simple-YouTube-Age-Restriction-Bypass/tree/main/account-proxy
  45.     // To learn what information is transferred, please read: https://github.com/zerodytrash/Simple-YouTube-Age-Restriction-Bypass#privacy
  46.     const ACCOUNT_PROXY_SERVER_HOST = 'https://youtube-proxy.zerody.one';
  47.     const VIDEO_PROXY_SERVER_HOST = 'https://ny.4everproxy.com';
  48.  
  49.     // User needs to confirm the unlock process on embedded player?
  50.     let ENABLE_UNLOCK_CONFIRMATION_EMBED = true;
  51.  
  52.     // Show notification?
  53.     let ENABLE_UNLOCK_NOTIFICATION = true;
  54.  
  55.     // Disable content warnings?
  56.     let SKIP_CONTENT_WARNINGS = true;
  57.  
  58.     // Some Innertube bypass methods require the following authentication headers of the currently logged in user.
  59.     const GOOGLE_AUTH_HEADER_NAMES = ['Authorization', 'X-Goog-AuthUser', 'X-Origin'];
  60.  
  61.     /**
  62.      * The SQP parameter length is different for blurred thumbnails.
  63.      * They contain much less information, than normal thumbnails.
  64.      * The thumbnail SQPs tend to have a long and a short version.
  65.      */
  66.     const BLURRED_THUMBNAIL_SQP_LENGTHS = [
  67.         32, // Mobile (SHORT)
  68.         48, // Desktop Playlist (SHORT)
  69.         56, // Desktop (SHORT)
  70.         68, // Mobile (LONG)
  71.         72, // Mobile Shorts
  72.         84, // Desktop Playlist (LONG)
  73.         88, // Desktop (LONG)
  74.     ];
  75.  
  76.     // small hack to prevent tree shaking on these exports
  77.     var Config = window[Symbol()] = {
  78.         UNLOCKABLE_PLAYABILITY_STATUSES,
  79.         VALID_PLAYABILITY_STATUSES,
  80.         ACCOUNT_PROXY_SERVER_HOST,
  81.         VIDEO_PROXY_SERVER_HOST,
  82.         ENABLE_UNLOCK_CONFIRMATION_EMBED,
  83.         ENABLE_UNLOCK_NOTIFICATION,
  84.         SKIP_CONTENT_WARNINGS,
  85.         GOOGLE_AUTH_HEADER_NAMES,
  86.         BLURRED_THUMBNAIL_SQP_LENGTHS,
  87.     };
  88.  
  89.     function isGoogleVideoUrl(url) {
  90.         return url.host.includes('.googlevideo.com');
  91.     }
  92.  
  93.     function isGoogleVideoUnlockRequired(googleVideoUrl, lastProxiedGoogleVideoId) {
  94.         const urlParams = new URLSearchParams(googleVideoUrl.search);
  95.         const hasGcrFlag = urlParams.get('gcr');
  96.         const wasUnlockedByAccountProxy = urlParams.get('id') === lastProxiedGoogleVideoId;
  97.  
  98.         return hasGcrFlag && wasUnlockedByAccountProxy;
  99.     }
  100.  
  101.     const nativeJSONParse = window.JSON.parse;
  102.     const nativeXMLHttpRequestOpen = window.XMLHttpRequest.prototype.open;
  103.  
  104.     const isDesktop = window.location.host !== 'm.youtube.com';
  105.     const isMusic = window.location.host === 'music.youtube.com';
  106.     const isEmbed = window.location.pathname.indexOf('/embed/') === 0;
  107.     const isConfirmed = window.location.search.includes('unlock_confirmed');
  108.  
  109.     class Deferred {
  110.         constructor() {
  111.             return Object.assign(
  112.                 new Promise((resolve, reject) => {
  113.                     this.resolve = resolve;
  114.                     this.reject = reject;
  115.                 }),
  116.                 this,
  117.             );
  118.         }
  119.     }
  120.  
  121.     function createElement(tagName, options) {
  122.         const node = document.createElement(tagName);
  123.         options && Object.assign(node, options);
  124.         return node;
  125.     }
  126.  
  127.     function isObject(obj) {
  128.         return obj !== null && typeof obj === 'object';
  129.     }
  130.  
  131.     function findNestedObjectsByAttributeNames(object, attributeNames) {
  132.         var results = [];
  133.  
  134.         // Does the current object match the attribute conditions?
  135.         if (attributeNames.every((key) => typeof object[key] !== 'undefined')) {
  136.             results.push(object);
  137.         }
  138.  
  139.         // Diggin' deeper for each nested object (recursive)
  140.         Object.keys(object).forEach((key) => {
  141.             if (object[key] && typeof object[key] === 'object') {
  142.                 results.push(...findNestedObjectsByAttributeNames(object[key], attributeNames));
  143.             }
  144.         });
  145.  
  146.         return results;
  147.     }
  148.  
  149.     function pageLoaded() {
  150.         if (document.readyState === 'complete') return Promise.resolve();
  151.  
  152.         const deferred = new Deferred();
  153.  
  154.         window.addEventListener('load', deferred.resolve, { once: true });
  155.  
  156.         return deferred;
  157.     }
  158.  
  159.     function createDeepCopy(obj) {
  160.         return nativeJSONParse(JSON.stringify(obj));
  161.     }
  162.  
  163.     function getYtcfgValue(name) {
  164.         var _window$ytcfg;
  165.         return (_window$ytcfg = window.ytcfg) === null || _window$ytcfg === void 0 ? void 0 : _window$ytcfg.get(name);
  166.     }
  167.  
  168.     function getSignatureTimestamp() {
  169.         return (
  170.             getYtcfgValue('STS')
  171.             || (() => {
  172.                 var _document$querySelect;
  173.                 // STS is missing on embedded player. Retrieve from player base script as fallback...
  174.                 const playerBaseJsPath = (_document$querySelect = document.querySelector('script[src*="/base.js"]')) === null || _document$querySelect === void 0
  175.                     ? void 0
  176.                     : _document$querySelect.src;
  177.  
  178.                 if (!playerBaseJsPath) return;
  179.  
  180.                 const xmlhttp = new XMLHttpRequest();
  181.                 xmlhttp.open('GET', playerBaseJsPath, false);
  182.                 xmlhttp.send(null);
  183.  
  184.                 return parseInt(xmlhttp.responseText.match(/signatureTimestamp:([0-9]*)/)[1]);
  185.             })()
  186.         );
  187.     }
  188.  
  189.     function isUserLoggedIn() {
  190.         // LOGGED_IN doesn't exist on embedded page, use DELEGATED_SESSION_ID or SESSION_INDEX as fallback
  191.         if (typeof getYtcfgValue('LOGGED_IN') === 'boolean') return getYtcfgValue('LOGGED_IN');
  192.         if (typeof getYtcfgValue('DELEGATED_SESSION_ID') === 'string') return true;
  193.         if (parseInt(getYtcfgValue('SESSION_INDEX')) >= 0) return true;
  194.  
  195.         return false;
  196.     }
  197.  
  198.     function getCurrentVideoStartTime(currentVideoId) {
  199.         // Check if the URL corresponds to the requested video
  200.         // This is not the case when the player gets preloaded for the next video in a playlist.
  201.         if (window.location.href.includes(currentVideoId)) {
  202.             var _ref;
  203.             // "t"-param on youtu.be urls
  204.             // "start"-param on embed player
  205.             // "time_continue" when clicking "watch on youtube" on embedded player
  206.             const urlParams = new URLSearchParams(window.location.search);
  207.             const startTimeString = (_ref = urlParams.get('t') || urlParams.get('start') || urlParams.get('time_continue')) === null || _ref === void 0
  208.                 ? void 0
  209.                 : _ref.replace('s', '');
  210.  
  211.             if (startTimeString && !isNaN(startTimeString)) {
  212.                 return parseInt(startTimeString);
  213.             }
  214.         }
  215.  
  216.         return 0;
  217.     }
  218.  
  219.     function setUrlParams(params) {
  220.         const urlParams = new URLSearchParams(window.location.search);
  221.         for (const paramName in params) {
  222.             urlParams.set(paramName, params[paramName]);
  223.         }
  224.         window.location.search = urlParams;
  225.     }
  226.  
  227.     function waitForElement(elementSelector, timeout) {
  228.         const deferred = new Deferred();
  229.  
  230.         const checkDomInterval = setInterval(() => {
  231.             const elem = document.querySelector(elementSelector);
  232.             if (elem) {
  233.                 clearInterval(checkDomInterval);
  234.                 deferred.resolve(elem);
  235.             }
  236.         }, 100);
  237.  
  238.         if (timeout) {
  239.             setTimeout(() => {
  240.                 clearInterval(checkDomInterval);
  241.                 deferred.reject();
  242.             }, timeout);
  243.         }
  244.  
  245.         return deferred;
  246.     }
  247.  
  248.     function parseRelativeUrl(url) {
  249.         if (typeof url !== 'string') {
  250.             return null;
  251.         }
  252.  
  253.         if (url.indexOf('/') === 0) {
  254.             url = window.location.origin + url;
  255.         }
  256.  
  257.         try {
  258.             return url.indexOf('https://') === 0 ? new window.URL(url) : null;
  259.         } catch {
  260.             return null;
  261.         }
  262.     }
  263.  
  264.     function isWatchNextObject(parsedData) {
  265.         var _parsedData$currentVi;
  266.         if (
  267.             !(parsedData !== null && parsedData !== void 0 && parsedData.contents)
  268.             || !(parsedData !== null && parsedData !== void 0 && (_parsedData$currentVi = parsedData.currentVideoEndpoint) !== null && _parsedData$currentVi !== void 0
  269.                 && (_parsedData$currentVi = _parsedData$currentVi.watchEndpoint) !== null && _parsedData$currentVi !== void 0 && _parsedData$currentVi.videoId)
  270.         ) return false;
  271.         return !!parsedData.contents.twoColumnWatchNextResults || !!parsedData.contents.singleColumnWatchNextResults;
  272.     }
  273.  
  274.     function isWatchNextSidebarEmpty(parsedData) {
  275.         var _parsedData$contents2, _content$find;
  276.         if (isDesktop) {
  277.             var _parsedData$contents;
  278.             // WEB response layout
  279.             const result = (_parsedData$contents = parsedData.contents) === null || _parsedData$contents === void 0
  280.                     || (_parsedData$contents = _parsedData$contents.twoColumnWatchNextResults) === null || _parsedData$contents === void 0
  281.                     || (_parsedData$contents = _parsedData$contents.secondaryResults) === null || _parsedData$contents === void 0
  282.                     || (_parsedData$contents = _parsedData$contents.secondaryResults) === null || _parsedData$contents === void 0
  283.                 ? void 0
  284.                 : _parsedData$contents.results;
  285.             return !result;
  286.         }
  287.  
  288.         // MWEB response layout
  289.         const content = (_parsedData$contents2 = parsedData.contents) === null || _parsedData$contents2 === void 0
  290.                 || (_parsedData$contents2 = _parsedData$contents2.singleColumnWatchNextResults) === null || _parsedData$contents2 === void 0
  291.                 || (_parsedData$contents2 = _parsedData$contents2.results) === null || _parsedData$contents2 === void 0
  292.                 || (_parsedData$contents2 = _parsedData$contents2.results) === null || _parsedData$contents2 === void 0
  293.             ? void 0
  294.             : _parsedData$contents2.contents;
  295.         const result = content === null || content === void 0 || (_content$find = content.find((e) => {
  296.                     var _e$itemSectionRendere;
  297.                     return ((_e$itemSectionRendere = e.itemSectionRenderer) === null || _e$itemSectionRendere === void 0 ? void 0 : _e$itemSectionRendere.targetId)
  298.                         === 'watch-next-feed';
  299.                 })) === null
  300.                 || _content$find === void 0
  301.             ? void 0
  302.             : _content$find.itemSectionRenderer;
  303.         return typeof result !== 'object';
  304.     }
  305.  
  306.     function isPlayerObject(parsedData) {
  307.         return (parsedData === null || parsedData === void 0 ? void 0 : parsedData.videoDetails)
  308.             && (parsedData === null || parsedData === void 0 ? void 0 : parsedData.playabilityStatus);
  309.     }
  310.  
  311.     function isEmbeddedPlayerObject(parsedData) {
  312.         return typeof (parsedData === null || parsedData === void 0 ? void 0 : parsedData.previewPlayabilityStatus) === 'object';
  313.     }
  314.  
  315.     function isAgeRestricted(playabilityStatus) {
  316.         var _playabilityStatus$er;
  317.         if (!(playabilityStatus !== null && playabilityStatus !== void 0 && playabilityStatus.status)) return false;
  318.         if (playabilityStatus.desktopLegacyAgeGateReason) return true;
  319.         if (Config.UNLOCKABLE_PLAYABILITY_STATUSES.includes(playabilityStatus.status)) return true;
  320.  
  321.         // Fix to detect age restrictions on embed player
  322.         // see https://github.com/zerodytrash/Simple-YouTube-Age-Restriction-Bypass/issues/85#issuecomment-946853553
  323.         return (
  324.             isEmbed
  325.             && ((_playabilityStatus$er = playabilityStatus.errorScreen) === null || _playabilityStatus$er === void 0
  326.                     || (_playabilityStatus$er = _playabilityStatus$er.playerErrorMessageRenderer) === null || _playabilityStatus$er === void 0
  327.                     || (_playabilityStatus$er = _playabilityStatus$er.reason) === null || _playabilityStatus$er === void 0
  328.                     || (_playabilityStatus$er = _playabilityStatus$er.runs) === null || _playabilityStatus$er === void 0
  329.                     || (_playabilityStatus$er = _playabilityStatus$er.find((x) => x.navigationEndpoint)) === null || _playabilityStatus$er === void 0
  330.                     || (_playabilityStatus$er = _playabilityStatus$er.navigationEndpoint) === null || _playabilityStatus$er === void 0
  331.                     || (_playabilityStatus$er = _playabilityStatus$er.urlEndpoint) === null || _playabilityStatus$er === void 0
  332.                     || (_playabilityStatus$er = _playabilityStatus$er.url) === null || _playabilityStatus$er === void 0
  333.                 ? void 0
  334.                 : _playabilityStatus$er.includes('/2802167'))
  335.         );
  336.     }
  337.  
  338.     function isSearchResult(parsedData) {
  339.         var _parsedData$contents3, _parsedData$contents4, _parsedData$onRespons;
  340.         return (
  341.             typeof (parsedData === null || parsedData === void 0 || (_parsedData$contents3 = parsedData.contents) === null || _parsedData$contents3 === void 0
  342.                     ? void 0
  343.                     : _parsedData$contents3.twoColumnSearchResultsRenderer) === 'object' // Desktop initial results
  344.             || (parsedData === null || parsedData === void 0 || (_parsedData$contents4 = parsedData.contents) === null || _parsedData$contents4 === void 0
  345.                         || (_parsedData$contents4 = _parsedData$contents4.sectionListRenderer) === null || _parsedData$contents4 === void 0
  346.                     ? void 0
  347.                     : _parsedData$contents4.targetId) === 'search-feed' // Mobile initial results
  348.             || (parsedData === null || parsedData === void 0 || (_parsedData$onRespons = parsedData.onResponseReceivedCommands) === null || _parsedData$onRespons === void 0
  349.                         || (_parsedData$onRespons = _parsedData$onRespons.find((x) => x.appendContinuationItemsAction)) === null || _parsedData$onRespons === void 0
  350.                         || (_parsedData$onRespons = _parsedData$onRespons.appendContinuationItemsAction) === null || _parsedData$onRespons === void 0
  351.                     ? void 0
  352.                     : _parsedData$onRespons.targetId) === 'search-feed' // Desktop & Mobile scroll continuation
  353.         );
  354.     }
  355.  
  356.     function attach$4(obj, prop, onCall) {
  357.         if (!obj || typeof obj[prop] !== 'function') {
  358.             return;
  359.         }
  360.  
  361.         let original = obj[prop];
  362.  
  363.         obj[prop] = function() {
  364.             try {
  365.                 onCall(arguments);
  366.             } catch {}
  367.             original.apply(this, arguments);
  368.         };
  369.     }
  370.  
  371.     const logPrefix = '%cSimple-YouTube-Age-Restriction-Bypass:';
  372.     const logPrefixStyle = 'background-color: #1e5c85; color: #fff; font-size: 1.2em;';
  373.     const logSuffix = '\uD83D\uDC1E You can report bugs at: https://github.com/zerodytrash/Simple-YouTube-Age-Restriction-Bypass/issues';
  374.  
  375.     function error(err, msg) {
  376.         console.error(logPrefix, logPrefixStyle, msg, err, getYtcfgDebugString(), '\n\n', logSuffix);
  377.         if (window.SYARB_CONFIG) {
  378.             window.dispatchEvent(
  379.                 new CustomEvent('SYARB_LOG_ERROR', {
  380.                     detail: {
  381.                         message: (msg ? msg + '; ' : '') + (err && err.message ? err.message : ''),
  382.                         stack: err && err.stack ? err.stack : null,
  383.                     },
  384.                 }),
  385.             );
  386.         }
  387.     }
  388.  
  389.     function info(msg) {
  390.         console.info(logPrefix, logPrefixStyle, msg);
  391.         if (window.SYARB_CONFIG) {
  392.             window.dispatchEvent(
  393.                 new CustomEvent('SYARB_LOG_INFO', {
  394.                     detail: {
  395.                         message: msg,
  396.                     },
  397.                 }),
  398.             );
  399.         }
  400.     }
  401.  
  402.     function getYtcfgDebugString() {
  403.         try {
  404.             return (
  405.                 `InnertubeConfig: `
  406.                 + `innertubeApiKey: ${getYtcfgValue('INNERTUBE_API_KEY')} `
  407.                 + `innertubeClientName: ${getYtcfgValue('INNERTUBE_CLIENT_NAME')} `
  408.                 + `innertubeClientVersion: ${getYtcfgValue('INNERTUBE_CLIENT_VERSION')} `
  409.                 + `loggedIn: ${getYtcfgValue('LOGGED_IN')} `
  410.             );
  411.         } catch (err) {
  412.             return `Failed to access config: ${err}`;
  413.         }
  414.     }
  415.  
  416.     /**
  417.      * And here we deal with YouTube's crappy initial data (present in page source) and the problems that occur when intercepting that data.
  418.      * YouTube has some protections in place that make it difficult to intercept and modify the global ytInitialPlayerResponse variable.
  419.      * The easiest way would be to set a descriptor on that variable to change the value directly on declaration.
  420.      * But some adblockers define their own descriptors on the ytInitialPlayerResponse variable, which makes it hard to register another descriptor on it.
  421.      * As a workaround only the relevant playerResponse property of the ytInitialPlayerResponse variable will be intercepted.
  422.      * This is achieved by defining a descriptor on the object prototype for that property, which affects any object with a `playerResponse` property.
  423.      */
  424.     function attach$3(onInitialData) {
  425.         interceptObjectProperty('playerResponse', (obj, playerResponse) => {
  426.             info(`playerResponse property set, contains sidebar: ${!!obj.response}`);
  427.  
  428.             // The same object also contains the sidebar data and video description
  429.             if (isObject(obj.response)) onInitialData(obj.response);
  430.  
  431.             // If the script is executed too late and the bootstrap data has already been processed,
  432.             // a reload of the player can be forced by creating a deep copy of the object.
  433.             // This is especially relevant if the userscript manager does not handle the `@run-at document-start` correctly.
  434.             playerResponse.unlocked = false;
  435.             onInitialData(playerResponse);
  436.             return playerResponse.unlocked ? createDeepCopy(playerResponse) : playerResponse;
  437.         });
  438.  
  439.         // The global `ytInitialData` variable can be modified on the fly.
  440.         // It contains search results, sidebar data and meta information
  441.         // Not really important but fixes https://github.com/zerodytrash/Simple-YouTube-Age-Restriction-Bypass/issues/127
  442.         window.addEventListener('DOMContentLoaded', () => {
  443.             if (isObject(window.ytInitialData)) {
  444.                 onInitialData(window.ytInitialData);
  445.             }
  446.         });
  447.     }
  448.  
  449.     function interceptObjectProperty(prop, onSet) {
  450.         var _Object$getOwnPropert;
  451.         // Allow other userscripts to decorate this descriptor, if they do something similar
  452.         const dataKey = '__SYARB_' + prop;
  453.         const { get: getter, set: setter } = (_Object$getOwnPropert = Object.getOwnPropertyDescriptor(Object.prototype, prop)) !== null && _Object$getOwnPropert !== void 0
  454.             ? _Object$getOwnPropert
  455.             : {
  456.                 set(value) {
  457.                     this[dataKey] = value;
  458.                 },
  459.                 get() {
  460.                     return this[dataKey];
  461.                 },
  462.             };
  463.  
  464.         // Intercept the given property on any object
  465.         // The assigned attribute value and the context (enclosing object) are passed to the onSet function.
  466.         Object.defineProperty(Object.prototype, prop, {
  467.             set(value) {
  468.                 setter.call(this, isObject(value) ? onSet(this, value) : value);
  469.             },
  470.             get() {
  471.                 return getter.call(this);
  472.             },
  473.             configurable: true,
  474.         });
  475.     }
  476.  
  477.     // Intercept, inspect and modify JSON-based communication to unlock player responses by hijacking the JSON.parse function
  478.     function attach$2(onJsonDataReceived) {
  479.         window.JSON.parse = function() {
  480.             const data = nativeJSONParse.apply(this, arguments);
  481.             return isObject(data) ? onJsonDataReceived(data) : data;
  482.         };
  483.     }
  484.  
  485.     function attach$1(onRequestCreate) {
  486.         if (typeof window.Request !== 'function') {
  487.             return;
  488.         }
  489.  
  490.         window.Request = new Proxy(window.Request, {
  491.             construct(target, args) {
  492.                 const [url, options] = args;
  493.                 try {
  494.                     const parsedUrl = parseRelativeUrl(url);
  495.                     const modifiedUrl = onRequestCreate(parsedUrl, options);
  496.  
  497.                     if (modifiedUrl) {
  498.                         args[0] = modifiedUrl.toString();
  499.                     }
  500.                 } catch (err) {
  501.                     error(err, `Failed to intercept Request()`);
  502.                 }
  503.  
  504.                 return Reflect.construct(...arguments);
  505.             },
  506.         });
  507.     }
  508.  
  509.     function attach(onXhrOpenCalled) {
  510.         XMLHttpRequest.prototype.open = function(method, url) {
  511.             try {
  512.                 let parsedUrl = parseRelativeUrl(url);
  513.  
  514.                 if (parsedUrl) {
  515.                     const modifiedUrl = onXhrOpenCalled(method, parsedUrl, this);
  516.  
  517.                     if (modifiedUrl) {
  518.                         arguments[1] = modifiedUrl.toString();
  519.                     }
  520.                 }
  521.             } catch (err) {
  522.                 error(err, `Failed to intercept XMLHttpRequest.open()`);
  523.             }
  524.  
  525.             nativeXMLHttpRequestOpen.apply(this, arguments);
  526.         };
  527.     }
  528.  
  529.     const localStoragePrefix = 'SYARB_';
  530.  
  531.     function set(key, value) {
  532.         localStorage.setItem(localStoragePrefix + key, JSON.stringify(value));
  533.     }
  534.  
  535.     function get(key) {
  536.         try {
  537.             return JSON.parse(localStorage.getItem(localStoragePrefix + key));
  538.         } catch {
  539.             return null;
  540.         }
  541.     }
  542.  
  543.     function getPlayer$1(payload, useAuth) {
  544.         return sendInnertubeRequest('v1/player', payload, useAuth);
  545.     }
  546.  
  547.     function getNext$1(payload, useAuth) {
  548.         return sendInnertubeRequest('v1/next', payload, useAuth);
  549.     }
  550.  
  551.     function sendInnertubeRequest(endpoint, payload, useAuth) {
  552.         const xmlhttp = new XMLHttpRequest();
  553.         xmlhttp.open('POST', `/youtubei/${endpoint}?key=${getYtcfgValue('INNERTUBE_API_KEY')}&prettyPrint=false`, false);
  554.  
  555.         if (useAuth && isUserLoggedIn()) {
  556.             xmlhttp.withCredentials = true;
  557.             Config.GOOGLE_AUTH_HEADER_NAMES.forEach((headerName) => {
  558.                 xmlhttp.setRequestHeader(headerName, get(headerName));
  559.             });
  560.         }
  561.  
  562.         xmlhttp.send(JSON.stringify(payload));
  563.         return nativeJSONParse(xmlhttp.responseText);
  564.     }
  565.  
  566.     var innertube = {
  567.         getPlayer: getPlayer$1,
  568.         getNext: getNext$1,
  569.     };
  570.  
  571.     let nextResponseCache = {};
  572.  
  573.     function getGoogleVideoUrl(originalUrl) {
  574.         return Config.VIDEO_PROXY_SERVER_HOST + '/direct/' + btoa(originalUrl.toString());
  575.     }
  576.  
  577.     function getPlayer(payload) {
  578.         // Also request the /next response if a later /next request is likely.
  579.         if (!nextResponseCache[payload.videoId] && !isMusic && !isEmbed) {
  580.             payload.includeNext = 1;
  581.         }
  582.  
  583.         return sendRequest('getPlayer', payload);
  584.     }
  585.  
  586.     function getNext(payload) {
  587.         // Next response already cached? => Return cached content
  588.         if (nextResponseCache[payload.videoId]) {
  589.             return nextResponseCache[payload.videoId];
  590.         }
  591.  
  592.         return sendRequest('getNext', payload);
  593.     }
  594.  
  595.     function sendRequest(endpoint, payload) {
  596.         const queryParams = new URLSearchParams(payload);
  597.         const proxyUrl = `${Config.ACCOUNT_PROXY_SERVER_HOST}/${endpoint}?${queryParams}&client=js`;
  598.  
  599.         try {
  600.             const xmlhttp = new XMLHttpRequest();
  601.             xmlhttp.open('GET', proxyUrl, false);
  602.             xmlhttp.send(null);
  603.  
  604.             const proxyResponse = nativeJSONParse(xmlhttp.responseText);
  605.  
  606.             // Mark request as 'proxied'
  607.             proxyResponse.proxied = true;
  608.  
  609.             // Put included /next response in the cache
  610.             if (proxyResponse.nextResponse) {
  611.                 nextResponseCache[payload.videoId] = proxyResponse.nextResponse;
  612.                 delete proxyResponse.nextResponse;
  613.             }
  614.  
  615.             return proxyResponse;
  616.         } catch (err) {
  617.             error(err, 'Proxy API Error');
  618.             return { errorMessage: 'Proxy Connection failed' };
  619.         }
  620.     }
  621.  
  622.     var proxy = {
  623.         getPlayer,
  624.         getNext,
  625.         getGoogleVideoUrl,
  626.     };
  627.  
  628.     function getUnlockStrategies$1(videoId, lastPlayerUnlockReason) {
  629.         var _getYtcfgValue$client;
  630.         const clientName = getYtcfgValue('INNERTUBE_CLIENT_NAME') || 'WEB';
  631.         const clientVersion = getYtcfgValue('INNERTUBE_CLIENT_VERSION') || '2.20220203.04.00';
  632.         const hl = getYtcfgValue('HL');
  633.         const userInterfaceTheme = (_getYtcfgValue$client = getYtcfgValue('INNERTUBE_CONTEXT').client.userInterfaceTheme) !== null && _getYtcfgValue$client !== void 0
  634.             ? _getYtcfgValue$client
  635.             : document.documentElement.hasAttribute('dark')
  636.             ? 'USER_INTERFACE_THEME_DARK'
  637.             : 'USER_INTERFACE_THEME_LIGHT';
  638.  
  639.         return [
  640.             /**
  641.              * Retrieve the sidebar and video description by just adding `racyCheckOk` and `contentCheckOk` params
  642.              * This strategy can be used to bypass content warnings
  643.              */
  644.             {
  645.                 name: 'Content Warning Bypass',
  646.                 skip: !lastPlayerUnlockReason || !lastPlayerUnlockReason.includes('CHECK_REQUIRED'),
  647.                 optionalAuth: true,
  648.                 payload: {
  649.                     context: {
  650.                         client: {
  651.                             clientName,
  652.                             clientVersion,
  653.                             hl,
  654.                             userInterfaceTheme,
  655.                         },
  656.                     },
  657.                     videoId,
  658.                     racyCheckOk: true,
  659.                     contentCheckOk: true,
  660.                 },
  661.                 endpoint: innertube,
  662.             },
  663.             /**
  664.              * Retrieve the sidebar and video description from an account proxy server.
  665.              * Session cookies of an age-verified Google account are stored on server side.
  666.              * See https://github.com/zerodytrash/Simple-YouTube-Age-Restriction-Bypass/tree/main/account-proxy
  667.              */
  668.             {
  669.                 name: 'Account Proxy',
  670.                 payload: {
  671.                     videoId,
  672.                     clientName,
  673.                     clientVersion,
  674.                     hl,
  675.                     userInterfaceTheme,
  676.                     isEmbed: +isEmbed,
  677.                     isConfirmed: +isConfirmed,
  678.                 },
  679.                 endpoint: proxy,
  680.             },
  681.         ];
  682.     }
  683.  
  684.     function getUnlockStrategies(videoId, reason) {
  685.         const clientName = getYtcfgValue('INNERTUBE_CLIENT_NAME') || 'WEB';
  686.         const clientVersion = getYtcfgValue('INNERTUBE_CLIENT_VERSION') || '2.20220203.04.00';
  687.         const signatureTimestamp = getSignatureTimestamp();
  688.         const startTimeSecs = getCurrentVideoStartTime(videoId);
  689.         const hl = getYtcfgValue('HL');
  690.  
  691.         return [
  692.             /**
  693.              * Retrieve the video info by just adding `racyCheckOk` and `contentCheckOk` params
  694.              * This strategy can be used to bypass content warnings
  695.              */
  696.             {
  697.                 name: 'Content Warning Bypass',
  698.                 skip: !reason || !reason.includes('CHECK_REQUIRED'),
  699.                 optionalAuth: true,
  700.                 payload: {
  701.                     context: {
  702.                         client: {
  703.                             clientName: clientName,
  704.                             clientVersion: clientVersion,
  705.                             hl,
  706.                         },
  707.                     },
  708.                     playbackContext: {
  709.                         contentPlaybackContext: {
  710.                             signatureTimestamp,
  711.                         },
  712.                     },
  713.                     videoId,
  714.                     startTimeSecs,
  715.                     racyCheckOk: true,
  716.                     contentCheckOk: true,
  717.                 },
  718.                 endpoint: innertube,
  719.             },
  720.             /**
  721.              * Retrieve the video info by using the TVHTML5 Embedded client
  722.              * This client has no age restrictions in place (2022-03-28)
  723.              * See https://github.com/zerodytrash/YouTube-Internal-Clients
  724.              */
  725.             {
  726.                 name: 'TV Embedded Player',
  727.                 requiresAuth: false,
  728.                 payload: {
  729.                     context: {
  730.                         client: {
  731.                             clientName: 'TVHTML5_SIMPLY_EMBEDDED_PLAYER',
  732.                             clientVersion: '2.0',
  733.                             clientScreen: 'WATCH',
  734.                             hl,
  735.                         },
  736.                         thirdParty: {
  737.                             embedUrl: 'https://www.youtube.com/',
  738.                         },
  739.                     },
  740.                     playbackContext: {
  741.                         contentPlaybackContext: {
  742.                             signatureTimestamp,
  743.                         },
  744.                     },
  745.                     videoId,
  746.                     startTimeSecs,
  747.                     racyCheckOk: true,
  748.                     contentCheckOk: true,
  749.                 },
  750.                 endpoint: innertube,
  751.             },
  752.             /**
  753.              * Retrieve the video info by using the WEB_CREATOR client in combination with user authentication
  754.              * Requires that the user is logged in. Can bypass the tightened age verification in the EU.
  755.              * See https://github.com/yt-dlp/yt-dlp/pull/600
  756.              */
  757.             {
  758.                 name: 'Creator + Auth',
  759.                 requiresAuth: true,
  760.                 payload: {
  761.                     context: {
  762.                         client: {
  763.                             clientName: 'WEB_CREATOR',
  764.                             clientVersion: '1.20210909.07.00',
  765.                             hl,
  766.                         },
  767.                     },
  768.                     playbackContext: {
  769.                         contentPlaybackContext: {
  770.                             signatureTimestamp,
  771.                         },
  772.                     },
  773.                     videoId,
  774.                     startTimeSecs,
  775.                     racyCheckOk: true,
  776.                     contentCheckOk: true,
  777.                 },
  778.                 endpoint: innertube,
  779.             },
  780.             /**
  781.              * Retrieve the video info from an account proxy server.
  782.              * Session cookies of an age-verified Google account are stored on server side.
  783.              * See https://github.com/zerodytrash/Simple-YouTube-Age-Restriction-Bypass/tree/main/account-proxy
  784.              */
  785.             {
  786.                 name: 'Account Proxy',
  787.                 payload: {
  788.                     videoId,
  789.                     reason,
  790.                     clientName,
  791.                     clientVersion,
  792.                     signatureTimestamp,
  793.                     startTimeSecs,
  794.                     hl,
  795.                     isEmbed: +isEmbed,
  796.                     isConfirmed: +isConfirmed,
  797.                 },
  798.                 endpoint: proxy,
  799.             },
  800.         ];
  801.     }
  802.  
  803.     var buttonTemplate =
  804.         '<div style="margin-top: 15px !important; padding: 3px 10px 3px 10px; margin: 0px auto; background-color: #4d4d4d; width: fit-content; font-size: 1.2em; text-transform: uppercase; border-radius: 3px; cursor: pointer;">\n    <div class="button-text"></div>\n</div>';
  805.  
  806.     let buttons = {};
  807.  
  808.     async function addButton(id, text, backgroundColor, onClick) {
  809.         const errorScreenElement = await waitForElement('.ytp-error', 2000);
  810.         const buttonElement = createElement('div', { class: 'button-container', innerHTML: buttonTemplate });
  811.         buttonElement.getElementsByClassName('button-text')[0].innerText = text;
  812.  
  813.         if (backgroundColor) {
  814.             buttonElement.querySelector(':scope > div').style['background-color'] = backgroundColor;
  815.         }
  816.  
  817.         if (typeof onClick === 'function') {
  818.             buttonElement.addEventListener('click', onClick);
  819.         }
  820.  
  821.         // Button already attached?
  822.         if (buttons[id] && buttons[id].isConnected) {
  823.             return;
  824.         }
  825.  
  826.         buttons[id] = buttonElement;
  827.         errorScreenElement.append(buttonElement);
  828.     }
  829.  
  830.     function removeButton(id) {
  831.         if (buttons[id] && buttons[id].isConnected) {
  832.             buttons[id].remove();
  833.         }
  834.     }
  835.  
  836.     const confirmationButtonId = 'confirmButton';
  837.     const confirmationButtonText = 'Click to unlock';
  838.  
  839.     function isConfirmationRequired() {
  840.         return !isConfirmed && isEmbed && Config.ENABLE_UNLOCK_CONFIRMATION_EMBED;
  841.     }
  842.  
  843.     function requestConfirmation() {
  844.         addButton(confirmationButtonId, confirmationButtonText, null, () => {
  845.             removeButton(confirmationButtonId);
  846.             confirm();
  847.         });
  848.     }
  849.  
  850.     function confirm() {
  851.         setUrlParams({
  852.             unlock_confirmed: 1,
  853.             autoplay: 1,
  854.         });
  855.     }
  856.  
  857.     var tDesktop = '<tp-yt-paper-toast></tp-yt-paper-toast>\n';
  858.  
  859.     var tMobile =
  860.         '<c3-toast>\n    <ytm-notification-action-renderer>\n        <div class="notification-action-response-text"></div>\n    </ytm-notification-action-renderer>\n</c3-toast>\n';
  861.  
  862.     const template = isDesktop ? tDesktop : tMobile;
  863.  
  864.     const nToastContainer = createElement('div', { id: 'toast-container', innerHTML: template });
  865.     const nToast = nToastContainer.querySelector(':scope > *');
  866.  
  867.     // On YT Music show the toast above the player controls
  868.     if (isMusic) {
  869.         nToast.style['margin-bottom'] = '85px';
  870.     }
  871.  
  872.     if (!isDesktop) {
  873.         nToast.nMessage = nToast.querySelector('.notification-action-response-text');
  874.         nToast.show = (message) => {
  875.             nToast.nMessage.innerText = message;
  876.             nToast.setAttribute('dir', 'in');
  877.             setTimeout(() => {
  878.                 nToast.setAttribute('dir', 'out');
  879.             }, nToast.duration + 225);
  880.         };
  881.     }
  882.  
  883.     async function show(message, duration = 5) {
  884.         if (!Config.ENABLE_UNLOCK_NOTIFICATION) return;
  885.         if (isEmbed) return;
  886.  
  887.         await pageLoaded();
  888.  
  889.         // Do not show notification when tab is in background
  890.         if (document.visibilityState === 'hidden') return;
  891.  
  892.         // Append toast container to DOM, if not already done
  893.         if (!nToastContainer.isConnected) document.documentElement.append(nToastContainer);
  894.  
  895.         nToast.duration = duration * 1000;
  896.         nToast.show(message);
  897.     }
  898.  
  899.     var Toast = { show };
  900.  
  901.     const messagesMap = {
  902.         success: 'Age-restricted video successfully unlocked!',
  903.         fail: 'Unable to unlock this video 🙁 - More information in the developer console',
  904.     };
  905.  
  906.     let lastPlayerUnlockVideoId = null;
  907.     let lastPlayerUnlockReason = null;
  908.  
  909.     let lastProxiedGoogleVideoUrlParams;
  910.     let cachedPlayerResponse = {};
  911.  
  912.     function getLastProxiedGoogleVideoId() {
  913.         var _lastProxiedGoogleVid;
  914.         return (_lastProxiedGoogleVid = lastProxiedGoogleVideoUrlParams) === null || _lastProxiedGoogleVid === void 0 ? void 0 : _lastProxiedGoogleVid.get('id');
  915.     }
  916.  
  917.     function unlockResponse$1(playerResponse) {
  918.         var _playerResponse$video, _playerResponse$playa, _playerResponse$previ, _unlockedPlayerRespon, _unlockedPlayerRespon3;
  919.         // Check if the user has to confirm the unlock first
  920.         if (isConfirmationRequired()) {
  921.             info('Unlock confirmation required.');
  922.             requestConfirmation();
  923.             return;
  924.         }
  925.  
  926.         const videoId = ((_playerResponse$video = playerResponse.videoDetails) === null || _playerResponse$video === void 0 ? void 0 : _playerResponse$video.videoId)
  927.             || getYtcfgValue('PLAYER_VARS').video_id;
  928.         const reason = ((_playerResponse$playa = playerResponse.playabilityStatus) === null || _playerResponse$playa === void 0 ? void 0 : _playerResponse$playa.status)
  929.             || ((_playerResponse$previ = playerResponse.previewPlayabilityStatus) === null || _playerResponse$previ === void 0 ? void 0 : _playerResponse$previ.status);
  930.  
  931.         if (!Config.SKIP_CONTENT_WARNINGS && reason.includes('CHECK_REQUIRED')) {
  932.             info(`SKIP_CONTENT_WARNINGS disabled and ${reason} status detected.`);
  933.             return;
  934.         }
  935.  
  936.         lastPlayerUnlockVideoId = videoId;
  937.         lastPlayerUnlockReason = reason;
  938.  
  939.         const unlockedPlayerResponse = getUnlockedPlayerResponse(videoId, reason);
  940.  
  941.         // account proxy error?
  942.         if (unlockedPlayerResponse.errorMessage) {
  943.             Toast.show(`${messagesMap.fail} (ProxyError)`, 10);
  944.             throw new Error(`Player Unlock Failed, Proxy Error Message: ${unlockedPlayerResponse.errorMessage}`);
  945.         }
  946.  
  947.         // check if the unlocked response isn't playable
  948.         if (
  949.             !Config.VALID_PLAYABILITY_STATUSES.includes(
  950.                 (_unlockedPlayerRespon = unlockedPlayerResponse.playabilityStatus) === null || _unlockedPlayerRespon === void 0 ? void 0 : _unlockedPlayerRespon.status,
  951.             )
  952.         ) {
  953.             var _unlockedPlayerRespon2;
  954.             Toast.show(`${messagesMap.fail} (PlayabilityError)`, 10);
  955.             throw new Error(
  956.                 `Player Unlock Failed, playabilityStatus: ${
  957.                     (_unlockedPlayerRespon2 = unlockedPlayerResponse.playabilityStatus) === null || _unlockedPlayerRespon2 === void 0 ? void 0 : _unlockedPlayerRespon2.status
  958.                 }`,
  959.             );
  960.         }
  961.  
  962.         // if the video info was retrieved via proxy, store the URL params from the url-attribute to detect later if the requested video file (googlevideo.com) need a proxy.
  963.         if (
  964.             unlockedPlayerResponse.proxied && (_unlockedPlayerRespon3 = unlockedPlayerResponse.streamingData) !== null && _unlockedPlayerRespon3 !== void 0
  965.             && _unlockedPlayerRespon3.adaptiveFormats
  966.         ) {
  967.             var _unlockedPlayerRespon4, _unlockedPlayerRespon5;
  968.             const cipherText = (_unlockedPlayerRespon4 = unlockedPlayerResponse.streamingData.adaptiveFormats.find((x) =>
  969.                             x.signatureCipher
  970.                         )) === null || _unlockedPlayerRespon4 === void 0
  971.                 ? void 0
  972.                 : _unlockedPlayerRespon4.signatureCipher;
  973.             const videoUrl = cipherText
  974.                 ? new URLSearchParams(cipherText).get('url')
  975.                 : (_unlockedPlayerRespon5 = unlockedPlayerResponse.streamingData.adaptiveFormats.find((x) => x.url)) === null || _unlockedPlayerRespon5 === void 0
  976.                 ? void 0
  977.                 : _unlockedPlayerRespon5.url;
  978.  
  979.             lastProxiedGoogleVideoUrlParams = videoUrl ? new URLSearchParams(new window.URL(videoUrl).search) : null;
  980.         }
  981.  
  982.         // Overwrite the embedded (preview) playabilityStatus with the unlocked one
  983.         if (playerResponse.previewPlayabilityStatus) {
  984.             playerResponse.previewPlayabilityStatus = unlockedPlayerResponse.playabilityStatus;
  985.         }
  986.  
  987.         // Transfer all unlocked properties to the original player response
  988.         Object.assign(playerResponse, unlockedPlayerResponse);
  989.  
  990.         playerResponse.unlocked = true;
  991.  
  992.         Toast.show(messagesMap.success);
  993.     }
  994.  
  995.     function getUnlockedPlayerResponse(videoId, reason) {
  996.         // Check if response is cached
  997.         if (cachedPlayerResponse.videoId === videoId) return createDeepCopy(cachedPlayerResponse);
  998.  
  999.         const unlockStrategies = getUnlockStrategies(videoId, reason);
  1000.  
  1001.         let unlockedPlayerResponse = {};
  1002.  
  1003.         // Try every strategy until one of them works
  1004.         unlockStrategies.every((strategy, index) => {
  1005.             var _unlockedPlayerRespon6;
  1006.             // Skip strategy if authentication is required and the user is not logged in
  1007.             if (strategy.skip || strategy.requiresAuth && !isUserLoggedIn()) return true;
  1008.  
  1009.             info(`Trying Player Unlock Method #${index + 1} (${strategy.name})`);
  1010.  
  1011.             try {
  1012.                 unlockedPlayerResponse = strategy.endpoint.getPlayer(strategy.payload, strategy.requiresAuth || strategy.optionalAuth);
  1013.             } catch (err) {
  1014.                 error(err, `Player Unlock Method ${index + 1} failed with exception`);
  1015.             }
  1016.  
  1017.             const isStatusValid = Config.VALID_PLAYABILITY_STATUSES.includes(
  1018.                 (_unlockedPlayerRespon6 = unlockedPlayerResponse) === null || _unlockedPlayerRespon6 === void 0
  1019.                     || (_unlockedPlayerRespon6 = _unlockedPlayerRespon6.playabilityStatus) === null || _unlockedPlayerRespon6 === void 0
  1020.                     ? void 0
  1021.                     : _unlockedPlayerRespon6.status,
  1022.             );
  1023.  
  1024.             if (isStatusValid) {
  1025.                 var _unlockedPlayerRespon7;
  1026.                 /**
  1027.                  * Workaround: https://github.com/zerodytrash/Simple-YouTube-Age-Restriction-Bypass/issues/191
  1028.                  *
  1029.                  * YouTube checks if the `trackingParams` in the response matches the decoded `trackingParam` in `responseContext.mainAppWebResponseContext`.
  1030.                  * However, sometimes the response does not include the `trackingParam` in the `responseContext`, causing the check to fail.
  1031.                  *
  1032.                  * This workaround addresses the issue by hardcoding the `trackingParams` in the response context.
  1033.                  */
  1034.                 if (
  1035.                     !unlockedPlayerResponse.trackingParams
  1036.                     || !((_unlockedPlayerRespon7 = unlockedPlayerResponse.responseContext) !== null && _unlockedPlayerRespon7 !== void 0
  1037.                         && (_unlockedPlayerRespon7 = _unlockedPlayerRespon7.mainAppWebResponseContext) !== null && _unlockedPlayerRespon7 !== void 0
  1038.                         && _unlockedPlayerRespon7.trackingParam)
  1039.                 ) {
  1040.                     unlockedPlayerResponse.trackingParams = 'CAAQu2kiEwjor8uHyOL_AhWOvd4KHavXCKw=';
  1041.                     unlockedPlayerResponse.responseContext = {
  1042.                         mainAppWebResponseContext: {
  1043.                             trackingParam: 'kx_fmPxhoPZRzgL8kzOwANUdQh8ZwHTREkw2UqmBAwpBYrzRgkuMsNLBwOcCE59TDtslLKPQ-SS',
  1044.                         },
  1045.                     };
  1046.                 }
  1047.  
  1048.                 /**
  1049.                  * Workaround: Account proxy response currently does not include `playerConfig`
  1050.                  *
  1051.                  * Stays here until we rewrite the account proxy to only include the necessary and bare minimum response
  1052.                  */
  1053.                 if (strategy.payload.startTimeSecs && strategy.name === 'Account Proxy') {
  1054.                     unlockedPlayerResponse.playerConfig = {
  1055.                         playbackStartConfig: {
  1056.                             startSeconds: strategy.payload.startTimeSecs,
  1057.                         },
  1058.                     };
  1059.                 }
  1060.             }
  1061.  
  1062.             return !isStatusValid;
  1063.         });
  1064.  
  1065.         // Cache response to prevent a flood of requests in case youtube processes a blocked response mutiple times.
  1066.         cachedPlayerResponse = { videoId, ...createDeepCopy(unlockedPlayerResponse) };
  1067.  
  1068.         return unlockedPlayerResponse;
  1069.     }
  1070.  
  1071.     let cachedNextResponse = {};
  1072.  
  1073.     function unlockResponse(originalNextResponse) {
  1074.         const videoId = originalNextResponse.currentVideoEndpoint.watchEndpoint.videoId;
  1075.  
  1076.         if (!videoId) {
  1077.             throw new Error(`Missing videoId in nextResponse`);
  1078.         }
  1079.  
  1080.         // Only unlock the /next response when the player has been unlocked as well
  1081.         if (videoId !== lastPlayerUnlockVideoId) {
  1082.             return;
  1083.         }
  1084.  
  1085.         const unlockedNextResponse = getUnlockedNextResponse(videoId);
  1086.  
  1087.         // check if the sidebar of the unlocked response is still empty
  1088.         if (isWatchNextSidebarEmpty(unlockedNextResponse)) {
  1089.             throw new Error(`Sidebar Unlock Failed`);
  1090.         }
  1091.  
  1092.         // Transfer some parts of the unlocked response to the original response
  1093.         mergeNextResponse(originalNextResponse, unlockedNextResponse);
  1094.     }
  1095.  
  1096.     function getUnlockedNextResponse(videoId) {
  1097.         // Check if response is cached
  1098.         if (cachedNextResponse.videoId === videoId) return createDeepCopy(cachedNextResponse);
  1099.  
  1100.         const unlockStrategies = getUnlockStrategies$1(videoId, lastPlayerUnlockReason);
  1101.  
  1102.         let unlockedNextResponse = {};
  1103.  
  1104.         // Try every strategy until one of them works
  1105.         unlockStrategies.every((strategy, index) => {
  1106.             if (strategy.skip) return true;
  1107.  
  1108.             info(`Trying Next Unlock Method #${index + 1} (${strategy.name})`);
  1109.  
  1110.             try {
  1111.                 unlockedNextResponse = strategy.endpoint.getNext(strategy.payload, strategy.optionalAuth);
  1112.             } catch (err) {
  1113.                 error(err, `Next Unlock Method ${index + 1} failed with exception`);
  1114.             }
  1115.  
  1116.             return isWatchNextSidebarEmpty(unlockedNextResponse);
  1117.         });
  1118.  
  1119.         // Cache response to prevent a flood of requests in case youtube processes a blocked response mutiple times.
  1120.         cachedNextResponse = { videoId, ...createDeepCopy(unlockedNextResponse) };
  1121.  
  1122.         return unlockedNextResponse;
  1123.     }
  1124.  
  1125.     function mergeNextResponse(originalNextResponse, unlockedNextResponse) {
  1126.         var _unlockedNextResponse;
  1127.         if (isDesktop) {
  1128.             // Transfer WatchNextResults to original response
  1129.             originalNextResponse.contents.twoColumnWatchNextResults.secondaryResults = unlockedNextResponse.contents.twoColumnWatchNextResults.secondaryResults;
  1130.  
  1131.             // Transfer video description to original response
  1132.             const originalVideoSecondaryInfoRenderer = originalNextResponse.contents.twoColumnWatchNextResults.results.results.contents.find(
  1133.                 (x) => x.videoSecondaryInfoRenderer,
  1134.             ).videoSecondaryInfoRenderer;
  1135.             const unlockedVideoSecondaryInfoRenderer = unlockedNextResponse.contents.twoColumnWatchNextResults.results.results.contents.find(
  1136.                 (x) => x.videoSecondaryInfoRenderer,
  1137.             ).videoSecondaryInfoRenderer;
  1138.  
  1139.             // TODO: Throw if description not found?
  1140.             if (unlockedVideoSecondaryInfoRenderer.description) {
  1141.                 originalVideoSecondaryInfoRenderer.description = unlockedVideoSecondaryInfoRenderer.description;
  1142.             } else if (unlockedVideoSecondaryInfoRenderer.attributedDescription) {
  1143.                 originalVideoSecondaryInfoRenderer.attributedDescription = unlockedVideoSecondaryInfoRenderer.attributedDescription;
  1144.             }
  1145.  
  1146.             return;
  1147.         }
  1148.  
  1149.         // Transfer WatchNextResults to original response
  1150.         const unlockedWatchNextFeed = (_unlockedNextResponse = unlockedNextResponse.contents) === null || _unlockedNextResponse === void 0
  1151.                 || (_unlockedNextResponse = _unlockedNextResponse.singleColumnWatchNextResults) === null || _unlockedNextResponse === void 0
  1152.                 || (_unlockedNextResponse = _unlockedNextResponse.results) === null || _unlockedNextResponse === void 0
  1153.                 || (_unlockedNextResponse = _unlockedNextResponse.results) === null || _unlockedNextResponse === void 0
  1154.                 || (_unlockedNextResponse = _unlockedNextResponse.contents) === null || _unlockedNextResponse === void 0
  1155.             ? void 0
  1156.             : _unlockedNextResponse.find(
  1157.                 (x) => {
  1158.                     var _x$itemSectionRendere;
  1159.                     return ((_x$itemSectionRendere = x.itemSectionRenderer) === null || _x$itemSectionRendere === void 0 ? void 0 : _x$itemSectionRendere.targetId)
  1160.                         === 'watch-next-feed';
  1161.                 },
  1162.             );
  1163.  
  1164.         if (unlockedWatchNextFeed) originalNextResponse.contents.singleColumnWatchNextResults.results.results.contents.push(unlockedWatchNextFeed);
  1165.  
  1166.         // Transfer video description to original response
  1167.         const originalStructuredDescriptionContentRenderer = originalNextResponse.engagementPanels
  1168.             .find((x) => x.engagementPanelSectionListRenderer)
  1169.             .engagementPanelSectionListRenderer.content.structuredDescriptionContentRenderer.items.find((x) => x.expandableVideoDescriptionBodyRenderer);
  1170.         const unlockedStructuredDescriptionContentRenderer = unlockedNextResponse.engagementPanels
  1171.             .find((x) => x.engagementPanelSectionListRenderer)
  1172.             .engagementPanelSectionListRenderer.content.structuredDescriptionContentRenderer.items.find((x) => x.expandableVideoDescriptionBodyRenderer);
  1173.  
  1174.         if (unlockedStructuredDescriptionContentRenderer.expandableVideoDescriptionBodyRenderer) {
  1175.             originalStructuredDescriptionContentRenderer.expandableVideoDescriptionBodyRenderer =
  1176.                 unlockedStructuredDescriptionContentRenderer.expandableVideoDescriptionBodyRenderer;
  1177.         }
  1178.     }
  1179.  
  1180.     /**
  1181.      *  Handles XMLHttpRequests and
  1182.      * - Rewrite Googlevideo URLs to Proxy URLs (if necessary)
  1183.      * - Store auth headers for the authentication of further unlock requests.
  1184.      * - Add "content check ok" flags to request bodys
  1185.      */
  1186.     function handleXhrOpen(method, url, xhr) {
  1187.         let proxyUrl = unlockGoogleVideo(url);
  1188.         if (proxyUrl) {
  1189.             // Exclude credentials from XMLHttpRequest
  1190.             Object.defineProperty(xhr, 'withCredentials', {
  1191.                 set: () => {},
  1192.                 get: () => false,
  1193.             });
  1194.             return proxyUrl;
  1195.         }
  1196.  
  1197.         if (url.pathname.indexOf('/youtubei/') === 0) {
  1198.             // Store auth headers in storage for further usage.
  1199.             attach$4(xhr, 'setRequestHeader', ([headerName, headerValue]) => {
  1200.                 if (Config.GOOGLE_AUTH_HEADER_NAMES.includes(headerName)) {
  1201.                     set(headerName, headerValue);
  1202.                 }
  1203.             });
  1204.         }
  1205.  
  1206.         if (Config.SKIP_CONTENT_WARNINGS && method === 'POST' && ['/youtubei/v1/player', '/youtubei/v1/next'].includes(url.pathname)) {
  1207.             // Add content check flags to player and next request (this will skip content warnings)
  1208.             attach$4(xhr, 'send', (args) => {
  1209.                 if (typeof args[0] === 'string') {
  1210.                     args[0] = setContentCheckOk(args[0]);
  1211.                 }
  1212.             });
  1213.         }
  1214.     }
  1215.  
  1216.     /**
  1217.      *  Handles Fetch requests and
  1218.      * - Rewrite Googlevideo URLs to Proxy URLs (if necessary)
  1219.      * - Store auth headers for the authentication of further unlock requests.
  1220.      * - Add "content check ok" flags to request bodys
  1221.      */
  1222.     function handleFetchRequest(url, requestOptions) {
  1223.         let newGoogleVideoUrl = unlockGoogleVideo(url);
  1224.         if (newGoogleVideoUrl) {
  1225.             // Exclude credentials from Fetch Request
  1226.             if (requestOptions.credentials) {
  1227.                 requestOptions.credentials = 'omit';
  1228.             }
  1229.             return newGoogleVideoUrl;
  1230.         }
  1231.  
  1232.         if (url.pathname.indexOf('/youtubei/') === 0 && isObject(requestOptions.headers)) {
  1233.             // Store auth headers in authStorage for further usage.
  1234.             for (let headerName in requestOptions.headers) {
  1235.                 if (Config.GOOGLE_AUTH_HEADER_NAMES.includes(headerName)) {
  1236.                     set(headerName, requestOptions.headers[headerName]);
  1237.                 }
  1238.             }
  1239.         }
  1240.  
  1241.         if (Config.SKIP_CONTENT_WARNINGS && ['/youtubei/v1/player', '/youtubei/v1/next'].includes(url.pathname)) {
  1242.             // Add content check flags to player and next request (this will skip content warnings)
  1243.             requestOptions.body = setContentCheckOk(requestOptions.body);
  1244.         }
  1245.     }
  1246.  
  1247.     /**
  1248.      * If the account proxy was used to retrieve the video info, the following applies:
  1249.      * some video files (mostly music videos) can only be accessed from IPs in the same country as the innertube api request (/youtubei/v1/player) was made.
  1250.      * to get around this, the googlevideo URL will be replaced with a web-proxy URL in the same country (US).
  1251.      * this is only required if the "gcr=[countrycode]" flag is set in the googlevideo-url...
  1252.      * @returns The rewitten url (if a proxy is required)
  1253.      */
  1254.     function unlockGoogleVideo(url) {
  1255.         if (Config.VIDEO_PROXY_SERVER_HOST && isGoogleVideoUrl(url)) {
  1256.             if (isGoogleVideoUnlockRequired(url, getLastProxiedGoogleVideoId())) {
  1257.                 return proxy.getGoogleVideoUrl(url);
  1258.             }
  1259.         }
  1260.     }
  1261.  
  1262.     /**
  1263.      * Adds `contentCheckOk` and `racyCheckOk` to the given json data (if the data contains a video id)
  1264.      * @returns {string} The modified json
  1265.      */
  1266.     function setContentCheckOk(bodyJson) {
  1267.         try {
  1268.             let parsedBody = JSON.parse(bodyJson);
  1269.             if (parsedBody.videoId) {
  1270.                 parsedBody.contentCheckOk = true;
  1271.                 parsedBody.racyCheckOk = true;
  1272.                 return JSON.stringify(parsedBody);
  1273.             }
  1274.         } catch {}
  1275.         return bodyJson;
  1276.     }
  1277.  
  1278.     function processThumbnails(responseObject) {
  1279.         const thumbnails = findNestedObjectsByAttributeNames(responseObject, ['url', 'height']);
  1280.  
  1281.         let blurredThumbnailCount = 0;
  1282.  
  1283.         for (const thumbnail of thumbnails) {
  1284.             if (isThumbnailBlurred(thumbnail)) {
  1285.                 blurredThumbnailCount++;
  1286.                 thumbnail.url = thumbnail.url.split('?')[0];
  1287.             }
  1288.         }
  1289.  
  1290.         info(blurredThumbnailCount + '/' + thumbnails.length + ' thumbnails detected as blurred.');
  1291.     }
  1292.  
  1293.     function isThumbnailBlurred(thumbnail) {
  1294.         const hasSQPParam = thumbnail.url.indexOf('?sqp=') !== -1;
  1295.  
  1296.         if (!hasSQPParam) {
  1297.             return false;
  1298.         }
  1299.  
  1300.         const SQPLength = new URL(thumbnail.url).searchParams.get('sqp').length;
  1301.         const isBlurred = Config.BLURRED_THUMBNAIL_SQP_LENGTHS.includes(SQPLength);
  1302.  
  1303.         return isBlurred;
  1304.     }
  1305.  
  1306.     try {
  1307.         attach$3(processYtData);
  1308.         attach$2(processYtData);
  1309.         attach(handleXhrOpen);
  1310.         attach$1(handleFetchRequest);
  1311.     } catch (err) {
  1312.         error(err, 'Error while attaching data interceptors');
  1313.     }
  1314.  
  1315.     function processYtData(ytData) {
  1316.         try {
  1317.             // Player Unlock #1: Initial page data structure and response from `/youtubei/v1/player` XHR request
  1318.             if (isPlayerObject(ytData) && isAgeRestricted(ytData.playabilityStatus)) {
  1319.                 unlockResponse$1(ytData);
  1320.             } // Player Unlock #2: Embedded Player inital data structure
  1321.             else if (isEmbeddedPlayerObject(ytData) && isAgeRestricted(ytData.previewPlayabilityStatus)) {
  1322.                 unlockResponse$1(ytData);
  1323.             }
  1324.         } catch (err) {
  1325.             error(err, 'Video unlock failed');
  1326.         }
  1327.  
  1328.         try {
  1329.             // Unlock sidebar watch next feed (sidebar) and video description
  1330.             if (isWatchNextObject(ytData) && isWatchNextSidebarEmpty(ytData)) {
  1331.                 unlockResponse(ytData);
  1332.             }
  1333.  
  1334.             // Mobile version
  1335.             if (isWatchNextObject(ytData.response) && isWatchNextSidebarEmpty(ytData.response)) {
  1336.                 unlockResponse(ytData.response);
  1337.             }
  1338.         } catch (err) {
  1339.             error(err, 'Sidebar unlock failed');
  1340.         }
  1341.  
  1342.         try {
  1343.             // Unlock blurry video thumbnails in search results
  1344.             if (isSearchResult(ytData)) {
  1345.                 processThumbnails(ytData);
  1346.             }
  1347.         } catch (err) {
  1348.             error(err, 'Thumbnail unlock failed');
  1349.         }
  1350.  
  1351.         return ytData;
  1352.     }
  1353. })();
  1354.