☰

Simple YouTube Age Restriction Bypass - by Hexxonn

Watch age restricted videos on YouTube without login and without age verification 😎 | Mod by Hexxonn

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