☰

YouTube: Audio Only

No Video Streaming

当前为 2024-12-22 提交的版本，查看 最新版本。

  1. // ==UserScript==
  2. // @name                YouTube: Audio Only
  3. // @description         No Video Streaming
  4. // @namespace           UserScript
  5. // @version             1.9.4
  6. // @author              CY Fung
  7. // @match               https://www.youtube.com/*
  8. // @match               https://www.youtube.com/embed/*
  9. // @match               https://www.youtube-nocookie.com/embed/*
  10. // @match               https://m.youtube.com/*
  11. // @exclude             /^https?://\S+\.(txt|png|jpg|jpeg|gif|xml|svg|manifest|log|ini)[^\/]*$/
  12. // @icon                https://raw.githubusercontent.com/cyfung1031/userscript-supports/main/icons/YouTube-Audio-Only.png
  13. // @grant               GM_registerMenuCommand
  14. // @grant               GM.setValue
  15. // @grant               GM.getValue
  16. // @grant               GM.listValues
  17. // @grant               GM.deleteValue
  18. // @run-at              document-start
  19. // @license             MIT
  20. // @compatible          chrome
  21. // @compatible          firefox
  22. // @compatible          opera
  23. // @compatible          edge
  24. // @compatible          safari
  25. // @allFrames           true
  26. //
  27. // ==/UserScript==
  28.  
  29. (async function () {
  30.     'use strict';
  31.  
  32.       !window.TTP && (() => {
  33.         // credit to Benjamin Philipp
  34.         // original source: https://greasyfork.org/en/scripts/433051-trusted-types-helper
  35.       
  36.         // --------------------------------------------------- Trusted Types Helper ---------------------------------------------------
  37.       
  38.         const overwrite_default = false; // If a default policy already exists, it might be best not to overwrite it, but to try and set a custom policy and use it to manually generate trusted types. Try at your own risk
  39.         const prefix = `TTP`;
  40.         var passThroughFunc = function (string, sink) {
  41.           return string; // Anything passing through this function will be returned without change
  42.         }
  43.         var TTPName = "passthrough";
  44.         var TTP_default, TTP = { createHTML: passThroughFunc, createScript: passThroughFunc, createScriptURL: passThroughFunc }; // We can use TTP.createHTML for all our assignments even if we don't need or even have Trusted Types; this should make fallbacks and polyfills easy
  45.         var needsTrustedHTML = false;
  46.         function doit() {
  47.           try {
  48.             if (typeof window.isSecureContext !== 'undefined' && window.isSecureContext) {
  49.               if (window.trustedTypes && window.trustedTypes.createPolicy) {
  50.                 needsTrustedHTML = true;
  51.                 if (trustedTypes.defaultPolicy) {
  52.                   log("TT Default Policy exists");
  53.                   if (overwrite_default)
  54.                     TTP = window.trustedTypes.createPolicy("default", TTP);
  55.                   else
  56.                     TTP = window.trustedTypes.createPolicy(TTPName, TTP); // Is the default policy permissive enough? If it already exists, best not to overwrite it
  57.                   TTP_default = trustedTypes.defaultPolicy;
  58.       
  59.                   log("Created custom passthrough policy, in case the default policy is too restrictive: Use Policy '" + TTPName + "' in var 'TTP':", TTP);
  60.                 }
  61.                 else {
  62.                   TTP_default = TTP = window.trustedTypes.createPolicy("default", TTP);
  63.                 }
  64.                 log("Trusted-Type Policies: TTP:", TTP, "TTP_default:", TTP_default);
  65.               }
  66.             }
  67.           } catch (e) {
  68.             log(e);
  69.           }
  70.         }
  71.       
  72.         function log(...args) {
  73.           if ("undefined" != typeof (prefix) && !!prefix)
  74.             args = [prefix + ":", ...args];
  75.           if ("undefined" != typeof (debugging) && !!debugging)
  76.             args = [...args, new Error().stack.replace(/^\s*(Error|Stack trace):?\n/gi, "").replace(/^([^\n]*\n)/, "\n")];
  77.           console.log(...args);
  78.         }
  79.       
  80.         doit();
  81.       
  82.         // --------------------------------------------------- Trusted Types Helper ---------------------------------------------------
  83.       
  84.         window.TTP = TTP;
  85.       
  86.       })();
  87.       
  88.       function createHTML(s) {
  89.         if (typeof TTP !== 'undefined' && typeof TTP.createHTML === 'function') return TTP.createHTML(s);
  90.         return s;
  91.       }
  92.       
  93.       let trustHTMLErr = null;
  94.       try {
  95.         document.createElement('div').innerHTML = createHTML('1');
  96.       } catch (e) {
  97.         trustHTMLErr = e;
  98.       }
  99.       
  100.       if (trustHTMLErr) {
  101.         console.log(`trustHTMLErr`, trustHTMLErr);
  102.         trustHTMLErr(); // exit userscript
  103.       }
  104.  
  105.     /** @type {globalThis.PromiseConstructor} */
  106.     const Promise = (async () => { })().constructor; // YouTube hacks Promise in WaterFox Classic and "Promise.resolve(0)" nevers resolve.
  107.  
  108.     if (typeof AbortSignal === 'undefined') throw new DOMException("Please update your browser.", "NotSupportedError");
  109.  
  110.     async function confirm(message) {
  111.         // Create the HTML for the dialog
  112.  
  113.         if (!document.body) return;
  114.  
  115.         let dialog = document.getElementById('confirmDialog794');
  116.         if (!dialog) {
  117.  
  118.             const dialogHTML = `
  119.             <div id="confirmDialog794" class="dialog-style" style="display: block;">
  120.                 <div class="confirm-box">
  121.                     <p>${message}</p>
  122.                     <div class="confirm-buttons">
  123.                         <button id="confirmBtn">Confirm</button>
  124.                         <button id="cancelBtn">Cancel</button>
  125.                     </div>
  126.                 </div>
  127.             </div>
  128.         `;
  129.  
  130.             // Append the dialog to the document body
  131.             document.body.insertAdjacentHTML('beforeend', createHTML(dialogHTML));
  132.             dialog = document.getElementById('confirmDialog794');
  133.  
  134.         }
  135.  
  136.         // Return a promise that resolves or rejects based on the user's choice
  137.         return new Promise((resolve) => {
  138.             document.getElementById('confirmBtn').onclick = () => {
  139.                 resolve(true);
  140.                 cleanup();
  141.             };
  142.  
  143.             document.getElementById('cancelBtn').onclick = () => {
  144.                 resolve(false);
  145.                 cleanup();
  146.             };
  147.  
  148.             function cleanup() {
  149.                 dialog && dialog.remove();
  150.                 dialog = null;
  151.             }
  152.         });
  153.     }
  154.  
  155.  
  156.  
  157.     if (location.pathname === '/live_chat' || location.pathname === 'live_chat_replay') return;
  158.  
  159.     const kEventListener = (evt) => {
  160.         if (document.documentElement.hasAttribute('forceRefresh032')) {
  161.             evt.stopImmediatePropagation();
  162.             evt.stopPropagation();
  163.         }
  164.     }
  165.     window.addEventListener('beforeunload', kEventListener, false);
  166.  
  167.     const pageInjectionCode = function () {
  168.  
  169.         let debugFlg001 = false;
  170.         // let debugFlg002 = false;
  171.         let globalPlayer = null;
  172.         const SHOW_VIDEO_STATIC_IMAGE = true;
  173.         const PATCH_MEDIA_PUBLISH = true;
  174.  
  175.         if (typeof AbortSignal === 'undefined') throw new DOMException("Please update your browser.", "NotSupportedError");
  176.  
  177.         const URL = window.URL || new Function('return URL')();
  178.         const createObjectURL = URL.createObjectURL.bind(URL);
  179.  
  180.         /** @type {globalThis.PromiseConstructor} */
  181.         const Promise = (async () => { })().constructor; // YouTube hacks Promise in WaterFox Classic and "Promise.resolve(0)" nevers resolve.
  182.  
  183.         const PromiseExternal = ((resolve_, reject_) => {
  184.             const h = (resolve, reject) => { resolve_ = resolve; reject_ = reject };
  185.             return class PromiseExternal extends Promise {
  186.                 constructor(cb = h) {
  187.                     super(cb);
  188.                     if (cb === h) {
  189.                         /** @type {(value: any) => void} */
  190.                         this.resolve = resolve_;
  191.                         /** @type {(reason?: any) => void} */
  192.                         this.reject = reject_;
  193.                     }
  194.                 }
  195.             };
  196.         })();
  197.  
  198.         /* globals WeakRef:false */
  199.  
  200.         /** @type {(o: Object | null) => WeakRef | null} */
  201.         const mWeakRef = typeof WeakRef === 'function' ? (o => o ? new WeakRef(o) : null) : (o => o || null);
  202.  
  203.         /** @type {(wr: Object | null) => Object | null} */
  204.         const kRef = (wr => (wr && wr.deref) ? wr.deref() : wr);
  205.  
  206.         /*
  207.  
  208.             g.k.playVideo = function(a) {
  209.                 this.logger.debug(function() {
  210.                     return "play video, player type " + a
  211.                 });
  212.                 var b = g.rT(this, a);
  213.                 b && (this.appState === 2 ? (g.BR(this.X) && $U(this.Rb),
  214.                 N0(this)) : g.pF(b.getPlayerState(), 2) ? (b = 36,
  215.                 this.getVideoData().nk() && (b = 37),
  216.                 this.seekTo(0, void 0, void 0, void 0, b)) : b.playVideo())
  217.             }
  218.  
  219.             g.k.getPresentingPlayerType = function(a) {
  220.                 if (this.appState === 1)
  221.                     return 1;
  222.                 if (J0(this))
  223.                     return 3;
  224.                 var b;
  225.                 if (a && ((b = this.ye) == null ? 0 : b.vl(this.getCurrentTime())))
  226.                     return 2;
  227.                 var c;
  228.                 return g.zS(this.getVideoData()) && ((c = this.wb) == null ? 0 : c.vl()) ? 2 : g.rT(this).getPlayerType()
  229.             }
  230.  
  231.             g.k.rS = function() {
  232.                 var a = this.app.getPresentingPlayerType();
  233.                 if (a === 2 && !this.app.Jf()) {
  234.                     var b = zV(this.app.zb());
  235.                     if (!Dkb(b) || Ekb(b))
  236.                         return
  237.                 }
  238.                 a === 3 ? AT(this.app.zb()).iG("control_play") : this.app.U().L("html5_ssap_ignore_play_for_ad") && g.zS(this.app.Od()) && a === 2 || this.app.playVideo(a)
  239.             }
  240.         */
  241.  
  242.         // const onDurationAvailable = async function(player_, media){
  243.         //     if (media instanceof HTMLMediaElement && media.__canPlayPromise__ && media.duration > 0 && media.networkState >= 2 && media.readyState >= 1) {
  244.         //         skipPause = true;
  245.         //         skipVisibility = true;
  246.         //         debugFlg002 && console.log(1991, player_.getPresentingPlayerType())
  247.         //         await player_.cancelPlayback();
  248.         //         debugFlg002 && console.log(1992, player_.getPresentingPlayerType())
  249.         //         await player_.pauseVideo();
  250.         //         debugFlg002 && console.log(1993, player_.getPresentingPlayerType())
  251.         //         // window.m33e = 1;
  252.         //         window.m34e = player_;
  253.         //         // await player_.clearQueue();
  254.         //         await player_.playVideo();
  255.         //         skipVisibility = false;
  256.         //         skipPause = false;
  257.  
  258.         //         debugFlg002 && console.log('HTMLMediaElement A2', [media.readyState, media.paused, media.networkState]);
  259.         //         if (media instanceof HTMLMediaElement && media.__canPlayPromise__ && media.duration > 0 && media.networkState >= 2 && media.readyState >= 4) {
  260.         //             media.__canPlayPromise__.resolve();
  261.         //             media.__canPlayPromise__ = null;
  262.         //         }
  263.         //     }
  264.         // }
  265.  
  266.         // let skipPause = false;
  267.         // let skipVisibility = false;
  268.         // const durationchangeListener = async function (evt) {
  269.         //     const media = evt ? evt.target : null;
  270.         //     if (media instanceof HTMLMediaElement && media.__canPlayPromise__ && media.duration > 0 && media.networkState >= 2 && media.readyState >= 1) {
  271.         //         if (media.readyState < 4) {
  272.         //             debugFlg002 && console.log('HTMLMediaElement A1', [media.readyState, media.paused, media.networkState])
  273.         //             const player_ = kRef(globalPlayer);
  274.         //             if (player_) {
  275.         //                 onDurationAvailable(player_, media);
  276.         //             } else {
  277.         //                 console.error("HTMLMediaElement", "player_ is not found when HTMLMediaElement duration change");
  278.         //             }
  279.         //         } else {
  280.         //             debugFlg002 && console.log('HTMLMediaElement B', [media.readyState, media.paused, media.networkState])
  281.         //             media.__canPlayPromise__.resolve();
  282.         //             media.__canPlayPromise__ = null;
  283.         //         }
  284.         //     }
  285.         // }
  286.  
  287.         // const canplayListener = function (evt) {
  288.         //     const media = evt ? evt.target : null;
  289.         //     if (media && media.__canPlayPromise__) {
  290.         //         debugFlg002 && console.log('HTMLMediaElement canplay', [media.readyState, media.paused, media.networkState]);
  291.         //         media.__canPlayPromise__.resolve();
  292.         //         media.__canPlayPromise__ = null;
  293.         //     }
  294.         //     debugFlg002 && console.log('HTMLMediaElement canplay')
  295.         // }
  296.  
  297.         // let x6CGdPr = null;
  298.         // window.addEventListener('message', (evt)=>{
  299.         //   if((evt||0).data === 'x6CGd' && x6CGdPr!==null) x6CGdPr.resolve();
  300.         // });
  301.         // const timelineResolve = async () => {
  302.         //   if (x6CGdPr !== null) {
  303.         //     await x6CGdPr.then();
  304.         //     return;
  305.         //   }
  306.         //   x6CGdPr = new PromiseExternal();
  307.         //   window.postMessage('x6CGd');
  308.         //   await x6CGdPr.then();
  309.         //   x6CGdPr = null;
  310.         // }
  311.  
  312.         // let playWId = 0;
  313.  
  314.         // const mediaPlay = HTMLMediaElement.prototype.play
  315.         // HTMLMediaElement.prototype.play = function () {
  316.         //     debugFlg002 && console.log('HTMLMediaElement play')
  317.         //     if (playWId > 1e9) playWId = 9;
  318.         //     const tid = ++playWId;
  319.         //     if (!this.paused) {
  320.         //         return mediaPlay.apply(this, arguments);
  321.         //     }
  322.         //     if (this.readyState >= 4) return mediaPlay.apply(this, arguments);
  323.         //     try {
  324.         //         if (!this.__canPlayPromise__ && this.closest('#player')) {
  325.         //             this.__canPlayPromise__ = new PromiseExternal();
  326.         //             const player_ = kRef(globalPlayer);
  327.         //             debugFlg002 && console.log('HTMLMediaElement play x', this.duration, player_)
  328.         //             if (!(this.duration > 0)) {
  329.         //                 this.removeEventListener('durationchange', durationchangeListener);
  330.         //                 this.addEventListener('durationchange', durationchangeListener);
  331.         //                 this.removeEventListener('canplay', canplayListener);
  332.         //                 this.addEventListener('canplay', canplayListener);
  333.         //             } else if (player_) {
  334.         //                 this.removeEventListener('canplay', canplayListener);
  335.         //                 this.addEventListener('canplay', canplayListener);
  336.         //                 onDurationAvailable(player_, this);
  337.         //             } else {
  338.         //                 console.error("HTMLMediaElement", "player_ is not found when HTMLMediaElement plays");
  339.         //             }
  340.  
  341.         //             //---------------
  342.  
  343.  
  344.         //             // this.addEventListener('canplaythrough', function(){
  345.         //             //     console.log('HTMLMediaElement canplaythrough')
  346.         //             // });
  347.         //             // this.addEventListener('loadeddata', function(){
  348.         //             //     console.log('HTMLMediaElement loadeddata')
  349.         //             // });
  350.         //             // this.addEventListener('loadedmetadata', function(){
  351.         //             //     console.log('HTMLMediaElement loadedmetadata')
  352.         //             // });
  353.  
  354.         //             //---------------
  355.  
  356.         //             // this.addEventListener('abort', function(){
  357.         //             //     console.log('HTMLMediaElement abort')
  358.         //             // });
  359.         //             // this.addEventListener('emptied', function(){
  360.         //             //     console.log('HTMLMediaElement emptied')
  361.         //             // });
  362.         //             // this.addEventListener('error', function(){
  363.         //             //     console.log('HTMLMediaElement error')
  364.         //             // });
  365.         //             // this.addEventListener('ended', function(){
  366.         //             //     console.log('HTMLMediaElement ended')
  367.         //             // });
  368.         //             // this.addEventListener('loadstart', function(){
  369.         //             //     console.log('HTMLMediaElement loadstart')
  370.         //             // });
  371.         //         }
  372.  
  373.         //     } catch (e) {
  374.         //         console.log('HTMLMediaElement.prototype.play error');
  375.         //         console.error(e);
  376.         //         this.__canPlayPromise__ = Promise.resolve();
  377.         //     }
  378.         //     const promise = this.__canPlayPromise__;
  379.         //     return (async () => {
  380.         //         await promise.then();
  381.         //         if (tid !== playWId) return;
  382.         //         return await mediaPlay.apply(this, arguments);
  383.         //     })();
  384.         // }
  385.         // const mediaPause = HTMLMediaElement.prototype.pause
  386.         // HTMLMediaElement.prototype.pause = function () {
  387.         //     if (skipPause) return;
  388.         //     debugFlg002 && console.log('HTMLMediaElement pause')
  389.         //     if (playWId > 1e9) playWId = 9;
  390.         //     const tid = ++playWId;
  391.         //     const promise = this.__canPlayPromise__;
  392.         //     if (promise) {
  393.         //         promise.resolve();
  394.         //         this.__canPlayPromise__ = null;
  395.         //     }
  396.         //     return mediaPause.apply(this, arguments);
  397.         // }
  398.  
  399.  
  400.  
  401.         const createPipeline = () => {
  402.             let pipelineMutex = Promise.resolve();
  403.             const pipelineExecution = fn => {
  404.                 return new Promise((resolve, reject) => {
  405.                     pipelineMutex = pipelineMutex.then(async () => {
  406.                         let res;
  407.                         try {
  408.                             res = await fn();
  409.                         } catch (e) {
  410.                             console.log('error_F1', e);
  411.                             reject(e);
  412.                         }
  413.                         resolve(res);
  414.                     }).catch(console.warn);
  415.                 });
  416.             };
  417.             return pipelineExecution;
  418.         }
  419.  
  420.         const observablePromise = (proc, timeoutPromise) => {
  421.             let promise = null;
  422.             return {
  423.                 obtain() {
  424.                     if (!promise) {
  425.                         promise = new Promise(resolve => {
  426.                             let mo = null;
  427.                             const f = () => {
  428.                                 let t = proc();
  429.                                 if (t) {
  430.                                     mo.disconnect();
  431.                                     mo.takeRecords();
  432.                                     mo = null;
  433.                                     resolve(t);
  434.                                 }
  435.                             }
  436.                             mo = new MutationObserver(f);
  437.                             mo.observe(document, { subtree: true, childList: true })
  438.                             f();
  439.                             timeoutPromise && timeoutPromise.then(() => {
  440.                                 resolve(null)
  441.                             });
  442.                         });
  443.                     }
  444.                     return promise
  445.                 }
  446.             }
  447.         }
  448.  
  449.  
  450.         const insp = o => o ? (o.polymerController || o.inst || o || 0) : (o || 0);
  451.  
  452.         const prototypeInherit = (d, b) => {
  453.             const m = Object.getOwnPropertyDescriptors(b);
  454.             for (const p in m) {
  455.                 if (!Object.getOwnPropertyDescriptor(d, p)) {
  456.                     Object.defineProperty(d, p, m[p]);
  457.                 }
  458.             }
  459.         };
  460.  
  461.         let setTimeout_ = setTimeout;
  462.         let clearTimeout_ = clearTimeout;
  463.  
  464.         const delayPn = delay => new Promise((fn => setTimeout_(fn, delay)));
  465.  
  466.         const isWatchPageURL = (url) => {
  467.             url = url || location;
  468.             return location.pathname === '/watch' || location.pathname.startsWith('/live/')
  469.         };
  470.  
  471.         const mockEvent = (o, elem) => {
  472.             o = o || {};
  473.             elem = elem || null;
  474.             return {
  475.                 preventDefault: () => { },
  476.                 stopPropagation: () => { },
  477.                 stopImmediatePropagation: () => { },
  478.                 returnValue: true,
  479.                 target: elem,
  480.                 srcElement: elem,
  481.                 defaultPrevented: false,
  482.                 cancelable: true,
  483.                 timeStamp: performance.now(),
  484.                 ...o
  485.             }
  486.         };
  487.  
  488.  
  489.         const generalRegister = (prop, symbol, checker, pg) => {
  490.             const objSet = new Set();
  491.             let done = false;
  492.             const f = (o) => {
  493.                 const ct = o.constructor;
  494.                 const proto = ct.prototype;
  495.                 if (!done && proto && ct !== Function && ct !== Object && checker(proto)) {
  496.                     done = true;
  497.                     delete Object.prototype[prop];
  498.                     objSet.delete(proto);
  499.                     objSet.delete(o);
  500.                     for (const obj of objSet) {
  501.                         obj[prop] = obj[symbol];
  502.                         delete obj[symbol];
  503.                     }
  504.                     objSet.clear();
  505.                     Object.defineProperty(proto, prop, pg);
  506.                     return proto;
  507.                 }
  508.                 return false;
  509.             };
  510.             Object.defineProperty(Object.prototype, prop, {
  511.                 get() {
  512.                     const p = f(this);
  513.                     if (p) {
  514.                         return p[prop];
  515.                     } else {
  516.                         return this[symbol];
  517.                     }
  518.                 },
  519.                 set(nv) {
  520.                     const p = f(this);
  521.                     if (p) {
  522.                         p[prop] = nv;
  523.                     } else {
  524.                         objSet.add(this);
  525.                         this[symbol] = nv;
  526.                     }
  527.                     return true;
  528.                 },
  529.                 enumerable: false,
  530.                 configurable: true
  531.             });
  532.  
  533.         };
  534.  
  535.         const mediaNetworkStateReady = async (audio) => {
  536.  
  537.             if (!(audio instanceof HTMLMediaElement)) {
  538.                 return '';
  539.             }
  540.             let done = false;
  541.             const et = await Promise.race([
  542.  
  543.                 new Promise(resolve => {
  544.                     audio.addEventListener('timeupdate', (evt) => {
  545.                         !done && resolve && resolve(evt.type);
  546.                         resolve = null
  547.                     }, { once: true, capture: true, passive: true })
  548.                 }),
  549.  
  550.                 new Promise(resolve => {
  551.                     audio.addEventListener('waiting', (evt) => {
  552.                         !done && resolve && resolve(evt.type);
  553.                         resolve = null
  554.                     }, { once: true, capture: true, passive: true })
  555.                 }),
  556.  
  557.                 new Promise(resolve => {
  558.                     audio.addEventListener('loadstart', (evt) => {
  559.                         !done && resolve && resolve(evt.type);
  560.                         resolve = null
  561.                     }, { once: true, capture: true, passive: true })
  562.                 }),
  563.  
  564.                 new Promise(resolve => {
  565.                     audio.addEventListener('durationchange', (evt) => {
  566.                         !done && resolve && resolve(evt.type);
  567.                         resolve = null
  568.                     }, { once: true, capture: true, passive: true })
  569.                 })
  570.  
  571.             ]);
  572.             done = true;
  573.             return et;
  574.  
  575.         };
  576.  
  577.         const updateLastActiveTimeAsync = (player_) => {
  578.             // TBC
  579.             Promise.resolve().then(() => {
  580.                 if (typeof player_.updateLastActiveTime === 'function') {
  581.                     player_.updateLastActiveTime();
  582.                 }
  583.             });
  584.         };
  585.  
  586.         const attachOneTimeEvent = function (eventType, callback) {
  587.             let kz = false;
  588.             document.addEventListener(eventType, function (evt) {
  589.                 if (kz) return;
  590.                 kz = true;
  591.                 callback(evt);
  592.             }, { capture: true, passive: true, once: true });
  593.         }
  594.  
  595.         function removeTempObjectProp01() {
  596.             delete Object.prototype['kevlar_non_watch_unified_player'];
  597.             delete Object.prototype['kevlar_unified_player'];
  598.         }
  599.  
  600.         function ytConfigFix(config__) {
  601.             const config_ = config__;
  602.  
  603.             if (config_) {
  604.  
  605.                 const playerKevlar = ((config_ || 0).WEB_PLAYER_CONTEXT_CONFIGS || 0).WEB_PLAYER_CONTEXT_CONFIG_ID_KEVLAR_WATCH || 0;
  606.  
  607.                 if (playerKevlar) {
  608.  
  609.                     // console.log(322, playerKevlar)
  610.                     playerKevlar.allowWoffleManagement = false;
  611.                     playerKevlar.cinematicSettingsAvailable = false;
  612.                     playerKevlar.showMiniplayerButton = false;
  613.                     playerKevlar.showMiniplayerUiWhenMinimized = false;
  614.                     playerKevlar.transparentBackground = false;
  615.  
  616.                     playerKevlar.enableCsiLogging = false;
  617.                     playerKevlar.externalFullscreen = false;
  618.  
  619.                     if (typeof playerKevlar.serializedExperimentFlags === 'string') {
  620.                         playerKevlar.serializedExperimentFlags = '';
  621.                         // playerKevlar.serializedExperimentFlags = playerKevlar.serializedExperimentFlags.replace(/[-\w]+=(\[\]|[.-\d]+|[_a-z]+|)(&|$)/g,'').replace(/&$/,'')
  622.                     }
  623.  
  624.                     if (typeof playerKevlar.serializedExperimentIds === 'string') {
  625.                         playerKevlar.serializedExperimentIds = '';
  626.                         // playerKevlar.serializedExperimentIds = playerKevlar.serializedExperimentIds.replace(/\d+\s*(,\s*|$)/g,'')
  627.                     }
  628.  
  629.                 }
  630.  
  631.                 removeTempObjectProp01();
  632.  
  633.                 let configs = config_.WEB_PLAYER_CONTEXT_CONFIGS || {};
  634.                 for (const [key, entry] of Object.entries(configs)) {
  635.  
  636.                     if (entry && typeof entry.serializedExperimentFlags === 'string' && entry.serializedExperimentFlags.length > 16) {
  637.                         // prevent idle playback failure
  638.                         entry.serializedExperimentFlags = entry.serializedExperimentFlags.replace(/\b(html5_check_for_idle_network_interval_ms|html5_trigger_loader_when_idle_network|html5_sabr_fetch_on_idle_network_preloaded_players|html5_autonav_cap_idle_secs|html5_autonav_quality_cap|html5_disable_client_autonav_cap_for_onesie|html5_idle_rate_limit_ms|html5_sabr_fetch_on_idle_network_preloaded_players|html5_webpo_idle_priority_job|html5_server_playback_start_policy|html5_check_video_data_errors_before_playback_start|html5_check_unstarted|html5_check_queue_on_data_loaded)=([-_\w]+)(\&|$)/g, (_, a, b, c) => {
  639.                             return a + '00' + '=' + b + c;
  640.                         });
  641.  
  642.                     }
  643.  
  644.                 }
  645.  
  646.                 const EXPERIMENT_FLAGS = config_.EXPERIMENT_FLAGS;
  647.  
  648.                 if (EXPERIMENT_FLAGS) {
  649.                     EXPERIMENT_FLAGS.kevlar_unified_player = true;
  650.                     EXPERIMENT_FLAGS.kevlar_non_watch_unified_player = true;
  651.                 }
  652.  
  653.  
  654.                 const EXPERIMENTS_FORCED_FLAGS = config_.EXPERIMENTS_FORCED_FLAGS;
  655.  
  656.                 if (EXPERIMENTS_FORCED_FLAGS) {
  657.                     EXPERIMENTS_FORCED_FLAGS.kevlar_unified_player = true;
  658.                     EXPERIMENTS_FORCED_FLAGS.kevlar_non_watch_unified_player = true;
  659.                 }
  660.  
  661.             }
  662.         }
  663.  
  664.         Object.defineProperty(Object.prototype, 'kevlar_non_watch_unified_player', {
  665.             get() {
  666.                 // console.log(501, this.constructor.prototype)
  667.                 return true;
  668.             },
  669.             set(nv) {
  670.                 return true;
  671.             },
  672.             enumerable: false,
  673.             configurable: true
  674.         });
  675.  
  676.  
  677.         Object.defineProperty(Object.prototype, 'kevlar_unified_player', {
  678.             get() {
  679.                 // console.log(501, this.constructor.prototype)
  680.                 return true;
  681.             },
  682.             set(nv) {
  683.                 return true;
  684.             },
  685.             enumerable: false,
  686.             configurable: true
  687.         });
  688.  
  689.         let prr = new PromiseExternal();
  690.         const prrPipeline = createPipeline();
  691.         let stopAndReload = false;
  692.  
  693.         let fa = 0;
  694.  
  695.         let cv = null;
  696.         let durationchangeForMobile = false;
  697.         function fixThumbnailURL(src) {
  698.             if (typeof src === 'string' && src.length >= 4) {
  699.                 let m = /\b[a-z0-9]{4,13}\.jpg\b/.exec(src);
  700.                 if (m && m[0]) {
  701.                     const t = m[0];
  702.                     let idx = src.indexOf(t);
  703.                     let nSrc = idx >= 0 ? src.substring(0, idx + t.length) : '';
  704.                     return nSrc;
  705.                 }
  706.             }
  707.             return src;
  708.         }
  709.  
  710.         const isDesktopSite = location.origin === 'https://www.youtube.com' && !location.pathname.startsWith('/embed/');
  711.  
  712.         const getThumbnailUrlFromThumbnails = (thumbnails) => {
  713.  
  714.             let thumbnailUrl = '';
  715.             if (thumbnails && thumbnails.length >= 1) {
  716.                 const arr = thumbnails.map(e => {
  717.                     return e.url ? [e.width * e.height, e.url] : typeof e === 'string' ? [0, e] : [0, '']
  718.                 });
  719.                 arr.sort((a, b) => b[0] - a[0]);
  720.                 thumbnailUrl = arr[0][1]
  721.                 if (typeof thumbnailUrl === 'string') {
  722.                     thumbnailUrl = fixThumbnailURL(thumbnailUrl);
  723.                 }
  724.             }
  725.             return thumbnailUrl;
  726.         }
  727.  
  728.         const pmof = () => {
  729.  
  730.             if (SHOW_VIDEO_STATIC_IMAGE) {
  731.  
  732.                 const medias = [...document.querySelectorAll('ytd-watch-flexy #player .html5-video-container .video-stream.html5-main-video')].filter(e => !e.closest('[hidden]'));
  733.                 if (medias.length !== 1) return;
  734.                 const mediaElement = medias[0];
  735.  
  736.                 const container = mediaElement ? mediaElement.closest('.html5-video-container') : null;
  737.                 if (!container) return;
  738.  
  739.                 let thumbnailUrl = '';
  740.                 const ytdPage = container.closest('ytd-watch-flexy');
  741.                 if (ytdPage && ytdPage.is === 'ytd-watch-flexy') {
  742.                     const cnt = insp(ytdPage);
  743.                     let thumbnails = null;
  744.                     try {
  745.                         thumbnails = cnt.polymerController.__data.playerData.videoDetails.thumbnail.thumbnails
  746.                         // thumbnails = cnt.__data.watchNextData.playerOverlays.playerOverlayRenderer.autoplay.playerOverlayAutoplayRenderer.background.thumbnails
  747.                     } catch (e) { }
  748.  
  749.                     thumbnailUrl = getThumbnailUrlFromThumbnails(thumbnails);
  750.                 }
  751.  
  752.  
  753.                 if (thumbnailUrl && typeof thumbnailUrl === 'string') {
  754.                     container.style.setProperty('--audio-only-thumbnail-image', `url(${thumbnailUrl})`);
  755.                 } else {
  756.                     container.style.removeProperty('--audio-only-thumbnail-image')
  757.                 }
  758.  
  759.             }
  760.  
  761.  
  762.         }
  763.         const pmo = new MutationObserver(pmof);
  764.  
  765.         isDesktopSite && document.addEventListener('yt-navigate-finish', () => {
  766.             const ytdWatchFlexy = document.querySelector('ytd-watch-flexy');
  767.             if (ytdWatchFlexy) {
  768.                 pmo.observe(ytdWatchFlexy, { attributes: true });
  769.                 ytdWatchFlexy.setAttribute('ytzNavigateFinish', Date.now());
  770.             }
  771.         });
  772.         document.addEventListener('durationchange', (evt) => {
  773.             const target = (evt || 0).target;
  774.             if (!(target instanceof HTMLMediaElement)) return;
  775.             const targetClassList = target.classList || 0;
  776.             const isPlayerVideo = typeof targetClassList.contains === 'function' ? targetClassList.contains('video-stream') && targetClassList.contains('html5-main-video') : false;
  777.  
  778.             if (durationchangeForMobile || isPlayerVideo) {
  779.                 if (target.readyState !== 1) {
  780.                     fa = 1;
  781.                 } else {
  782.                     fa = 2;
  783.                 }
  784.             }
  785.  
  786.             if (isPlayerVideo) {
  787.  
  788.                 if (target.readyState === 1 && target.networkState === 2) {
  789.                     target.__spfgs__ = true;
  790.                     if (cv) {
  791.                         cv.resolve();
  792.                         cv = null;
  793.                     }
  794.                 } else {
  795.                     target.__spfgs__ = false;
  796.                 }
  797.  
  798.                 if (isDesktopSite) {
  799.                     const ytdWatchFlexy = document.querySelector('ytd-watch-flexy');
  800.                     if (ytdWatchFlexy) {
  801.                         ytdWatchFlexy.setAttribute('ytzMediaDurationChanged', Date.now());
  802.                     }
  803.                 }
  804.  
  805.                 if (onVideoChangeForMobile) {
  806.                     onVideoChangeForMobile();
  807.                 }
  808.  
  809.             }
  810.         }, true);
  811.  
  812.  
  813.  
  814.         // XMLHttpRequest.prototype.open299 = XMLHttpRequest.prototype.open;
  815.         /*
  816.  
  817.         XMLHttpRequest.prototype.open2 = function(method, url, ...args){
  818.  
  819.               if (typeof url === 'string' && url.length > 24 && url.includes('/videoplayback?') && url.replace('?', '&').includes('&source=')) {
  820.                 if (vcc !== vdd) {
  821.                   vdd = vcc;
  822.                   window.postMessage({ ZECxh: url.includes('source=yt_live_broadcast') }, "*");
  823.                 }
  824.               }
  825.  
  826.           return this.open299(method, url, ...args)
  827.         }*/
  828.  
  829.  
  830.  
  831.         // desktop only
  832.         // document.addEventListener('yt-page-data-fetched', async (evt) => {
  833.  
  834.         //   const pageFetchedDataLocal = evt.detail;
  835.         //   let isLiveNow;
  836.         //   try {
  837.         //     isLiveNow = pageFetchedDataLocal.pageData.playerResponse.microformat.playerMicroformatRenderer.liveBroadcastDetails.isLiveNow;
  838.         //   } catch (e) { }
  839.         //   window.postMessage({ ZECxh: isLiveNow === true }, "*");
  840.  
  841.         // }, false);
  842.  
  843.         // return;
  844.  
  845.         // let clickLockFn = null;
  846.  
  847.  
  848.         let onVideoChangeForMobile = null;
  849.  
  850.         let removeBottomOverlayForMobile = null;
  851.  
  852.         let clickLockFn = null;
  853.         let clickTarget = null;
  854.         if (location.origin === 'https://m.youtube.com') {
  855.  
  856.             EventTarget.prototype.addEventListener322 = EventTarget.prototype.addEventListener;
  857.  
  858.             const dummyFn = () => { };
  859.             EventTarget.prototype.addEventListener = function (evt, fn, opts) {
  860.  
  861.                 let hn = fn;
  862.  
  863.                 // if (evt === 'player-error') {
  864.                 // } else if (evt === 'player-detailed-error') {
  865.                 // } else if (evt === 'video-data-change') {
  866.                 // } else if (evt === 'player-state-change') {
  867.                 // } else
  868.                 if (evt === 'player-autonav-pause' || evt === 'visibilitychange') {
  869.                     evt += 'y'
  870.                     fn = dummyFn;
  871.                 } else if (evt === 'click' && this.id === 'movie_player') {
  872.                     clickLockFn = fn;
  873.                     clickTarget = this;
  874.                 }
  875.                 return this.addEventListener322(evt, hn, opts)
  876.  
  877.             }
  878.  
  879.         }
  880.  
  881.  
  882.  
  883.         (() => {
  884.  
  885.             XMLHttpRequest = (() => {
  886.                 const XMLHttpRequest_ = XMLHttpRequest;
  887.                 if ('__xmMc8__' in XMLHttpRequest_.prototype) return XMLHttpRequest_;
  888.                 const url0 = createObjectURL(new Blob([], { type: 'text/plain' }));
  889.                 const c = class XMLHttpRequest extends XMLHttpRequest_ {
  890.                     constructor(...args) {
  891.                         super(...args);
  892.                     }
  893.                     open(method, url, ...args) {
  894.                         let skip = false;
  895.                         if (!url || typeof url !== 'string') skip = true;
  896.                         else if (typeof url === 'string') {
  897.                             let turl = url[0] === '/' ? `.youtube.com${url}` : `${url}`;
  898.                             if (turl.includes('googleads') || turl.includes('doubleclick.net')) {
  899.                                 skip = true;
  900.                             } else if (turl.includes('.youtube.com/pagead/')) {
  901.                                 skip = true;
  902.                             } else if (turl.includes('.youtube.com/ptracking')) {
  903.                                 skip = true;
  904.                             } else if (turl.includes('.youtube.com/api/stats/')) { // /api/stats/
  905.                                 // skip = true; // for user activity logging e.g. watched videos
  906.                             } else if (turl.includes('play.google.com/log')) {
  907.                                 skip = true;
  908.                             } else if (turl.includes('.youtube.com//?')) { // //?cpn=
  909.                                 skip = true;
  910.                             }
  911.                         }
  912.                         if (!skip) {
  913.                             this.__xmMc8__ = 1;
  914.                             return super.open(method, url, ...args);
  915.                         } else {
  916.                             this.__xmMc8__ = 2;
  917.                             return super.open('GET', url0);
  918.                         }
  919.                     }
  920.                     send(...args) {
  921.                         if (this.__xmMc8__ === 1) {
  922.                             return super.send(...args);
  923.                         } else if (this.__xmMc8__ === 2) {
  924.                             return super.send();
  925.                         } else {
  926.                             console.log('xhr warning');
  927.                             return super.send(...args);
  928.                         }
  929.                     }
  930.                 }
  931.                 c.prototype.__xmMc8__ = 0;
  932.                 prototypeInherit(c.prototype, XMLHttpRequest_.prototype);
  933.                 return c;
  934.             })();
  935.  
  936.             const s7 = Symbol();
  937.             const f7 = () => true;
  938.  
  939.             !window.canRetry9048 && generalRegister('canRetry', s7, (p) => {
  940.                 return typeof p.onStateChange === 'function' && typeof p.dispose === 'function' && typeof p.hide === 'undefined' && typeof p.show === 'undefined' && typeof p.isComplete === 'undefined' && typeof p.getDuration === 'undefined'
  941.             }, {
  942.                 get() {
  943.                     if ('logger' in this && 'policy' in this && 'xhr' && this) {
  944.                         if (this.errorMessage && typeof this.errorMessage === 'string' && this.errorMessage.includes('XMLHttpRequest') && this.errorMessage.includes('Invalid URL')) { // "SyntaxError_Failed to execute 'open' on 'XMLHttpRequest': Invalid URL"
  945.                             // OKAY !
  946.                             console.log('canRetry05 - ', this.errorMessage)
  947.                             return f7;
  948.                         }
  949.                         // console.log(this)
  950.                         console.log('canRetry02 - ', this.errorMessage, this)
  951.                     } else {
  952.                         console.log('canRetry ERR - ', this.errorMessage)
  953.                     }
  954.                     return this[s7];
  955.                 },
  956.                 set(nv) {
  957.                     this[s7] = nv;
  958.                     return true;
  959.                 },
  960.                 enumerable: false,
  961.                 configurable: true
  962.             });
  963.             window.canRetry9048 = 1;
  964.  
  965.         })();
  966.  
  967.         if (location.origin === 'https://www.youtube.com') {
  968.  
  969.             if (location.pathname.startsWith('/embed/')) {
  970.  
  971.                 const ytEmbedReady = observablePromise(() => document.querySelector('#player > .ytp-embed')).obtain();
  972.  
  973.                 const embedConfigFix = (async () => {
  974.                     while (true) {
  975.                         const config_ = typeof yt !== 'undefined' ? (yt || 0).config_ : 0;
  976.                         if (config_) {
  977.                             ytConfigFix(config_);
  978.                             break;
  979.                         }
  980.                         await delayPn(60);
  981.                     }
  982.                 });
  983.  
  984.                 ytEmbedReady.then(async (embedPlayer) => {
  985.  
  986.                     embedConfigFix();
  987.  
  988.                     const player_ = embedPlayer;
  989.                     // console.log(player_)
  990.  
  991.                     const asyncStateChange = async (audio, k) => {
  992.                         const refreshAllStaleEntitiesForNonReadyAudio = async () => {
  993.                             try {
  994.                                 if (audio.readyState == 0) await player_.refreshAllStaleEntities();
  995.                             } catch (e) {
  996.                             }
  997.                         };
  998.                         const triggerPlaying = async () => {
  999.                             await player_.pauseVideo();
  1000.                             await player_.playVideo();
  1001.                         };
  1002.                         const seekToLiveHeadForLiveStream = async () => {
  1003.                             try {
  1004.                                 await player_.seekToLiveHead();
  1005.                                 if ((await player_.isAtLiveHead()) === true) {
  1006.                                     await player_.seekToStreamTime();
  1007.                                     return true;
  1008.                                 }
  1009.                             } catch (e) {
  1010.                                 console.log('error_F3', e);
  1011.                             }
  1012.                         };
  1013.                         const fixLiveAudioFn = async () => {
  1014.                             if (audio.paused === true) {
  1015.  
  1016.                                 await player_.clearVideo(); // avoid error in live streaming
  1017.                                 await player_.clearQueue(); // avoid error in live streaming
  1018.                                 await delayPn(300);
  1019.                                 for (let i = 0; i < 3; i++) {
  1020.                                     if (audio.readyState === 0) {
  1021.                                         if (await seekToLiveHeadForLiveStream()) await delayPn(60);
  1022.                                     }
  1023.                                 }
  1024.                                 if (k === -1) {
  1025.                                     await refreshAllStaleEntitiesForNonReadyAudio();
  1026.                                 } else if (k === 3) {
  1027.                                     while (audio.readyState === 0) {
  1028.                                         await refreshAllStaleEntitiesForNonReadyAudio();
  1029.                                         await triggerPlaying();
  1030.                                         await delayPn(300);
  1031.                                     }
  1032.                                 }
  1033.                             } else if (audio.paused === false) {
  1034.  
  1035.                                 if (!player_.isAtLiveHead()) {
  1036.                                     if (await seekToLiveHeadForLiveStream()) await delayPn(60);
  1037.                                 }
  1038.                                 while (audio.readyState === 0) {
  1039.                                     await refreshAllStaleEntitiesForNonReadyAudio();
  1040.                                     await triggerPlaying();
  1041.                                     await delayPn(300);
  1042.                                 }
  1043.                                 if (!player_.isAtLiveHead()) {
  1044.                                     if (await seekToLiveHeadForLiveStream()) await delayPn(60);
  1045.                                 }
  1046.                                 await refreshAllStaleEntitiesForNonReadyAudio();
  1047.                                 if (audio.readyState > 0 && audio.paused === true) {
  1048.                                     await triggerPlaying();
  1049.                                 }
  1050.                             }
  1051.  
  1052.                         }
  1053.                         try {
  1054.                             let ns23 = audio.networkState == 2 || audio.networkState == 3;
  1055.  
  1056.                             if (!ns23 && k === player_.getPlayerState()) {
  1057.                                 if (k === -1 && audio.readyState === 0) {
  1058.                                     const et = await mediaNetworkStateReady(audio);
  1059.                                     if (audio.isConnected === false || player_.getPlayerState() === 5) return;
  1060.                                     ns23 = audio.networkState == 2 || audio.networkState == 3;
  1061.                                     // console.log(503, ns23, et, player_.getPlayerState());
  1062.                                     if (player_.getPlayerState() !== -1) return;
  1063.                                 } else {
  1064.                                     console.log(507, k, audio.readyState, audio.networkState)
  1065.                                 }
  1066.                             }
  1067.  
  1068.                             if (k === -1 && player_.getPlayerState() === -1 && audio.readyState === 0 && ns23) {
  1069.                                 await delayPn(200);
  1070.                                 if (k === -1 && player_.getPlayerState() === -1 && audio.readyState === 0 && ns23) {
  1071.                                     await fixLiveAudioFn();
  1072.                                 }
  1073.                             } else if (k === 3 && player_.getPlayerState() === 3 && audio.readyState === 1 && ns23 && audio.muted === false) {
  1074.                                 await seekToLiveHeadForLiveStream();
  1075.                             } else if (k === 3 && player_.getPlayerState() === 3 && audio.readyState == 0 && ns23 && audio.muted === false) {
  1076.                                 await delayPn(60);
  1077.                                 if (k === 3 && player_.getPlayerState() === 3 && audio.readyState == 0 && ns23 && audio.muted === false) {
  1078.                                     await fixLiveAudioFn();
  1079.                                 }
  1080.                             } else if (k === 3 && player_.getPlayerState() === 3 && audio.readyState === 1 && ns23 && audio.muted === true) {
  1081.                                 await seekToLiveHeadForLiveStream();
  1082.                             } else if (k === 3 && player_.getPlayerState() === 3 && audio.readyState == 0 && ns23 && audio.muted === true) {
  1083.                                 await delayPn(60);
  1084.                                 if (k === 3 && player_.getPlayerState() === 3 && audio.readyState == 0 && ns23 && audio.muted === true) {
  1085.                                     await fixLiveAudioFn();
  1086.                                 }
  1087.                             }
  1088.  
  1089.                         } catch (e) {
  1090.                             console.log('error_F4', e)
  1091.                         }
  1092.  
  1093.                     };
  1094.  
  1095.                     // console.log(299, player_)
  1096.                     const _onPlayerStateChange = (k) => {
  1097.                         try {
  1098.                             if (typeof k === 'number' && k === player_.getPlayerState()) {
  1099.  
  1100.                                 const audio = document.querySelector('#player audio.video-stream.html5-main-video');
  1101.                                 if (audio) asyncStateChange(audio, k);
  1102.  
  1103.                             }
  1104.                         } catch (e) {
  1105.                             console.log('error_F5', e)
  1106.                         }
  1107.                     };
  1108.  
  1109.                     player_.addEventListener('onStateChange', _onPlayerStateChange);
  1110.                     const state0 = player_.getPlayerState();
  1111.                     if (typeof state0 === 'number') {
  1112.                         _onPlayerStateChange(state0);
  1113.                     }
  1114.  
  1115.                     player_.addEventListener('onVideoProgress', () => {
  1116.                         updateLastActiveTimeAsync(player_);
  1117.                     });
  1118.  
  1119.                     // console.log(1231)
  1120.  
  1121.                     if (SHOW_VIDEO_STATIC_IMAGE) {
  1122.  
  1123.                         let displayImage = '';
  1124.                         let html5Container = null;
  1125.  
  1126.  
  1127.                         const moviePlayer = document.querySelector('#movie_player .html5-video-container .video-stream.html5-main-video');
  1128.                         if (moviePlayer) {
  1129.                             html5Container = moviePlayer.closest('.html5-video-container');
  1130.                         }
  1131.  
  1132.                         if (html5Container) {
  1133.  
  1134.                             const overlayImage = document.querySelector('#movie_player .ytp-cued-thumbnail-overlay-image[style]');
  1135.                             if (overlayImage) {
  1136.  
  1137.                                 const cStyle = window.getComputedStyle(overlayImage);
  1138.                                 const cssImageValue = cStyle.backgroundImage;
  1139.                                 if (cssImageValue && typeof cssImageValue === 'string' && cssImageValue.startsWith('url(')) {
  1140.                                     displayImage = cssImageValue;
  1141.  
  1142.                                 }
  1143.  
  1144.                             }
  1145.  
  1146.                             if (!displayImage) {
  1147.  
  1148.                                 const config_ = typeof yt !== 'undefined' ? (yt || 0).config_ : 0;
  1149.                                 let embedded_player_response = null;
  1150.                                 if (config_) {
  1151.                                     embedded_player_response = ((config_.PLAYER_VARS || 0).embedded_player_response || 0)
  1152.                                 }
  1153.                                 if (embedded_player_response && typeof embedded_player_response === 'string') {
  1154.  
  1155.                                     let idx1 = embedded_player_response.indexOf('"defaultThumbnail"');
  1156.                                     let idx2 = idx1 >= 0 ? embedded_player_response.lastIndexOf('"defaultThumbnail"') : -1;
  1157.  
  1158.                                     if (idx1 === idx2 && idx1 > 0) {
  1159.  
  1160.                                         let bk = 0;
  1161.                                         let j = -1;
  1162.                                         for (let i = idx1; i < embedded_player_response.length; i++) {
  1163.                                             if (i > idx1 + 40 && bk === 0) {
  1164.                                                 j = i;
  1165.                                                 break;
  1166.                                             }
  1167.                                             let t = embedded_player_response.charAt(i);
  1168.                                             if (t === '{') bk++;
  1169.                                             else if (t === '}') bk--;
  1170.                                         }
  1171.  
  1172.                                         if (j > idx1) {
  1173.  
  1174.                                             let defaultThumbnailString = embedded_player_response.substring(idx1, j);
  1175.                                             let defaultThumbnailObject = null;
  1176.  
  1177.                                             try {
  1178.                                                 defaultThumbnailObject = JSON.parse(`{${defaultThumbnailString}}`);
  1179.  
  1180.                                             } catch (e) { }
  1181.  
  1182.                                             const thumbnails = ((defaultThumbnailObject.defaultThumbnail || 0).thumbnails || 0);
  1183.  
  1184.                                             if (thumbnails && thumbnails.length >= 1) {
  1185.  
  1186.                                                 let thumbnailUrl = getThumbnailUrlFromThumbnails(thumbnails);
  1187.  
  1188.                                                 if (thumbnailUrl && thumbnailUrl.length > 3) {
  1189.                                                     displayImage = `url(${thumbnailUrl})`;
  1190.                                                 }
  1191.                                             }
  1192.                                         }
  1193.  
  1194.                                     }
  1195.  
  1196.  
  1197.                                 }
  1198.  
  1199.  
  1200.                             }
  1201.  
  1202.                             if (displayImage) {
  1203.  
  1204.                                 html5Container.style.setProperty('--audio-only-thumbnail-image', `${displayImage}`);
  1205.                             } else {
  1206.                                 html5Container.style.removeProperty('--audio-only-thumbnail-image')
  1207.                             }
  1208.  
  1209.                         }
  1210.  
  1211.  
  1212.                     }
  1213.  
  1214.                 });
  1215.  
  1216.  
  1217.             } else {
  1218.  
  1219.                 attachOneTimeEvent('yt-action', () => {
  1220.                     const config_ = typeof yt !== 'undefined' ? (yt || 0).config_ : 0;
  1221.                     ytConfigFix(config_);
  1222.                 });
  1223.  
  1224.                 const setupAudioPlaying = (player00_) => {
  1225.                     const player_ = player00_;
  1226.                     if (!player_) return;
  1227.                     if (player_.__audio544__) return;
  1228.                     player_.__audio544__ = 1;
  1229.  
  1230.                     globalPlayer = mWeakRef(player_);
  1231.  
  1232.                     // console.log(1233, player_)
  1233.                     const mediaCollection = document.getElementsByClassName('html5-main-video');
  1234.  
  1235.                     const stopAndReloadFn = async () => {
  1236.                         let isLive = false;
  1237.                         if (isWatchPageURL()) {
  1238.                             const liveBtn = document.querySelector('.ytp-live-badge.ytp-button');
  1239.                             try {
  1240.                                 if (liveBtn && !liveBtn.closest('[hidden]') && (liveBtn.textContent || '').trim().length > 0) {
  1241.                                     isLive = true;
  1242.                                 }
  1243.                             } catch (e) { }
  1244.                         }
  1245.                         if (isLive) {
  1246.                             player_.destroy();
  1247.                             location.replace(location.href);
  1248.                             await delayPn(8000);
  1249.                         } else {
  1250.                             // await player_.stopVideo();
  1251.                             // await player_.updateVideoData();
  1252.                             // try{
  1253.                             //     await player_.refreshAllStaleEntities();
  1254.                             // }catch(e){}
  1255.                             // await player_.playVideo();
  1256.                         }
  1257.                     };
  1258.                     const asyncStateChange = async (audio, k) => {
  1259.  
  1260.                         const refreshAllStaleEntitiesForNonReadyAudio = async () => {
  1261.                             try {
  1262.                                 if (audio.readyState == 0 && audio.isConnected === true) await player_.refreshAllStaleEntities();
  1263.                             } catch (e) {
  1264.                             }
  1265.                         };
  1266.                         const triggerPlaying = async () => {
  1267.                             await player_.cancelPlayback();
  1268.                             await player_.pauseVideo();
  1269.                             await player_.playVideo();
  1270.                         };
  1271.                         const seekToLiveHeadForLiveStream = async () => {
  1272.                             try {
  1273.                                 audio.isConnected === true && await player_.seekToLiveHead();
  1274.                                 if (audio.isConnected === true && (await player_.isAtLiveHead()) === true) {
  1275.                                     audio.isConnected === true && await player_.seekToStreamTime();
  1276.                                     return true;
  1277.                                 }
  1278.                             } catch (e) {
  1279.                                 console.log('error_F7', e);
  1280.                             }
  1281.                         };
  1282.                         const fixLiveAudioFn = async () => {
  1283.                             if (stopAndReload) {
  1284.                                 stopAndReload = false;
  1285.                                 await stopAndReloadFn();
  1286.                             }
  1287.                             if (audio.isConnected === true && audio.paused === true) {
  1288.                                 await player_.clearVideo(); // avoid error in live streaming
  1289.                                 await player_.clearQueue(); // avoid error in live streaming
  1290.                                 await delayPn(300);
  1291.                                 for (let i = 0; i < 3; i++) {
  1292.                                     if (audio.readyState === 0 && audio.isConnected === true) {
  1293.                                         if (await seekToLiveHeadForLiveStream()) await delayPn(60);
  1294.                                     }
  1295.                                 }
  1296.                                 if (k === -1) {
  1297.                                     await refreshAllStaleEntitiesForNonReadyAudio();
  1298.                                 } else if (k === 3) {
  1299.                                     while (audio.readyState === 0 && audio.isConnected === true) {
  1300.                                         await refreshAllStaleEntitiesForNonReadyAudio();
  1301.                                         await triggerPlaying();
  1302.                                         await delayPn(300);
  1303.                                     }
  1304.                                 }
  1305.                             } else if (audio.isConnected === true && audio.paused === false) {
  1306.                                 if (!player_.isAtLiveHead() && audio.isConnected === true) {
  1307.                                     if (await seekToLiveHeadForLiveStream()) await delayPn(60);
  1308.                                 }
  1309.                                 while (audio.readyState === 0 && audio.isConnected === true) {
  1310.                                     await refreshAllStaleEntitiesForNonReadyAudio();
  1311.                                     await triggerPlaying();
  1312.                                     await delayPn(300);
  1313.                                 }
  1314.                                 if (!player_.isAtLiveHead() && audio.isConnected === true) {
  1315.                                     if (await seekToLiveHeadForLiveStream()) await delayPn(60);
  1316.                                 }
  1317.                                 await refreshAllStaleEntitiesForNonReadyAudio();
  1318.                                 if (audio.readyState > 0 && audio.paused === true && audio.isConnected === true) {
  1319.                                     await triggerPlaying();
  1320.                                 }
  1321.                             }
  1322.                         }
  1323.                         try {
  1324.  
  1325.                             let ns23 = audio.networkState == 2 || audio.networkState == 3;
  1326.  
  1327.                             if (!ns23 && k === player_.getPlayerState()) {
  1328.                                 if (k === -1 && audio.readyState === 0) {
  1329.                                     const et = await mediaNetworkStateReady(audio);
  1330.                                     if (audio.isConnected === false || player_.getPlayerState() === 5) return;
  1331.                                     ns23 = audio.networkState == 2 || audio.networkState == 3;
  1332.                                     console.log(513, ns23, et, player_.getPlayerState());
  1333.                                     if (player_.getPlayerState() !== -1) return;
  1334.                                 } else if (k === 3 && audio.readyState === 0 && audio.networkState === 0) {
  1335.                                     const et = await Promise.race([mediaNetworkStateReady(audio), delayPn(800)]); // idk
  1336.                                     if (audio.isConnected === false || player_.getPlayerState() === 5) return;
  1337.                                     ns23 = audio.networkState == 2 || audio.networkState == 3;
  1338.                                     console.log(514, ns23, et, player_.getPlayerState());
  1339.                                     if (player_.getPlayerState() !== 3) return;
  1340.                                 } else {
  1341.                                     console.log(517, k, audio.readyState, audio.networkState) // 517 3 0 0 after tab sleeping
  1342.                                 }
  1343.                             }
  1344.  
  1345.                             if (k === -1 && player_.getPlayerState() === -1 && audio.readyState === 0 && ns23) {
  1346.                                 await delayPn(200);
  1347.                                 if (k === -1 && player_.getPlayerState() === -1 && audio.readyState === 0 && ns23) {
  1348.                                     await fixLiveAudioFn();
  1349.                                 }
  1350.                             } else if (k === 3 && player_.getPlayerState() === 3 && audio.readyState === 1 && ns23 && audio.muted === false) {
  1351.                                 await seekToLiveHeadForLiveStream();
  1352.                             } else if (k === 3 && player_.getPlayerState() === 3 && audio.readyState == 0 && ns23 && audio.muted === false) {
  1353.                                 await delayPn(60);
  1354.                                 if (k === 3 && player_.getPlayerState() === 3 && audio.readyState == 0 && ns23 && audio.muted === false) {
  1355.                                     await fixLiveAudioFn();
  1356.                                 }
  1357.                             } else if (k === 3 && player_.getPlayerState() === 3 && audio.readyState === 1 && ns23 && audio.muted === true) {
  1358.                                 await seekToLiveHeadForLiveStream();
  1359.                             } else if (k === 3 && player_.getPlayerState() === 3 && audio.readyState == 0 && ns23 && audio.muted === true) {
  1360.                                 await delayPn(60);
  1361.                                 if (k === 3 && player_.getPlayerState() === 3 && audio.readyState == 0 && ns23 && audio.muted === true) {
  1362.                                     await fixLiveAudioFn();
  1363.                                 }
  1364.                             }
  1365.  
  1366.                         } catch (e) {
  1367.                             console.log('error_F8', e)
  1368.                         }
  1369.  
  1370.                     };
  1371.                     let mid = 0;
  1372.                     const getAudioElement = () => {
  1373.                         if (mediaCollection.length === 0) return null;
  1374.                         if (mediaCollection.length > 1) {
  1375.                             const audios = [...mediaCollection].filter(e => e && !e.closest('[hidden]') && e.closest('ytd-player'));
  1376.                             if (audios.length === 1) {
  1377.                                 return audios[0];
  1378.                             }
  1379.                         } else if (mediaCollection.length === 1) {
  1380.                             const e = mediaCollection[0];
  1381.                             if (e && !e.closest('[hidden]') && e.closest('ytd-player')) return e;
  1382.                         }
  1383.                         return null;
  1384.                     };
  1385.                     const _onPlayerStateChange = (k_) => {
  1386.                         const k = k_;
  1387.                         const ps = player_.getPlayerState();
  1388.                         if (stopAndReload) {
  1389.                             stopAndReload = false;
  1390.                             const audio = getAudioElement();
  1391.                             if (audio) {
  1392.                                 prrPipeline(async () => {
  1393.                                     await prr.then();
  1394.                                     await stopAndReloadFn();
  1395.                                 });
  1396.                             }
  1397.                         }
  1398.                         if (typeof k === 'number' && k === ps && ps !== 5) {
  1399.  
  1400.                             if (mid > 1e9) mid = 9;
  1401.                             const t = ++mid;
  1402.                             prrPipeline(async () => {
  1403.                                 if (t !== mid) return;
  1404.                                 await prr.then();
  1405.                                 if (t !== mid) return;
  1406.                                 const audio = getAudioElement();
  1407.  
  1408.                                 if (audio && player_.getPlayerState() === ps) {
  1409.                                     await asyncStateChange(audio, k);
  1410.                                 }
  1411.                             });
  1412.                         }
  1413.                     };
  1414.  
  1415.                     player_.addEventListener('onStateChange', _onPlayerStateChange);
  1416.                     const state0 = player_.getPlayerState();
  1417.                     // console.log(221, state0)
  1418.                     if (typeof state0 === 'number') {
  1419.                         _onPlayerStateChange(state0);
  1420.                     }
  1421.  
  1422.                     player_.addEventListener('onVideoProgress', () => {
  1423.                         updateLastActiveTimeAsync(player_);
  1424.                     });
  1425.  
  1426.                 }
  1427.  
  1428.                 customElements.whenDefined('ytd-player').then(() => {
  1429.                     const dummy = document.querySelector('ytd-player') || document.createElement('ytd-player');
  1430.                     const cnt = insp(dummy);
  1431.                     const cProto = cnt.constructor.prototype;
  1432.                     cProto.createMainAppPlayer932_ = cProto.createMainAppPlayer_;
  1433.                     cProto.initPlayer932_ = cProto.initPlayer_;
  1434.                     const configFixBeforeCreate = () => {
  1435.                         try {
  1436.                             const config_ = typeof yt !== 'undefined' ? (yt || 0).config_ : 0;
  1437.                             if (config_) {
  1438.                                 ytConfigFix(config_);
  1439.                             }
  1440.                         } catch (e) { }
  1441.                     }
  1442.                     cProto.createMainAppPlayer_ = function (a, b, c) {
  1443.                         configFixBeforeCreate();
  1444.                         let r = this.createMainAppPlayer932_(a, b, c);
  1445.                         try {
  1446.                             this.mainAppPlayer_.api.then(function (e) {
  1447.                                 setupAudioPlaying(e);
  1448.                             })
  1449.                         } finally {
  1450.                             return r;
  1451.                         }
  1452.                     }
  1453.                     cProto.initPlayer_ = function (a) {
  1454.                         configFixBeforeCreate();
  1455.                         let r = this.initPlayer932_(a);
  1456.                         try {
  1457.                             r.then(() => {
  1458.                                 setupAudioPlaying(this.player_);
  1459.                             })
  1460.                         } finally {
  1461.                             return r;
  1462.                         }
  1463.                     }
  1464.                 })
  1465.  
  1466.                 let useStopAndReload = !isWatchPageURL();
  1467.                 document.addEventListener('yt-navigate-start', () => {
  1468.                     prr = new PromiseExternal();
  1469.                     if (useStopAndReload) stopAndReload = true;
  1470.                 });
  1471.  
  1472.                 document.addEventListener('yt-navigate-cache', () => {
  1473.                     prr = new PromiseExternal();
  1474.                     if (useStopAndReload) stopAndReload = true;
  1475.                 });
  1476.  
  1477.                 document.addEventListener('yt-navigate-finish', () => {
  1478.                     prr.resolve();
  1479.                 });
  1480.  
  1481.             }
  1482.  
  1483.         } else if (location.origin === 'https://m.youtube.com') {
  1484.  
  1485.             removeBottomOverlayForMobile = async (delay) => {
  1486.  
  1487.  
  1488.                 let closeBtnRenderer = document.querySelector('.ytm-bottom-sheet-overlay-renderer-close.icon-close');
  1489.                 if (closeBtnRenderer) {
  1490.  
  1491.                     const btn = closeBtnRenderer.querySelector('button');
  1492.                     const container = closeBtnRenderer.closest('#global-loader ~ .ytm-bottom-sheet-overlay-container');
  1493.  
  1494.                     if (container) {
  1495.                         container.style.visibility = 'collapse';
  1496.                         container.style.zIndex = '-1';
  1497.                     }
  1498.                     if (btn) {
  1499.                         if (delay) {
  1500.                             await delayPn(delay);
  1501.                         }
  1502.                         btn.click();
  1503.                     }
  1504.                 }
  1505.  
  1506.             }
  1507.  
  1508.             const getAppJSON = () => {
  1509.                 let t;
  1510.                 t = document.querySelector('player-microformat-renderer.PlayerMicroformatRendererHost script[type="application/ld+json"]');
  1511.                 if (t) return t;
  1512.                 t = document.querySelector('player-microformat-renderer.playerMicroformatRendererHost script[type="application/ld+json"]');
  1513.                 if (t) return t;
  1514.  
  1515.                 console.log('[mobile youtube audio only] getAppJSON fails.', document.querySelectorAll('script[type="application/ld+json"]').length);
  1516.                 return null;
  1517.  
  1518.             }
  1519.  
  1520.  
  1521.             let lastPlayerInfoText = '';
  1522.             let mz = 0;
  1523.             onVideoChangeForMobile = async () => {
  1524.  
  1525.  
  1526.                 let html5Container = null;
  1527.  
  1528.                 const moviePlayer = document.querySelector('#player .html5-video-container .video-stream.html5-main-video');
  1529.                 if (moviePlayer) {
  1530.                     html5Container = moviePlayer.closest('.html5-video-container');
  1531.                 }
  1532.  
  1533.                 console.log('STx00', html5Container)
  1534.                 if (!html5Container) return;
  1535.                 let thumbnailUrl = '';
  1536.  
  1537.                 if (mz > 1e9) mz = 9;
  1538.                 let mt = ++mz;
  1539.                 const scriptText = await observablePromise(() => {
  1540.                     if (mt !== mz) return 1;
  1541.                     const t = getAppJSON();
  1542.                     const tt = (t ? t.textContent : '') || '';
  1543.                     if (tt === lastPlayerInfoText) return;
  1544.                     return tt;
  1545.                 }).obtain();
  1546.                 if (typeof scriptText !== 'string') return; // 1
  1547.                 lastPlayerInfoText = scriptText;
  1548.  
  1549.                 if (!scriptText) return;
  1550.  
  1551.  
  1552.                 if (SHOW_VIDEO_STATIC_IMAGE) {
  1553.                     console.log('STx01')
  1554.  
  1555.                     let idx1 = scriptText.indexOf('"thumbnailUrl"');
  1556.                     let idx2 = idx1 >= 0 ? scriptText.lastIndexOf('"thumbnailUrl"') : -1;
  1557.  
  1558.                     if (idx1 === idx2 && idx1 > 0) {
  1559.  
  1560.                         let bk = 0;
  1561.                         let j = -1;
  1562.                         for (let i = idx1; i < scriptText.length; i++) {
  1563.                             if (i > idx1 + 20 && bk === 0) {
  1564.                                 j = i;
  1565.                                 break;
  1566.                             }
  1567.                             let t = scriptText.charAt(i);
  1568.                             if (t === '[') bk++;
  1569.                             else if (t === ']') bk--;
  1570.                             else if (t === '{') bk++;
  1571.                             else if (t === '}') bk--;
  1572.                         }
  1573.  
  1574.  
  1575.                         if (j > idx1) {
  1576.  
  1577.                             let thumbnailUrlString = scriptText.substring(idx1, j);
  1578.                             let thumbnailUrlObject = null;
  1579.  
  1580.                             try {
  1581.                                 thumbnailUrlObject = JSON.parse(`{${thumbnailUrlString}}`);
  1582.  
  1583.                             } catch (e) { }
  1584.  
  1585.                             const thumbnails = thumbnailUrlObject.thumbnailUrl;
  1586.  
  1587.                             if (thumbnails && thumbnails.length >= 1 && typeof thumbnails[0] === 'string') {
  1588.                                 if (thumbnails[0] && thumbnails[0].length > 3) {
  1589.                                     thumbnailUrl = thumbnails[0];
  1590.                                 }
  1591.                             }
  1592.                         }
  1593.  
  1594.                     }
  1595.                     console.log('STx02', thumbnailUrl)
  1596.  
  1597.                     // const ytipr = (typeof ytInitialPlayerResponse !== 'undefined' ? ytInitialPlayerResponse : null) || 0;
  1598.  
  1599.                     // const thumbnails = (((ytipr.videoDetails || 0).thumbnail || 0).thumbnails || 0);
  1600.  
  1601.                     // if (thumbnails && thumbnails.length >= 1) {
  1602.                     //     thumbnailUrl = getThumbnailUrlFromThumbnails(thumbnails);
  1603.  
  1604.                     // }
  1605.                     if (thumbnailUrl && typeof thumbnailUrl === 'string') {
  1606.                         html5Container.style.setProperty('--audio-only-thumbnail-image', `url(${thumbnailUrl})`);
  1607.                     } else {
  1608.                         html5Container.style.removeProperty('--audio-only-thumbnail-image')
  1609.                     }
  1610.  
  1611.                 }
  1612.  
  1613.  
  1614.                 if (removeBottomOverlayForMobile) await removeBottomOverlayForMobile(40);
  1615.  
  1616.                 await delayPn(80);
  1617.                 const audio = moviePlayer;
  1618.                 if (audio && audio.muted === true && audio.isConnected === true && audio.readyState >= 0 && audio.networkState >= 2 && audio.paused === false) {
  1619.                     await audio.click();
  1620.                 }
  1621.  
  1622.             }
  1623.  
  1624.             let player0 = null;
  1625.             let mgg = null;
  1626.             const mff = function (e) {
  1627.                 if (!player0) {
  1628.                     if (e && typeof ((e || 0).target || 0).getPlayerState === 'function') {
  1629.                         player0 = e.target
  1630.                         if (mgg) mgg();
  1631.                     }
  1632.                 }
  1633.  
  1634.  
  1635.                 // if (SHOW_VIDEO_STATIC_IMAGE && (e.type === 'player-state-change' || e.type === 'video-data-change')) {
  1636.  
  1637.                 //     onVideoChangeForMobile();
  1638.                 // }
  1639.  
  1640.             }
  1641.  
  1642.             document.addEventListener('player-initialized', mff, true);
  1643.             document.addEventListener('player-state-change', mff, true);
  1644.             document.addEventListener('player-ad-state-change', mff, true);
  1645.             document.addEventListener('player-detailed-error', mff, true);
  1646.             document.addEventListener('player-error', mff, true);
  1647.             document.addEventListener('on-play-autonav-video', mff, true);
  1648.             document.addEventListener('on-play-previous-autonav-video', mff, true);
  1649.             document.addEventListener('player-fullscreen-change', mff, true);
  1650.             document.addEventListener('player-fullscreen-toggled', mff, true);
  1651.             document.addEventListener('player-dom-paused', mff, true);
  1652.             document.addEventListener('yt-show-toast', mff, true);
  1653.             document.addEventListener('yt-innertube-command', mff, true);
  1654.             document.addEventListener('yt-update-c3-companion', mff, true);
  1655.             document.addEventListener('video-data-change', mff, true);
  1656.             document.addEventListener('video-progress', mff, true);
  1657.             document.addEventListener('local-media-change', mff, true);
  1658.  
  1659.  
  1660.             let tc = false;
  1661.             // let pw = null;
  1662.             (async () => {
  1663.  
  1664.                 let player__;
  1665.  
  1666.                 const getAudioElement = () => {
  1667.                     const elm = player__ || player0;
  1668.                     const audio = elm && elm.isConnected === true ? HTMLElement.prototype.querySelector.call(elm, '.video-stream.html5-main-video') : null;
  1669.                     return audio;
  1670.                 }
  1671.  
  1672.                 const asyncStateChange = async (audio, k) => {
  1673.                     const player_ = player__;
  1674.                     if (!player_) return;
  1675.                     if (typeof player_.getPlayerState !== 'function') return;
  1676.  
  1677.                     const refreshAllStaleEntitiesForNonReadyAudio = async () => {
  1678.                         // try {
  1679.                         //     if (audio.readyState == 0) await player_.refreshAllStaleEntities();
  1680.                         // } catch (e) {
  1681.                         // }
  1682.                     };
  1683.                     const triggerPlaying = async () => {
  1684.                         await player_.cancelPlayback();
  1685.                         await player_.pauseVideo();
  1686.                         await player_.playVideo();
  1687.                     };
  1688.                     const seekToLiveHeadForLiveStream = async () => {
  1689.                         try {
  1690.                             await player_.seekToLiveHead();
  1691.                             if ((await player_.isAtLiveHead()) === true) {
  1692.                                 await player_.seekToStreamTime();
  1693.                                 return true;
  1694.                             }
  1695.                         } catch (e) {
  1696.                             console.log('error_F9', e);
  1697.                         }
  1698.                     };
  1699.                     const fixLiveAudioFn = async () => {
  1700.                         if (audio.paused === true) {
  1701.                             await player_.clearVideo(); // avoid error in live streaming
  1702.                             await player_.clearQueue(); // avoid error in live streaming
  1703.                             await delayPn(300);
  1704.                             for (let i = 0; i < 3; i++) {
  1705.                                 if (audio.readyState === 0) {
  1706.                                     if (await seekToLiveHeadForLiveStream()) await delayPn(60);
  1707.                                 }
  1708.                             }
  1709.                             if (k === -1) {
  1710.                                 await refreshAllStaleEntitiesForNonReadyAudio();
  1711.                             } else if (k === 3) {
  1712.                                 while (audio.readyState === 0) {
  1713.                                     await refreshAllStaleEntitiesForNonReadyAudio();
  1714.                                     await triggerPlaying();
  1715.                                     await delayPn(300);
  1716.                                 }
  1717.                                 // console.log(8809,audio.readyState)
  1718.                             }
  1719.                         } else if (audio.paused === false) {
  1720.                             if (!player_.isAtLiveHead()) {
  1721.                                 if (await seekToLiveHeadForLiveStream()) await delayPn(60);
  1722.                             }
  1723.                             while (audio.readyState === 0) {
  1724.                                 await refreshAllStaleEntitiesForNonReadyAudio();
  1725.                                 await triggerPlaying();
  1726.                                 await delayPn(300);
  1727.                             }
  1728.                             if (!player_.isAtLiveHead()) {
  1729.                                 if (await seekToLiveHeadForLiveStream()) await delayPn(60);
  1730.                             }
  1731.                             await refreshAllStaleEntitiesForNonReadyAudio();
  1732.                             if (audio.readyState > 0 && audio.paused === true) {
  1733.                                 await triggerPlaying();
  1734.                             }
  1735.                         }
  1736.  
  1737.                     }
  1738.                     try {
  1739.  
  1740.                         let ns23 = audio.networkState == 2 || audio.networkState == 3
  1741.                         // console.log(127001, k, player_.getPlayerState(), audio.readyState, ns23, audio.muted)
  1742.  
  1743.                         if (!ns23 && k === player_.getPlayerState()) {
  1744.                             if (k === -1 && audio.readyState === 0) {
  1745.                                 const et = await mediaNetworkStateReady(audio);
  1746.                                 if (audio.isConnected === false || player_.getPlayerState() === 5) return;
  1747.                                 ns23 = audio.networkState == 2 || audio.networkState == 3;
  1748.                                 console.log(523, ns23, et, player_.getPlayerState());
  1749.                                 if (player_.getPlayerState() !== -1) return;
  1750.                             } else {
  1751.                                 console.log(527, k, audio.readyState, audio.networkState)
  1752.                             }
  1753.                         }
  1754.  
  1755.                         if (removeBottomOverlayForMobile) await removeBottomOverlayForMobile(300);
  1756.  
  1757.                         if (k === 3 && player_.getPlayerState() === 3 && audio.readyState > 0 && ns23 && audio.muted === true) {
  1758.                             tc = true;
  1759.                         }
  1760.                         if (k === -1 && player_.getPlayerState() === -1 && audio.readyState === 0 && ns23) {
  1761.                             await delayPn(200);
  1762.                             if (k === -1 && player_.getPlayerState() === -1 && audio.readyState === 0 && ns23) {
  1763.                                 // console.log(8806)
  1764.                                 await fixLiveAudioFn();
  1765.                             }
  1766.                         } else if (k === 3 && player_.getPlayerState() === 3 && audio.readyState === 1 && ns23 && audio.muted === false) {
  1767.                             await seekToLiveHeadForLiveStream();
  1768.                         } else if (k === 3 && player_.getPlayerState() === 3 && audio.readyState == 0 && ns23) {
  1769.                             await delayPn(60);
  1770.                             if (k === 3 && player_.getPlayerState() === 3 && audio.readyState == 0 && ns23 && audio.paused === false) {
  1771.                                 // console.log(8807)
  1772.                                 await fixLiveAudioFn();
  1773.                             }
  1774.  
  1775.                         }
  1776.  
  1777.                     } catch (e) {
  1778.                         console.log('error_F10', e)
  1779.                     }
  1780.  
  1781.                 };
  1782.                 const _onPlayerStateChange = (e) => {
  1783.                     if (e && (e || 0).target) {
  1784.                         player__ = e.target
  1785.                     }
  1786.                     const player_ = player__;
  1787.                     try {
  1788.                         if (!player_) return;
  1789.                         let k = null;
  1790.                         if (e && e.detail && e.detail.state) {
  1791.                             k = e.detail.state
  1792.                         }
  1793.                         if (typeof player_.getPlayerState === 'function' && typeof k === 'number' && k === player_.getPlayerState()) {
  1794.                             const audio = getAudioElement();
  1795.                             if (audio) asyncStateChange(audio, k);
  1796.                         }
  1797.                     } catch (e) {
  1798.                         console.log('error_F11', e)
  1799.                     }
  1800.                 };
  1801.  
  1802.                 let idleAudioActivatePending = false;
  1803.  
  1804.                 const _onVideoProgress = (e) => {
  1805.                     if (e && (e || 0).target) {
  1806.                         player__ = e.target
  1807.                     }
  1808.                     const player_ = player__;
  1809.                     if (!player_) return;
  1810.                     updateLastActiveTimeAsync(player_);
  1811.                     if (tc) {
  1812.                         tc = false;
  1813.                         if (!idleAudioActivatePending) {
  1814.                             idleAudioActivatePending = true;
  1815.                         }
  1816.                     }
  1817.                 };
  1818.  
  1819.                 mgg = function () {
  1820.                     const player_ = player0;
  1821.                     if (player_) {
  1822.                         const state0 = player_.getPlayerState();
  1823.                         if (typeof state0 === 'number') {
  1824.                             _onPlayerStateChange({ type: 'player-state-change', target: player_, detail: { state: state0 } });
  1825.                         }
  1826.                     }
  1827.                 }
  1828.  
  1829.                 document.addEventListener('player-state-change', _onPlayerStateChange, true);
  1830.  
  1831.                 document.addEventListener('video-progress', _onVideoProgress, true);
  1832.  
  1833.             })();
  1834.  
  1835.             //       document.addEventListener('DOMContentLoaded', (evt) => {
  1836.             //         const mo = new MutationObserver((mutations)=>{
  1837.             //           console.log(5899, mutations)
  1838.             //         });
  1839.             //         mo.observe(document, {subtree: true, childList: true})
  1840.             //       })
  1841.  
  1842.             //       window.addEventListener('onReady', (evt) => {
  1843.             //         console.log(6811)
  1844.             //       }, true);
  1845.  
  1846.             //       window.addEventListener('localmediachange', (evt) => {
  1847.             //         console.log(6812)
  1848.             //       }, true);
  1849.  
  1850.             //       window.addEventListener('onVideoDataChange', (evt) => {
  1851.             //         console.log(6813)
  1852.             //       }, true);
  1853.  
  1854.             window.addEventListener('state-navigateend', async (evt) => {
  1855.  
  1856.  
  1857.                 const config_ = typeof yt !== 'undefined' ? (yt || 0).config_ : 0;
  1858.                 ytConfigFix(config_);
  1859.  
  1860.                 try {
  1861.                     if (clickLockFn && clickTarget) {
  1862.  
  1863.                         let a = HTMLElement.prototype.querySelector.call(clickTarget, '.video-stream.html5-main-video');
  1864.                         if (!a) return;
  1865.  
  1866.                         if (a.muted === true && a.__spfgs__ !== true && a.paused === true && a.networkState === 0 && a.readyState === 0) {
  1867.  
  1868.                             const pr = new Promise(resolve => {
  1869.  
  1870.                                 document.addEventListener('player-state-change', resolve, { once: true, passive: true, capture: false });
  1871.  
  1872.                             }).then();
  1873.  
  1874.                             clickLockFn.call(clickTarget, mockEvent({ type: 'click', target: clickTarget, detail: 1 }));
  1875.                             await delayPn(1);
  1876.  
  1877.                             if (a.muted === false && a.__spfgs__ !== true && a.paused === true && a.networkState === 0 && a.readyState === 0) {
  1878.                                 clickLockFn.call(clickTarget, mockEvent({ type: 'click', target: clickTarget, detail: 1 }));
  1879.                                 await delayPn(1);
  1880.                             }
  1881.  
  1882.                             delayRun(pr);
  1883.  
  1884.                         }
  1885.  
  1886.                     }
  1887.  
  1888.                 } catch (e) { console.log('error_F12', e) }
  1889.  
  1890.  
  1891.             }, false);
  1892.  
  1893.  
  1894.  
  1895.             // document.addEventListener('volumechange', (evt) => {
  1896.             //   console.log('volumechange')
  1897.             // }, true)
  1898.             // document.addEventListener('play', (evt) => {
  1899.             //   console.log('play')
  1900.             // }, true)
  1901.  
  1902.  
  1903.             // document.addEventListener('player-initialized', (evt) => {
  1904.             //   console.log(evt.type)
  1905.             // }, true)
  1906.             // document.addEventListener('renderer-module-load-start', (evt) => {
  1907.             //   console.log(evt.type)
  1908.             // }, true)
  1909.             // document.addEventListener('video-data-change', (evt) => {
  1910.             //   console.log(evt.type)
  1911.             // }, true)
  1912.             // document.addEventListener('player-state-change', (evt) => {
  1913.             //   console.log(evt.type)
  1914.             // }, true)
  1915.             // document.addEventListener('updateui', (evt) => {
  1916.             //   console.log(evt.type)
  1917.             // }, true)
  1918.             // document.addEventListener('renderer-module-load-end', (evt) => {
  1919.             //   console.log(evt.type)
  1920.             // }, true)
  1921.  
  1922.             // document.addEventListener('player-autonav-pause', (evt) => {
  1923.             //   console.log(evt.type)
  1924.             // }, true)
  1925.  
  1926.  
  1927.  
  1928.             // document.addEventListener('player-ad-state-change', (evt) => {
  1929.             //   console.log(evt.type)
  1930.             // }, true)
  1931.  
  1932.             // document.addEventListener('player-detailed-error', (evt) => {
  1933.             //   console.log(evt.type)
  1934.             // }, true)
  1935.  
  1936.             // document.addEventListener('player-error', (evt) => {
  1937.             //   console.log(evt.type)
  1938.             // }, true)
  1939.  
  1940.             // document.addEventListener('on-play-autonav-video', (evt) => {
  1941.             //   console.log(evt.type)
  1942.             // }, true)
  1943.  
  1944.             // document.addEventListener('on-play-previous-autonav-video', (evt) => {
  1945.             //   console.log(evt.type)
  1946.             // }, true)
  1947.  
  1948.             // document.addEventListener('player-fullscreen-change', (evt) => {
  1949.             //   console.log(evt.type)
  1950.             // }, true)
  1951.  
  1952.             // document.addEventListener('player-fullscreen-toggled', (evt) => {
  1953.             //   console.log(evt.type)
  1954.             // }, true)
  1955.  
  1956.             // document.addEventListener('player-dom-paused', (evt) => {
  1957.             //   console.log(evt.type)
  1958.             // }, true)
  1959.  
  1960.             // document.addEventListener('yt-show-toast', (evt) => {
  1961.             //   console.log(evt.type)
  1962.             // }, true)
  1963.             // document.addEventListener('yt-innertube-command', (evt) => {
  1964.             //   console.log(evt.type)
  1965.             // }, true)
  1966.             // document.addEventListener('yt-update-c3-companion', (evt) => {
  1967.             //   console.log(evt.type)
  1968.             // }, true)
  1969.             // document.addEventListener('video-progress', (evt) => {
  1970.             //   // console.log(evt.type)
  1971.             // }, true)
  1972.             // document.addEventListener('localmediachange', (evt) => {
  1973.             //   console.log(evt.type)
  1974.             // }, true)
  1975.  
  1976.  
  1977.  
  1978.             // window.addEventListener('player-initialized', (evt) => {
  1979.             //   console.log(evt.type)
  1980.             // }, true)
  1981.             // window.addEventListener('renderer-module-load-start', (evt) => {
  1982.             //   console.log(evt.type)
  1983.             // }, true)
  1984.             // window.addEventListener('video-data-change', (evt) => {
  1985.             //   console.log(evt.type)
  1986.             // }, true)
  1987.             // window.addEventListener('player-state-change', (evt) => {
  1988.             //   console.log(evt.type)
  1989.             // }, true)
  1990.             // window.addEventListener('updateui', (evt) => {
  1991.             //   console.log(evt.type)
  1992.             // }, true)
  1993.             // window.addEventListener('renderer-module-load-end', (evt) => {
  1994.             //   console.log(evt.type)
  1995.             // }, true)
  1996.  
  1997.             // window.addEventListener('player-autonav-pause', (evt) => {
  1998.             //   console.log(evt.type)
  1999.             // }, true)
  2000.  
  2001.  
  2002.  
  2003.             // window.addEventListener('player-ad-state-change', (evt) => {
  2004.             //   console.log(evt.type)
  2005.             // }, true)
  2006.  
  2007.             // window.addEventListener('player-detailed-error', (evt) => {
  2008.             //   console.log(evt.type)
  2009.             // }, true)
  2010.  
  2011.             // window.addEventListener('player-error', (evt) => {
  2012.             //   console.log(evt.type)
  2013.             // }, true)
  2014.  
  2015.             // window.addEventListener('on-play-autonav-video', (evt) => {
  2016.             //   console.log(evt.type)
  2017.             // }, true)
  2018.  
  2019.             // window.addEventListener('on-play-previous-autonav-video', (evt) => {
  2020.             //   console.log(evt.type)
  2021.             // }, true)
  2022.  
  2023.             // window.addEventListener('player-fullscreen-change', (evt) => {
  2024.             //   console.log(evt.type)
  2025.             // }, true)
  2026.  
  2027.             // window.addEventListener('player-fullscreen-toggled', (evt) => {
  2028.             //   console.log(evt.type)
  2029.             // }, true)
  2030.  
  2031.             // window.addEventListener('player-dom-paused', (evt) => {
  2032.             //   console.log(evt.type)
  2033.             // }, true)
  2034.  
  2035.             // window.addEventListener('yt-show-toast', (evt) => {
  2036.             //   console.log(evt.type)
  2037.             // }, true)
  2038.             // window.addEventListener('yt-innertube-command', (evt) => {
  2039.             //   console.log(evt.type)
  2040.             // }, true)
  2041.             // window.addEventListener('yt-update-c3-companion', (evt) => {
  2042.             //   console.log(evt.type)
  2043.             // }, true)
  2044.             // window.addEventListener('video-progress', (evt) => {
  2045.             //   // console.log(evt.type)
  2046.             // }, true)
  2047.             // window.addEventListener('localmediachange', (evt) => {
  2048.             //   console.log(evt.type)
  2049.             // }, true)
  2050.  
  2051.  
  2052.  
  2053.             // document.addEventListener('player-error', (evt) => {
  2054.             //   console.log(3001, evt.type, evt)
  2055.             // }, true)
  2056.             // document.addEventListener('player-detailed-error', (evt) => {
  2057.             //   console.log(3002, evt.type, evt)
  2058.             // }, true)
  2059.  
  2060.  
  2061.  
  2062.             async function delayRun(pr) {
  2063.  
  2064.                 let q = document.querySelector('#movie_player');
  2065.                 if (!q) return;
  2066.                 let a = document.querySelector('.video-stream.html5-main-video');
  2067.                 if (!a) return;
  2068.  
  2069.                 await pr.then();
  2070.  
  2071.                 if (fa !== 1) {
  2072.                     return;
  2073.                 } else if (a.muted === true) {
  2074.                     return;
  2075.                 } else if (a.muted === false && a.readyState === 0 && a.networkState === 2) {
  2076.                     if (a.paused === false) return;
  2077.                 } else {
  2078.                     return;
  2079.                 }
  2080.  
  2081.                 if (document.querySelector('.player-controls-content')) return;
  2082.  
  2083.                 if (a.paused === true && a.muted === false && a.readyState === 0 && a.networkState === 2) {
  2084.  
  2085.                     clickLockFn.call(clickTarget, mockEvent({ type: 'click', target: clickTarget, detail: 1 }));
  2086.  
  2087.                 }
  2088.  
  2089.                 if (a.paused === true && a.muted === false && a.networkState === 2 && a.readyState === 0) {
  2090.  
  2091.                     if (typeof clickTarget.seekToLiveHead === 'function') await clickTarget.seekToLiveHead();
  2092.                     if (typeof clickTarget.isAtLiveHead === 'function' && (await clickTarget.isAtLiveHead()) === true) {
  2093.                         if (typeof clickTarget.seekToStreamTime === 'function') await clickTarget.seekToStreamTime();
  2094.                     }
  2095.                 }
  2096.  
  2097.             }
  2098.  
  2099.             durationchangeForMobile = true;
  2100.  
  2101.         }
  2102.  
  2103.         attachOneTimeEvent('yt-action', function () {
  2104.             const config_ = typeof yt !== 'undefined' ? (yt || 0).config_ : 0;
  2105.             ytConfigFix(config_);
  2106.         });
  2107.  
  2108.         let prepared = false;
  2109.         function prepare() {
  2110.             if (prepared) return;
  2111.             prepared = true;
  2112.  
  2113.             if (typeof _yt_player !== 'undefined' && _yt_player && typeof _yt_player === 'object') {
  2114.  
  2115.                 for (const [k, v] of Object.entries(_yt_player)) {
  2116.  
  2117.                     const p = typeof v === 'function' ? v.prototype : 0;
  2118.  
  2119.                     if (p
  2120.                         && typeof p.clone === 'function'
  2121.                         && typeof p.get === 'function' && typeof p.set === 'function'
  2122.                         && typeof p.isEmpty === 'undefined' && typeof p.forEach === 'undefined'
  2123.                         && typeof p.clear === 'undefined'
  2124.                     ) {
  2125.  
  2126.                         key = k;
  2127.  
  2128.                     }
  2129.  
  2130.                 }
  2131.  
  2132.             }
  2133.  
  2134.             if (key) {
  2135.  
  2136.                 const ClassX = _yt_player[key];
  2137.                 _yt_player[key] = class extends ClassX {
  2138.                     constructor(...args) {
  2139.  
  2140.                         if (typeof args[0] === 'string' && args[0].startsWith('http://')) args[0] = '';
  2141.                         super(...args);
  2142.  
  2143.                     }
  2144.                 }
  2145.                 _yt_player[key].luX1Y = 1;
  2146.                 prototypeInherit(_yt_player[key].prototype, ClassX.prototype);
  2147.             }
  2148.  
  2149.         }
  2150.         let s3 = Symbol();
  2151.  
  2152.         generalRegister('deviceIsAudioOnly', s3, (p) => {
  2153.             return typeof p.getPlayerType === 'function' && typeof p.getVideoEmbedCode === 'function' && typeof p.getVideoUrl === 'function' && !p.onCueRangeEnter && !p.getVideoData && !('ATTRIBUTE_NODE' in p)
  2154.         }, {
  2155.  
  2156.             get() {
  2157.                 return this[s3];
  2158.             },
  2159.             set(nv) {
  2160.                 if (typeof nv === 'boolean') this[s3] = true;
  2161.                 else this[s3] = undefined;
  2162.                 prepare();
  2163.                 return true;
  2164.             },
  2165.             enumerable: false,
  2166.             configurable: true
  2167.  
  2168.         });
  2169.  
  2170.  
  2171.         let s1 = Symbol();
  2172.         let s2 = Symbol();
  2173.         Object.defineProperty(Object.prototype, 'defraggedFromSubfragments', {
  2174.             get() {
  2175.                 // console.log(501, this.constructor.prototype)
  2176.                 return undefined;
  2177.             },
  2178.             set(nv) {
  2179.                 return true;
  2180.             },
  2181.             enumerable: false,
  2182.             configurable: true
  2183.         });
  2184.  
  2185.         Object.defineProperty(Object.prototype, 'hasSubfragmentedFmp4', {
  2186.             get() {
  2187.                 // console.log(502, this.constructor.prototype)
  2188.                 return this[s1];
  2189.             },
  2190.             set(nv) {
  2191.                 if (typeof nv === 'boolean') this[s1] = false;
  2192.                 else this[s1] = undefined;
  2193.                 return true;
  2194.             },
  2195.             enumerable: false,
  2196.             configurable: true
  2197.         });
  2198.  
  2199.         Object.defineProperty(Object.prototype, 'hasSubfragmentedWebm', {
  2200.             get() {
  2201.                 // console.log(503, this.constructor.prototype)
  2202.                 return this[s2];
  2203.             },
  2204.             set(nv) {
  2205.                 if (typeof nv === 'boolean') this[s2] = false;
  2206.                 else this[s2] = undefined;
  2207.                 return true;
  2208.             },
  2209.             enumerable: false,
  2210.             configurable: true
  2211.         });
  2212.  
  2213.  
  2214.         const supportedFormatsConfig = () => {
  2215.  
  2216.             function typeTest(type) {
  2217.                 if (typeof type === 'string' && type.startsWith('video/')) {
  2218.                     return false;
  2219.                 }
  2220.             }
  2221.  
  2222.             // return a custom MIME type checker that can defer to the original function
  2223.             function makeModifiedTypeChecker(origChecker) {
  2224.                 // Check if a video type is allowed
  2225.                 return function (type) {
  2226.                     let res = undefined;
  2227.                     if (type === undefined) res = false;
  2228.                     else {
  2229.                         res = typeTest.call(this, type);
  2230.                     }
  2231.                     if (res === undefined) res = origChecker.apply(this, arguments);
  2232.                     return res;
  2233.                 };
  2234.             }
  2235.  
  2236.             // Override video element canPlayType() function
  2237.             const proto = (HTMLVideoElement || 0).prototype;
  2238.             if (proto && typeof proto.canPlayType == 'function') {
  2239.                 proto.canPlayType = makeModifiedTypeChecker(proto.canPlayType);
  2240.             }
  2241.  
  2242.             // Override media source extension isTypeSupported() function
  2243.             const mse = window.MediaSource;
  2244.             // Check for MSE support before use
  2245.             if (mse && typeof mse.isTypeSupported == 'function') {
  2246.                 mse.isTypeSupported = makeModifiedTypeChecker(mse.isTypeSupported);
  2247.             }
  2248.  
  2249.         };
  2250.  
  2251.         supportedFormatsConfig();
  2252.  
  2253.  
  2254.         PATCH_MEDIA_PUBLISH && (async ()=>{
  2255.  
  2256.  
  2257.             const _yt_player_observable = observablePromise(() => {
  2258.                 return (((window || 0)._yt_player || 0) || 0);
  2259.             });
  2260.   
  2261.  
  2262.             const addProtoToArr = (parent, key, arr) => {
  2263.  
  2264.  
  2265.                 let isChildProto = false;
  2266.                 for (const sr of arr) {
  2267.                     if (parent[key].prototype instanceof parent[sr]) {
  2268.                         isChildProto = true;
  2269.                         break;
  2270.                     }
  2271.                 }
  2272.  
  2273.                 if (isChildProto) return;
  2274.  
  2275.                 arr = arr.filter(sr => {
  2276.                     if (parent[sr].prototype instanceof parent[key]) {
  2277.                         return false;
  2278.                     }
  2279.                     return true;
  2280.                 });
  2281.  
  2282.                 arr.push(key);
  2283.  
  2284.                 return arr;
  2285.  
  2286.  
  2287.             };
  2288.             
  2289.             /*
  2290.  
  2291.                 const getD0 = (_yt_player) => {
  2292.  
  2293.                     const w = 'D0';
  2294.  
  2295.                     let arr = [];
  2296.  
  2297.                     for (const [k, v] of Object.entries(_yt_player)) {
  2298.  
  2299.                     const p = typeof v === 'function' ? v.prototype : 0;
  2300.                     if (p
  2301.                         && typeof p.playVideo === 'function' && p.playVideo.length === 1
  2302.                         && typeof p.getVisibilityState === 'function' && p.getVisibilityState.length === 8
  2303.                         && typeof p.getVideoData === 'function' && p.getVideoData.length === 0
  2304.                         && typeof p.seekTo === 'function' && p.seekTo.length === 5
  2305.                         && typeof p.pauseVideo === 'function' && p.pauseVideo.length === 2
  2306.                         && typeof p.stopVideo === 'function' && p.stopVideo.length === 1
  2307.                         && typeof p.getPresentingPlayerType === 'function' && p.getPresentingPlayerType.length === 1
  2308.                         && typeof p.getCurrentTime === 'function' && p.getCurrentTime.length === 3
  2309.                         && typeof p.cancelPlayback === 'function' && p.cancelPlayback.length === 2
  2310.                         // && !p.getPlayerType
  2311.  
  2312.                     ) {
  2313.                         arr = addProtoToArr(_yt_player, k, arr) || arr;
  2314.  
  2315.  
  2316.                     }
  2317.  
  2318.                     }
  2319.  
  2320.                     if (arr.length === 0) {
  2321.  
  2322.                     console.warn(`Key does not exist. [${w}]`);
  2323.                     } else {
  2324.  
  2325.                     console.log(`[${w}]`, arr);
  2326.                     return arr[0];
  2327.                     }
  2328.  
  2329.                 }
  2330.             */
  2331.  
  2332.             const gets0 = (_yt_player) => {
  2333.  
  2334.                 const w = 's0';
  2335.  
  2336.                 let arr = [];
  2337.  
  2338.                 for (const [k, v] of Object.entries(_yt_player)) {
  2339.  
  2340.                 const p = typeof v === 'function' ? v.prototype : 0;
  2341.                 if (p
  2342.                     && typeof p.isBackground === 'function' && p.isBackground.length === 0
  2343.                     && typeof p.getPlaybackRate === 'function' && p.getPlaybackRate.length === 0
  2344.                     && typeof p.publish === 'function' && p.publish.length === 2
  2345.                     && typeof p.isAtLiveHead === 'function' && p.isAtLiveHead.length === 2
  2346.  
  2347.  
  2348.  
  2349.                     // && !p.getPlayerType
  2350.  
  2351.                 ) {
  2352.                     arr = addProtoToArr(_yt_player, k, arr) || arr;
  2353.  
  2354.  
  2355.                 }
  2356.  
  2357.                 }
  2358.  
  2359.                 if (arr.length === 0) {
  2360.  
  2361.                 console.warn(`Key does not exist. [${w}]`);
  2362.                 } else {
  2363.  
  2364.                 console.log(`[${w}]`, arr);
  2365.                 return arr[0];
  2366.                 }
  2367.  
  2368.             };
  2369.  
  2370.             const printObject = (b)=>{
  2371.                 return JSON.stringify( Object.entries(b||{}).filter(e=>typeof (e[1]||0)!=='object'));
  2372.             };
  2373.  
  2374.             /*
  2375.                 (async () => {
  2376.                     // rAf scheduling
  2377.             
  2378.                     const _yt_player = await _yt_player_observable.obtain();
  2379.             
  2380.                     if (!_yt_player || typeof _yt_player !== 'object') return;
  2381.             
  2382.                     let keyD0 = getD0(_yt_player);
  2383.             
  2384.             
  2385.                     if (!keyD0) return;
  2386.             
  2387.             
  2388.                     const g = _yt_player
  2389.                     let k = keyD0
  2390.             
  2391.                     const gk = g[k];
  2392.                     if (typeof gk !== 'function') return;
  2393.                     const gkp = gk.prototype;
  2394.  
  2395.  
  2396.                     gkp.playVideo48 = gkp.playVideo;
  2397.                     gkp.playVideo = function(a) {
  2398.                         let r =  this.playVideo48(a);
  2399.                         // console.log('gkpD0 playVideo',r, a)
  2400.                         return r;
  2401.                     }
  2402.  
  2403.                     gkp.getVisibilityState48 = gkp.getVisibilityState;
  2404.                     gkp.getVisibilityState = function(a, b, c, d, e, f, h, l) {
  2405.                         let r =  this.getVisibilityState48(a, b, c, d, e, f, h, l);
  2406.                         // console.log('gkpD0 getVisibilityState',r, a,b,c,d,e,f,h,l)
  2407.                         r = 0;
  2408.                         return r;
  2409.                     }
  2410.  
  2411.  
  2412.                     gkp.getVideoData48 = gkp.getVideoData;
  2413.                     gkp.getVideoData = function() {
  2414.                         let r =  this.getVideoData48();
  2415.                         // console.log('gkpD0 getVideoData',r)
  2416.                         return r;
  2417.                     }
  2418.  
  2419.                     gkp.seekTo48 = gkp.seekTo;
  2420.                     gkp.seekTo = function(a, b, c, d, e) {
  2421.                         let r =  this.seekTo48(a, b, c, d, e);
  2422.                         // console.log('gkpD0 seekTo',r, a,b,c,d,e)
  2423.                         return r;
  2424.                     }
  2425.  
  2426.                     
  2427.                     gkp.pauseVideo48 = gkp.pauseVideo;
  2428.                     gkp.pauseVideo = function(a, b) {
  2429.                         let r =  this.pauseVideo48(a, b);
  2430.                         // console.log('gkpD0 pauseVideo',r, a,b);
  2431.                         return r;
  2432.                     }
  2433.  
  2434.  
  2435.                     gkp.stopVideo48 = gkp.stopVideo;
  2436.                     gkp.stopVideo = function(a) {
  2437.                         let r =  this.stopVideo48(a);
  2438.                         // console.log('gkpD0 stopVideo',r,a)
  2439.                         return r;
  2440.                     }
  2441.  
  2442.  
  2443.  
  2444.  
  2445.                     gkp.getPresentingPlayerType48 = gkp.getPresentingPlayerType;
  2446.                     gkp.getPresentingPlayerType = function(a) {
  2447.                         let r =  this.getPresentingPlayerType48(a);
  2448.                         // console.log('gkpD0 getPresentingPlayerType',r,a)
  2449.                         return r;
  2450.                     }
  2451.  
  2452.                     gkp.getCurrentTime48 = gkp.getCurrentTime;
  2453.                     gkp.getCurrentTime = function(a, b, c) {
  2454.                         let r =  this.getCurrentTime48(a, b, c);
  2455.                         // console.log('gkpD0 getCurrentTime',r, a,b,c)
  2456.                         return r;
  2457.                     }
  2458.  
  2459.                     
  2460.                     gkp.cancelPlayback48 = gkp.cancelPlayback;
  2461.                     gkp.cancelPlayback = function(a, b) {
  2462.                         let r =  this.cancelPlayback48(a, b);
  2463.                         // console.log('gkpD0 cancelPlayback',r, a,b);
  2464.                         return r;
  2465.                     }
  2466.             
  2467.                 })();
  2468.             */
  2469.  
  2470.  
  2471.  
  2472.             /**
  2473.              * 
  2474.              * 
  2475.  
  2476.                 g.k.mL = function(a) {
  2477.                     var b = a.target.Gf();
  2478.                     if (this.mediaElement && this.mediaElement.Gf() && this.mediaElement.Gf() === b) {
  2479.                         ehb(this, a.type);
  2480.                         switch (a.type) {
  2481.                         case "error":
  2482.                             var c = yFa(this.mediaElement) || ""
  2483.                             , d = this.mediaElement.xf();
  2484.                             if (c === "capability.changed") {
  2485.                                 this.L("html5_restart_on_capability_change") ? (this.ma("capchg", {
  2486.                                     msg: d
  2487.                                 }),
  2488.                                 F_(this, !0)) : u0(this);
  2489.                                 return
  2490.                             }
  2491.                             if (this.mediaElement.hasError() && (Ndb(this.al, c, {
  2492.                                 msg: d
  2493.                             }) || g.zS(this.videoData) && this.wb && this.wb.handleError(c)))
  2494.                                 return;
  2495.                             if (this.isBackground() && this.mediaElement.fh() === 4) {
  2496.                                 this.So();
  2497.                                 x0(this, "unplayable");
  2498.                                 return
  2499.                             }
  2500.                             break;
  2501.                         case "durationchange":
  2502.                             c = this.mediaElement.getDuration();
  2503.                             isFinite(c) && (!this.Qa || c > 0) && c !== 1 && this.Hl(c);
  2504.                             break;
  2505.                         case "ratechange":
  2506.                             this.ya && this.ya.setPlaybackRate(this.mediaElement.getPlaybackRate());
  2507.                             xfb(this.Ch);
  2508.                             this.wc().onPlaybackRateChange(this.getPlaybackRate());
  2509.                             break;
  2510.                         case "loadedmetadata":
  2511.                             ghb(this);
  2512.                             this.publish("onLoadedMetadata");
  2513.                             W5a(this);
  2514.                             c = this.bf();
  2515.                             this.videoData.SB && (this.videoData.SB = c);
  2516.                             break;
  2517.                         case "loadstart":
  2518.                             W5a(this);
  2519.                             break;
  2520.                         case "progress":
  2521.                         case "suspend":
  2522.                             this.Uc();
  2523.                             this.publish("onLoadProgress", this, this.Sw());
  2524.                             break;
  2525.                         case "playing":
  2526.                             this.Rb.uv("plev");
  2527.                             this.bT && !k0(this) && (this.bT = !1,
  2528.                             this.isAtLiveHead() || (this.logger.debug("seek to infinity on PLAYING"),
  2529.                             this.seekTo(Infinity, {
  2530.                                 kd: "videoplayer_onPlaying"
  2531.                             })));
  2532.                             break;
  2533.                         case "timeupdate":
  2534.                             c = this.mediaElement && !this.mediaElement.getCurrentTime();
  2535.                             d = this.mediaElement && this.mediaElement.Tk() === 0;
  2536.                             if (c && (!this.VK || d))
  2537.                                 return;
  2538.                             this.VK = this.VK || !!this.mediaElement.getCurrentTime();
  2539.                             Vgb(this);
  2540.                             this.Uc();
  2541.                             if (!this.mediaElement || this.mediaElement.Gf() !== b)
  2542.                                 return;
  2543.                             this.publish("onVideoProgress", this, this.getCurrentTime());
  2544.                             break;
  2545.                         case "waiting":
  2546.                             if (this.mediaElement.Vw().length > 0 && this.mediaElement.Eh().length === 0 && this.mediaElement.getCurrentTime() > 0 && this.mediaElement.getCurrentTime() < 5 && this.ya)
  2547.                                 return;
  2548.                             this.L("html5_ignore_unexpected_waiting_cfl") && (this.mediaElement.isPaused() || this.mediaElement.Tk() > 2 || !this.mediaElement.isSeeking() && aK(this.mediaElement.Eh(), this.mediaElement.getCurrentTime())) && (c = this.mediaElement.uc(),
  2549.                             c.bh = sK(this.mediaElement).toFixed(3),
  2550.                             this.ma("uwe", c));
  2551.                             g.zS(this.videoData) && this.wb && n7a(this.wb, this.mediaElement.getCurrentTime());
  2552.                             break;
  2553.                         case "resize":
  2554.                             ghb(this);
  2555.                             this.videoData.B && this.videoData.B.video.quality === "auto" && this.publish("internalvideoformatchange", this.videoData, !1);
  2556.                             break;
  2557.                         case "pause":
  2558.                             if (this.TW && g.pF(this.playerState, 8) && !g.pF(this.playerState, 1024) && this.getCurrentTime() === 0 && g.VB) {
  2559.                                 x0(this, "safari_autoplay_disabled");
  2560.                                 return
  2561.                             }
  2562.                         }
  2563.                         if (this.mediaElement && this.mediaElement.Gf() === b) {
  2564.                             dgb(this.Tc, a, this.wb || void 0);
  2565.                             this.publish("videoelementevent", a);
  2566.                             b = this.playerState;
  2567.                             d = this.bE;
  2568.                             var e = this.mediaElement;
  2569.                             c = this.videoData.clientPlaybackNonce;
  2570.                             var f = g.zS(this.videoData) && this.wb ? jY(this.wb) : void 0;
  2571.                             if (!g.pF(b, 128)) {
  2572.                                 var h = b.state;
  2573.                                 e = e ? e : a.target;
  2574.                                 var l = e.getCurrentTime();
  2575.                                 if (!g.pF(b, 64) || a.type !== "ended" && a.type !== "pause") {
  2576.                                     f = f || e.getDuration();
  2577.                                     f = e.isEnded() || l > 1 && Math.abs(l - f) < 1.1;
  2578.                                     var m = a.type === "pause" && e.isEnded();
  2579.                                     l = a.type === "ended" || a.type === "waiting" || a.type === "timeupdate" && !g.pF(b, 4) && !a0(d, l);
  2580.                                     if (m || f && l)
  2581.                                         e.KJ() > 0 && e.Gf() && (h = 14);
  2582.                                     else
  2583.                                         switch (a.type) {
  2584.                                         case "error":
  2585.                                             yFa(e) && (h |= 128);
  2586.                                             break;
  2587.                                         case "pause":
  2588.                                             g.pF(b, 256) ? (h ^= 256) || (h = 64) : g.pF(b, 32) || g.pF(b, 2) || g.pF(b, 4) || (h = 4,
  2589.                                             g.pF(b, 1) && g.pF(b, 8) && (h |= 1));
  2590.                                             break;
  2591.                                         case "playing":
  2592.                                             l = h;
  2593.                                             h = (h | 8) & -1093;
  2594.                                             l & 4 ? (h |= 1,
  2595.                                             uK(d, e)) : a0(d, e.getCurrentTime()) && (h &= -2);
  2596.                                             g.pF(b, 1) && uK(d, e) && (h |= 1);
  2597.                                             break;
  2598.                                         case "seeking":
  2599.                                             h |= 16;
  2600.                                             g.pF(b, 8) && (h |= 1);
  2601.                                             h &= -3;
  2602.                                             break;
  2603.                                         case "seeked":
  2604.                                             h &= -17;
  2605.                                             uK(d, e);
  2606.                                             break;
  2607.                                         case "waiting":
  2608.                                             g.pF(b, 2) || (h |= 1);
  2609.                                             uK(d, e);
  2610.                                             break;
  2611.                                         case "timeupdate":
  2612.                                             l = g.pF(b, 16),
  2613.                                             f = g.pF(b, 4),
  2614.                                             (g.pF(b, 8) || l) && !f && a0(d, e.getCurrentTime()) && (h = 8),
  2615.                                             uK(d, e) && (h |= 1)
  2616.                                         }
  2617.                                 }
  2618.                                 d = h;
  2619.                                 h = null;
  2620.                                 d & 128 && (h = a.target,
  2621.                                 e = yFa(h),
  2622.                                 l = 1,
  2623.                                 e ? (e === "capability.changed" && (l = 2),
  2624.                                 f = "GENERIC_WITHOUT_LINK",
  2625.                                 m = h.uc(),
  2626.                                 m.mediaElem = "1",
  2627.                                 /AUDIO_RENDERER/.test(h.xf()) && (f = "HTML5_AUDIO_RENDERER_ERROR"),
  2628.                                 h = {
  2629.                                     errorCode: e,
  2630.                                     errorMessage: g.JV[f] || "",
  2631.                                     bP: f,
  2632.                                     KL: yJ(m),
  2633.                                     rJ: l,
  2634.                                     cpn: b.Pg ? b.Pg.cpn : ""
  2635.                                 }) : h = null,
  2636.                                 h && (h.cpn = c));
  2637.                                 b = vK(b, d, h)
  2638.                             }
  2639.                             !g.pF(this.playerState, 1) && g.pF(b, 1) && dhb(this, "evt" + a.type);
  2640.                             this.Ic(b)
  2641.                         }
  2642.                     }
  2643.                 }
  2644.                 ;
  2645.              * 
  2646.              * 
  2647.              */
  2648.  
  2649.  
  2650.  
  2651.  
  2652.             (async () => {
  2653.                 // rAf scheduling
  2654.           
  2655.                 const _yt_player = await _yt_player_observable.obtain();
  2656.           
  2657.                 if (!_yt_player || typeof _yt_player !== 'object') return;
  2658.           
  2659.                 let keys0 = gets0(_yt_player);
  2660.           
  2661.           
  2662.                 if (!keys0) return;
  2663.           
  2664.           
  2665.                 const g = _yt_player
  2666.                 let k = keys0
  2667.           
  2668.                 const gk = g[k];
  2669.                 if (typeof gk !== 'function') return;
  2670.                 const gkp = gk.prototype;
  2671.  
  2672.  
  2673.                 // gkp.isBackground48 = gkp.isBackground;
  2674.                 // gkp.isBackground = function() {
  2675.                 //     if(!this?.visibility?.isBackground88){
  2676.                 //         this.visibility.isBackground88 = 1;
  2677.                 //         this.visibility.isBackground = function(){
  2678.                 //             return false;
  2679.                 //         }
  2680.                 //     }
  2681.                 //     // console.log('gkps0', 'isBackground', this.visibility)
  2682.                 //     // return false;
  2683.                 //     // if(!this.mediaElement || !(this.mediaElement.readyState>=4)){
  2684.                 //     //     return false;
  2685.                 //     // }
  2686.                 //     // console.log(1882,)
  2687.                 //     return this.isBackground48();
  2688.                 // }
  2689.  
  2690.                 gkp.publish48 = gkp.publish;
  2691.                 gkp.publish33 = async function(a,b){
  2692.  
  2693.                     const player_ = kRef(globalPlayer);
  2694.                     let publishStatus = 0;
  2695.                     const media = this.mediaElement;
  2696.  
  2697.                     if(a==='internalaudioformatchange' && typeof (b.author||0) === 'string' && media && player_){
  2698.  
  2699.                         await player_.clearVideo(); // avoid error in live streaming
  2700.                         await player_.clearQueue(); // avoid error in live streaming
  2701.                         await refreshAllStaleEntitiesForNonReadyAudio();
  2702.                         // await player_.cancelPlayback();
  2703.                         publishStatus = media.__publishStatus17__ = 100;
  2704.                     }
  2705.  
  2706.  
  2707.  
  2708.  
  2709.  
  2710.                     const domMedia = media ? Object.values(media).filter(e => e instanceof HTMLMediaElement) : [];
  2711.                     if (this.mediaElement && a !== 'internalvideoformatchange' && player_ && domMedia.length === 1) {
  2712.  
  2713.                         const audio = domMedia[0];
  2714.  
  2715.  
  2716.  
  2717.                         const refreshAllStaleEntitiesForNonReadyAudio = async () => {
  2718.                             try {
  2719.                                 if (audio.readyState == 0 && audio.isConnected === true) await player_.refreshAllStaleEntities();
  2720.                             } catch (e) {
  2721.                             }
  2722.                         };
  2723.                         // const triggerPlaying = async () => {
  2724.                         //     await player_.cancelPlayback();
  2725.                         //     this.pauseVideo();
  2726.                         //     this.playVideo();
  2727.                         //     await player_.pauseVideo();
  2728.                         //     await player_.playVideo();
  2729.                         // };
  2730.                         const seekToLiveHeadForLiveStream = async () => {
  2731.                             try {
  2732.                                 audio.isConnected === true && await player_.seekToLiveHead();
  2733.                                 if (audio.isConnected === true && (await player_.isAtLiveHead()) === true) {
  2734.                                     audio.isConnected === true && await player_.seekToStreamTime();
  2735.                                     return true;
  2736.                                 }
  2737.                             } catch (e) {
  2738.                                 console.log('error_F7', e);
  2739.                             }
  2740.                         };
  2741.  
  2742.  
  2743.                         if(a.includes('error') ){
  2744.  
  2745.                             if(!media.__publishStatus17__ || media.__publishStatus17__ < 200){
  2746.  
  2747.                                 await player_.clearVideo(); // avoid error in live streaming
  2748.                                 await player_.clearQueue(); // avoid error in live streaming
  2749.                                 await refreshAllStaleEntitiesForNonReadyAudio();
  2750.                                 // await player_.cancelPlayback();
  2751.  
  2752.                             }
  2753.     
  2754.      
  2755.     
  2756.     
  2757.                         }else{
  2758.  
  2759.  
  2760.  
  2761.                             media.__publishStatus17__ = media.__publishStatus17__ || 100;
  2762.  
  2763.  
  2764.  
  2765.                             if (media.__publishStatus17__ === 100) await refreshAllStaleEntitiesForNonReadyAudio();
  2766.                             if (media.__publishStatus17__ === 100 && audio.duration > 0 && player_.getPlayerState() === 3) {
  2767.     
  2768.     
  2769.     
  2770.                                 media.__publishStatus17__ = 200
  2771.                                 // await refreshAllStaleEntitiesForNonReadyAudio();
  2772.     
  2773.                                 await player_.cancelPlayback();
  2774.                                 await this.pauseVideo();
  2775.                                 // this.playVideo();
  2776.                                 // await player_.pauseVideo();
  2777.                                 await player_.playVideo();
  2778.                                 await seekToLiveHeadForLiveStream();
  2779.     
  2780.     
  2781.                                 // fixLiveAudioFn(domMedia0, player_, player_.getPlayerState())
  2782.     
  2783.     
  2784.                                 // skipPause = true;
  2785.                                 // skipVisibility = true;
  2786.                                 //  player_.cancelPlayback();
  2787.                                 //  player_.pauseVideo();
  2788.                                 //  player_.playVideo();
  2789.                                 //  skipPause = false;
  2790.                                 //  skipVisibility = false;
  2791.     
  2792.     
  2793.                             } 
  2794.     
  2795.     
  2796.     
  2797.                             if (a === 'onLoadedMetadata' && media.__publishStatus17__ === 200) media.__publishStatus17__ = 201;
  2798.                             if (a === 'videoelementevent' && b.type === 'loadedmetadata' && media.__publishStatus17__ === 201) media.__publishStatus17__ = 202;
  2799.                             if (a === 'videoelementevent' && b.type === 'progress' && media.__publishStatus17__ === 202) {
  2800.     
  2801.                                 media.__publishStatus17__ = 203;
  2802.                                 window.debug_mfk = this;
  2803.                                 window.debug_mfp = player_;
  2804.     
  2805.                                 // (async ()=>{
  2806.                                 //     await timelineResolve();
  2807.                                 //     const domMedia = Object.values(this.mediaElement).filter(e=>e instanceof HTMLMediaElement);
  2808.                                 //     if(domMedia.length === 1){
  2809.                                 //         const domMedia0 = domMedia[0]
  2810.     
  2811.                                 //         if(domMedia0.duration >0 && domMedia0.readyState >= 4){
  2812.     
  2813.                                 //             await timelineResolve();
  2814.                                 //             console.log(939, domMedia0, domMedia0.paused, domMedia0.duration, domMedia0.readyState)
  2815.                                 //             this.pauseVideo();
  2816.                                 //             await timelineResolve();
  2817.                                 //             this.playVideo();
  2818.     
  2819.                                 //         }
  2820.                                 //         // this.mediaElement.pause();
  2821.                                 //         // this.mediaElement.play();
  2822.                                 //     }
  2823.     
  2824.                                 // })();
  2825.                             }
  2826.                             if (media.__publishStatus17__ === 203 && audio && audio.readyState === 1) {
  2827.     
  2828.     
  2829.                                 media.__publishStatus17__ = 204;
  2830.                             
  2831.                                 // await timelineResolve();
  2832.                                 // await player_.cancelPlayback();
  2833.                                 await this.pauseVideo();
  2834.                                 // this.playVideo();
  2835.                                 // await timelineResolve();
  2836.                                 // await player_.pauseVideo();
  2837.                                 await player_.playVideo();
  2838.                                 // await timelineResolve();
  2839.                                 await seekToLiveHeadForLiveStream();
  2840.     
  2841.     
  2842.     
  2843.                             }
  2844.     
  2845.     
  2846.                             if (media.__publishStatus17__ < 300 && media.__publishStatus17__ >= 200 && a === 'videoelementevent' && b.type==='timeupdate' && !audio.paused && audio.readyState >= 4 && audio.duration > 0) {
  2847.                                 media.__publishStatus17__ = 300;
  2848.                                 if(!player_.isAtLiveHead()) await seekToLiveHeadForLiveStream();
  2849.                             }
  2850.     
  2851.  
  2852.                         }
  2853.  
  2854.  
  2855.                         publishStatus = media.__publishStatus17__;
  2856.  
  2857.                         if (debugFlg001) console.log('gkps0 publish | ' + publishStatus, a, printObject(b))
  2858.  
  2859.                     }
  2860.                 }
  2861.                 gkp.publish = function(a,b){
  2862.  
  2863.                     this.publish33(a,b);
  2864.                     
  2865.                     return this.publish48.apply(this, arguments);
  2866.                 }
  2867.  
  2868.                 // console.log(23488)
  2869.  
  2870.             })();
  2871.  
  2872.         })();
  2873.  
  2874.  
  2875.     }
  2876.  
  2877.     const getVideoIdByURL = () => {
  2878.         // It's almost certainly going to stay at 11 characters. The individual characters come from a set of 64 possibilities (A-Za-z0-9_-).
  2879.         // base64 form; 26+26+10+2; 64^len
  2880.         // Math.pow(64,11) = 73786976294838210000
  2881.  
  2882.         const url = new URL(location.href);
  2883.         let m;
  2884.  
  2885.         if (m = /^\/watch\?v=([A-Za-z0-9_-]+)/.exec(`${url.pathname}?v=${url.searchParams.get('v')}`)) return `${m[1]}`;
  2886.         if (m = /^\/live\/([A-Za-z0-9_-]+)/.exec(url.pathname)) return `${m[1]}`;
  2887.  
  2888.         if (m = /^\/embed\/live_stream\?channel=([A-Za-z0-9_-]+)/.exec(`${url.pathname}?channel=${url.searchParams.get('channel')}`)) return `L:${m[1]}`;
  2889.         if (m = /^\/embed\/([A-Za-z0-9_-]+)/.exec(url.pathname)) return `${m[1]}`;
  2890.  
  2891.         if (m = /^\/channel\/([A-Za-z0-9_-]+)\/live\b/.exec(url.pathname)) return `L:${m[1]}`;
  2892.         if (url.hostname === 'youtu.be' && (m = /\/([A-Za-z0-9_-]+)/.exec(url.pathname))) return `${m[1]}`;
  2893.  
  2894.         return '';
  2895.  
  2896.     };
  2897.  
  2898.     const getVideoIdByElement = ()=>{
  2899.         const videoIdElements = [...document.querySelectorAll('[video-id]')].filter(v => !v.closest('[hidden]'));
  2900.         const videoId = videoIdElements.length > 0 ? videoIdElements[0].getAttribute('video-id') : null;
  2901.         return videoId || '';
  2902.     };
  2903.  
  2904.     const getEnableValue = async ()=>{
  2905.         const videoId = getVideoIdByURL() || getVideoIdByElement();
  2906.         const siteVal = videoId ? await GM.getValue(`isEnable_aWsjF_${videoId}`, null) : null;
  2907.         return (siteVal !== null) ? siteVal : await GM.getValue("isEnable_aWsjF", true);
  2908.     };
  2909.  
  2910.     const setEnableVal = async (val)=>{
  2911.         const videoId = getVideoIdByURL() || getVideoIdByElement();
  2912.         if (videoId) {
  2913.             try {
  2914.                 const cv = await GM.getValue(`isEnable_aWsjF_${videoId}`, null);
  2915.                 if (typeof cv === typeof val) await GM.setValue(`isEnable_aWsjF_${videoId}`, val);
  2916.             } catch (e) { }
  2917.         }
  2918.         await GM.setValue("isEnable_aWsjF", val);
  2919.     }
  2920.  
  2921.     const isEnable = (typeof GM !== 'undefined' && typeof GM.getValue === 'function') ? await getEnableValue() : null;
  2922.     if (typeof isEnable !== 'boolean') throw new DOMException("Please Update your browser", "NotSupportedError");
  2923.     if (isEnable) {
  2924.         const element = document.createElement('button');
  2925.         element.setAttribute('onclick', createHTML(`(${pageInjectionCode})()`));
  2926.         element.click();
  2927.     }
  2928.  
  2929.     GM_registerMenuCommand(`Turn ${isEnable ? 'OFF' : 'ON'} YouTube Audio Mode`, async function () {
  2930.         await setEnableVal(!isEnable);
  2931.         await GM.setValue('lastCheck_bWsm5', Date.now());
  2932.         document.documentElement.setAttribute('forceRefresh032', '');
  2933.         location.reload();
  2934.     });
  2935.  
  2936.     let messageCount = 0;
  2937.     let busy = false;
  2938.     window.addEventListener('message', (evt) => {
  2939.  
  2940.         const v = ((evt || 0).data || 0).ZECxh;
  2941.         if (typeof v === 'boolean') {
  2942.             if (messageCount > 1e9) messageCount = 9;
  2943.             const t = ++messageCount;
  2944.             if (v && isEnable) {
  2945.                 requestAnimationFrame(async () => {
  2946.                     if (t !== messageCount) return;
  2947.                     if (busy) return;
  2948.                     busy = true;
  2949.                     if (await confirm("Livestream is detected. Press OK to disable YouTube Audio Mode.")) {
  2950.                         await setEnableVal(!isEnable);
  2951.                         await GM.setValue('lastCheck_bWsm5', Date.now());
  2952.                         document.documentElement.setAttribute('forceRefresh032', '');
  2953.                         location.reload();
  2954.                     }
  2955.                     busy = false;
  2956.                 });
  2957.             }
  2958.         }
  2959.  
  2960.     });
  2961.  
  2962.  
  2963.     const pLoad = new Promise(resolve => {
  2964.         if (document.readyState !== 'loading') {
  2965.             resolve();
  2966.         } else {
  2967.             window.addEventListener("DOMContentLoaded", resolve, false);
  2968.         }
  2969.     });
  2970.  
  2971.  
  2972.     function contextmenuInfoItemAppearedFn(target) {
  2973.  
  2974.         const btn = target.closest('.ytp-menuitem[role="menuitem"]');
  2975.         if (!btn) return;
  2976.         if (btn.parentNode.querySelector('.ytp-menuitem[role="menuitem"].audio-only-toggle-btn')) return;
  2977.         document.documentElement.classList.add('with-audio-only-toggle-btn');
  2978.         const newBtn = btn.cloneNode(true)
  2979.         newBtn.querySelector('.ytp-menuitem-label').textContent = `Turn ${isEnable ? 'OFF' : 'ON'} YouTube Audio Mode`;
  2980.         newBtn.classList.add('audio-only-toggle-btn');
  2981.         btn.parentNode.insertBefore(newBtn, btn.nextSibling);
  2982.         newBtn.addEventListener('click', async (evt) => {
  2983.             try {
  2984.                 evt.stopPropagation();
  2985.                 evt.stopImmediatePropagation();
  2986.             } catch (e) { }
  2987.             await setEnableVal(!isEnable);
  2988.             await GM.setValue('lastCheck_bWsm5', Date.now());
  2989.             document.documentElement.setAttribute('forceRefresh032', '');
  2990.             location.reload();
  2991.         });
  2992.         let t;
  2993.         let h = 0;
  2994.         t = btn.closest('.ytp-panel-menu[style*="height"]');
  2995.         if (t) t.style.height = t.scrollHeight + 'px';
  2996.         t = btn.closest('.ytp-panel[style*="height"]');
  2997.         if (t) t.style.height = (h = t.scrollHeight) + 'px';
  2998.         t = btn.closest('.ytp-popup.ytp-contextmenu[style*="height"]');
  2999.         if (t && h > 0) t.style.height = h + 'px';
  3000.     }
  3001.  
  3002.  
  3003.     function mobileMenuItemAppearedFn(target) {
  3004.  
  3005.         const btn = target.closest('ytm-menu-item');
  3006.         if (!btn) return;
  3007.         if (btn.parentNode.querySelector('ytm-menu-item.audio-only-toggle-btn')) return;
  3008.         document.documentElement.classList.add('with-audio-only-toggle-btn');
  3009.         const newBtn = btn.cloneNode(true);
  3010.         newBtn.querySelector('.menu-item-button').textContent = `Turn ${isEnable ? 'OFF' : 'ON'} YouTube Audio Mode`;
  3011.         newBtn.classList.add('audio-only-toggle-btn');
  3012.         btn.parentNode.insertBefore(newBtn, btn.nextSibling);
  3013.         newBtn.addEventListener('click', async (evt) => {
  3014.             try {
  3015.                 evt.stopPropagation();
  3016.                 evt.stopImmediatePropagation();
  3017.             } catch (e) { }
  3018.             await setEnableVal(!isEnable);
  3019.             await GM.setValue('lastCheck_bWsm5', Date.now());
  3020.             document.documentElement.setAttribute('forceRefresh032', '');
  3021.             location.reload();
  3022.         });
  3023.     }
  3024.  
  3025.     const lastEntry = (arr) => {
  3026.         return arr.length > 0 ? arr[arr.length - 1] : null;
  3027.     }
  3028.  
  3029.     function mobileMenuItemAppearedV2Fn(target) {
  3030.  
  3031.         const btn = target.closest('yt-list-item-view-model');
  3032.         if (!(btn instanceof HTMLElement)) return;
  3033.         if (btn.parentNode.querySelector('yt-list-item-view-model.audio-only-toggle-btn')) return;
  3034.         const parentNode = btn.closest('player-settings-menu');
  3035.         if(!parentNode) return;
  3036.         let qt = 1E9;
  3037.         let targetBtnO = lastEntry([...parentNode.getElementsByTagName(btn.nodeName)].filter(e => e.parentElement === btn.parentElement).map((elm) => {
  3038.             const count = elm.getElementsByTagName('*').length;
  3039.             if (count < qt) qt = count;
  3040.             return {
  3041.                 elm: elm,
  3042.                 count: count
  3043.             }
  3044.         }).filter((o) => o.count === qt));
  3045.  
  3046.         const targetBtn = targetBtnO && targetBtnO.elm instanceof HTMLElement ? targetBtnO.elm : btn;
  3047.  
  3048.  
  3049.         const newBtn = targetBtn.cloneNode(true);
  3050.         if(newBtn instanceof HTMLElement){
  3051.             document.documentElement.classList.add('with-audio-only-toggle-btn');
  3052.  
  3053.             let newBtnContentElm = newBtn;
  3054.             let layerCN = 8;
  3055.             while (newBtnContentElm.childElementCount === 1 && layerCN--) {
  3056.                 newBtnContentElm = newBtnContentElm.firstElementChild;
  3057.             }
  3058.             if (!(newBtnContentElm instanceof HTMLElement)) newBtnContentElm = newBtn;
  3059.             let t;
  3060.             if (t = lastEntry(newBtnContentElm.querySelectorAll('span[role="text"]'))) {
  3061.                 newBtnContentElm = t;
  3062.                 newBtnContentElm.classList.add('audio-only-toggle-btn-content2');
  3063.             } else if (t = lastEntry(newBtnContentElm.querySelectorAll('[role="text"]'))) {
  3064.                 newBtnContentElm = t;
  3065.                 newBtnContentElm.classList.add('audio-only-toggle-btn-content2');
  3066.             } else if (t = lastEntry(newBtnContentElm.querySelectorAll('span'))) {
  3067.                 newBtnContentElm = t;
  3068.                 newBtnContentElm.classList.add('audio-only-toggle-btn-content2');
  3069.             } else if (t = lastEntry(newBtnContentElm.querySelector('.yt-core-attributed-string'))) {
  3070.                 newBtnContentElm = t;
  3071.                 newBtnContentElm.classList.add('audio-only-toggle-btn-content2');
  3072.             }
  3073.             newBtnContentElm.textContent = `Turn ${isEnable ? 'OFF' : 'ON'} YouTube Audio Mode`;
  3074.             newBtn.classList.add('audio-only-toggle-btn');
  3075.             newBtnContentElm.classList.add('audio-only-toggle-btn-content');
  3076.             btn.parentNode.insertBefore(newBtn, btn.nextSibling);
  3077.             newBtn.addEventListener('click', async (evt) => {
  3078.                 try {
  3079.                     evt.stopPropagation();
  3080.                     evt.stopImmediatePropagation();
  3081.                 } catch (e) { }
  3082.                 await setEnableVal(!isEnable);
  3083.                 await GM.setValue('lastCheck_bWsm5', Date.now());
  3084.                 document.documentElement.setAttribute('forceRefresh032', '');
  3085.                 location.reload();
  3086.             });
  3087.             const contentWrapper = newBtn.closest('#content-wrapper');
  3088.             if (contentWrapper) {
  3089.                 contentWrapper.style.height = 'unset';
  3090.                 contentWrapper.style.maxHeight = 'unset';
  3091.             }
  3092.         }
  3093.     }
  3094.  
  3095.     pLoad.then(() => {
  3096.  
  3097.         document.addEventListener('animationstart', (evt) => {
  3098.             const animationName = evt.animationName;
  3099.             if (!animationName) return;
  3100.  
  3101.             if (animationName === 'contextmenuInfoItemAppeared') contextmenuInfoItemAppearedFn(evt.target);
  3102.             if (animationName === 'mobileMenuItemAppeared') mobileMenuItemAppearedFn(evt.target);
  3103.             if (animationName === 'mobileMenuItemAppearedV2') mobileMenuItemAppearedV2Fn(evt.target);
  3104.  
  3105.         }, true);
  3106.  
  3107.         const cssForEnabled = isEnable ? `
  3108.  
  3109.             .html5-video-player {
  3110.                 background-color: black;
  3111.             }
  3112.  
  3113.             [style*="--audio-only-thumbnail-image"]{
  3114.                 background-image: var(--audio-only-thumbnail-image);
  3115.                 object-fit: contain;
  3116.                 background-position: center;
  3117.                 background-size: contain;
  3118.                 background-repeat: no-repeat;
  3119.             }
  3120.             .html5-video-player.ended-mode [style*="--audio-only-thumbnail-image"]{
  3121.                 background-image: none;
  3122.             }
  3123.  
  3124.             .html5-video-player.ytp-ce-shown .html5-video-container {
  3125.                 opacity: 0.5;
  3126.                 transition: opacity 0.5s;
  3127.             }
  3128.  
  3129.             ytd-video-preview #media-container div#player-container,
  3130.             ytd-video-preview #media-container div#thumbnail-container{
  3131.                 transition: initial !important;
  3132.                 transition-duration:0ms !important;
  3133.                 transition-delay:0ms !important;
  3134.             }
  3135.             ytd-video-preview #media-container div#thumbnail-container{
  3136.                 /* pointer-events:none !important; */
  3137.                 opacity:0;
  3138.                 /* z-index:-1; */
  3139.             }
  3140.             ytd-video-preview #media-container div#player-container,
  3141.             ytd-video-preview #media-container div#inline-preview-player{
  3142.                 background-color:transparent !important;
  3143.                 background-image:none !important;
  3144.             }
  3145.  
  3146.             #movie_player > .html5-video-container:not(:empty) {
  3147.                 box-sizing: border-box;
  3148.                 height: 100%;
  3149.             }
  3150.  
  3151.             #movie_player [style*="--audio-only-thumbnail-image"] ~ .ytp-cued-thumbnail-overlay > .ytp-cued-thumbnail-overlay-image[style*="background-image"] {
  3152.                 opacity: 0;
  3153.             }
  3154.  
  3155.             #movie_player [style*="--audio-only-thumbnail-image"]::before {
  3156.                 content: '';
  3157.                 display: block;
  3158.                 position: absolute;
  3159.                 left: 0;
  3160.                 top: 0;
  3161.                 bottom: 0;
  3162.                 right: 0;
  3163.                 /* background: transparent; */
  3164.  
  3165.  
  3166.                 /* We use multiple backgrounds: one gradient per side */
  3167.                 background:
  3168.                     /* Left border gradient */
  3169.                     linear-gradient(to right, rgba(0,0,0,0.4), transparent) left center,
  3170.                     /* Right border gradient */
  3171.                     linear-gradient(to left, rgba(0,0,0,0.4), transparent) right center,
  3172.                     /* Top border gradient */
  3173.                     linear-gradient(to bottom, rgba(0,0,0,0.4), transparent) center top,
  3174.                     /* Bottom border gradient */
  3175.                     linear-gradient(to top, rgba(0,0,0,0.4), transparent) center bottom;
  3176.                     
  3177.                 /* Prevents repetition of gradients */
  3178.                 background-repeat: no-repeat;
  3179.                 
  3180.                 /* Set the size of each gradient "border" */
  3181.                 background-size:
  3182.                     12% 100%, /* left border width and full height */
  3183.                     12% 100%, /* right border width and full height */
  3184.                     100% 12%, /* top border full width and small height */
  3185.                     100% 12%; /* bottom border full width and small height */
  3186.                     
  3187.                 /* Optional: a base background color inside the element */
  3188.                 /* background-color: #fff; */
  3189.                 /* background-color: var(--blinker-fmw83-bgc, transparent); */
  3190.  
  3191.                     opacity: var(--fmw83-opacity, 1);
  3192.  
  3193.                     pointer-events: none !important;
  3194.                     z-index:-1;
  3195.  
  3196.             }
  3197.  
  3198.             /*
  3199.             @keyframes blinker-fmw83 {
  3200.                 0%, 60%, 100% {
  3201.                     opacity: 1;
  3202.                 }
  3203.                 30% {
  3204.                     opacity: 0.96;
  3205.                 }
  3206.             }
  3207.                 */
  3208.                 
  3209.          
  3210.             #movie_player.playing-mode [style*="--audio-only-thumbnail-image"]{
  3211.                 /* animation: blinker-fmw83 1.74s linear infinite; */
  3212.                 --fmw83-opacity: 0.6;
  3213.                 
  3214.             }
  3215.             
  3216.  
  3217.  
  3218.         `: "";
  3219.  
  3220.         const style = document.createElement('style');
  3221.         style.id = 'fm9v0';
  3222.         style.textContent = `
  3223.  
  3224.         ${cssForEnabled}
  3225.  
  3226.         @keyframes mobileMenuItemAppeared {
  3227.             0% {
  3228.                 background-position-x: 3px;
  3229.            }
  3230.             100% {
  3231.                 background-position-x: 4px;
  3232.            }
  3233.        }
  3234.  
  3235.         @keyframes mobileMenuItemAppearedV2 {
  3236.             0% {
  3237.                 background-position-x: 3px;
  3238.            }
  3239.             100% {
  3240.                 background-position-x: 4px;
  3241.            }
  3242.        }
  3243.         ytm-select.player-speed-settings ~ ytm-menu-item:last-of-type {
  3244.             animation: mobileMenuItemAppeared 1ms linear 0s 1 normal forwards;
  3245.        }
  3246.  
  3247.        player-settings-menu > yt-list-item-view-model:last-of-type {
  3248.             animation: mobileMenuItemAppearedV2 1ms linear 0s 1 normal forwards;
  3249.        }
  3250.  
  3251.  
  3252.        player-settings-menu .audio-only-toggle-btn-content {
  3253.             padding: 14px 24px;
  3254.             box-sizing: border-box;
  3255.             font-size: 130%;
  3256.        }
  3257.  
  3258.        player-settings-menu .audio-only-toggle-btn-content2 {
  3259.             padding: 0;
  3260.             box-sizing: border-box;
  3261.             font-size: inherit;
  3262.        }
  3263.  
  3264.  
  3265.         @keyframes contextmenuInfoItemAppeared {
  3266.             0% {
  3267.                 background-position-x: 3px;
  3268.            }
  3269.             100% {
  3270.                 background-position-x: 4px;
  3271.            }
  3272.        }
  3273.         .ytp-contextmenu .ytp-menuitem[role="menuitem"] path[d^="M22 34h4V22h-4v12zm2-30C12.95"]{
  3274.             animation: contextmenuInfoItemAppeared 1ms linear 0s 1 normal forwards;
  3275.        }
  3276.         #confirmDialog794 {
  3277.             z-index:999999 !important;
  3278.             display: none;
  3279.            /* Hidden by default */
  3280.             position: fixed;
  3281.            /* Stay in place */
  3282.             z-index: 1;
  3283.            /* Sit on top */
  3284.             left: 0;
  3285.             top: 0;
  3286.             width: 100%;
  3287.            /* Full width */
  3288.             height: 100%;
  3289.            /* Full height */
  3290.             overflow: auto;
  3291.            /* Enable scroll if needed */
  3292.             background-color: rgba(0,0,0,0.4);
  3293.            /* Black w/ opacity */
  3294.        }
  3295.         #confirmDialog794 .confirm-box {
  3296.             position:relative;
  3297.             color: black;
  3298.             z-index:999999 !important;
  3299.             background-color: #fefefe;
  3300.             margin: 15% auto;
  3301.            /* 15% from the top and centered */
  3302.             padding: 20px;
  3303.             border: 1px solid #888;
  3304.             width: 30%;
  3305.            /* Could be more or less, depending on screen size */
  3306.             box-shadow: 0 4px 8px 0 rgba(0,0,0,0.2);
  3307.        }
  3308.         #confirmDialog794 .confirm-buttons {
  3309.             text-align: right;
  3310.        }
  3311.         #confirmDialog794 button {
  3312.             margin-left: 10px;
  3313.        }
  3314.  
  3315.       `
  3316.         document.head.appendChild(style);
  3317.  
  3318.     });
  3319.  
  3320.  
  3321.     const pNavigateFinished = new Promise(resolve => {
  3322.         document.addEventListener('yt-navigate-finish', resolve, true);
  3323.     });
  3324.  
  3325.     pNavigateFinished.then(() => {
  3326.         const inputs = document.querySelectorAll('#masthead input[type="text"][name]');
  3327.  
  3328.         let lastInputTextValue = null;
  3329.         let busy = false;
  3330.         let disableMonitoring = false;
  3331.         const setGV = async (val)=>{
  3332.  
  3333.             const videoId = getVideoIdByURL() || getVideoIdByElement();
  3334.             if (videoId) {
  3335.                 const cgv = await GM.getValue(`isEnable_aWsjF_${videoId}`, null);
  3336.                 if (cgv !== val || isEnable !== val) {
  3337.                     disableMonitoring = true;
  3338.                     await GM.setValue(`isEnable_aWsjF_${videoId}`, val);
  3339.                     await GM.setValue('lastCheck_bWsm5', Date.now());
  3340.                     document.documentElement.setAttribute('forceRefresh032', '');
  3341.                     location.reload();
  3342.                 }
  3343.  
  3344.             }
  3345.         }
  3346.         const checkTextChangeF = async (evt) => {
  3347.             busy = false;
  3348.             const inputElem = (evt || 0).target;
  3349.             if (inputElem instanceof HTMLInputElement && !disableMonitoring) {
  3350.                 const cv = inputElem.value;
  3351.                 if (cv === lastInputTextValue) return;
  3352.                 lastInputTextValue = cv;
  3353.                 if (cv === 'vvv') {
  3354.  
  3355.                     await setGV(false);
  3356.  
  3357.                 } else if (cv === 'aaa') {
  3358.  
  3359.                     await setGV(true);
  3360.  
  3361.                 }
  3362.             }
  3363.         }
  3364.         const checkTextChange = (evt) => {
  3365.             if (busy) return;
  3366.             busy = true;
  3367.             Promise.resolve(evt).then(checkTextChangeF)
  3368.         };
  3369.         for (const input of inputs) {
  3370.             input.addEventListener('input', checkTextChange, false);
  3371.             input.addEventListener('keydown', checkTextChange, false);
  3372.             input.addEventListener('keyup', checkTextChange, false);
  3373.             input.addEventListener('keypress', checkTextChange, false);
  3374.             input.addEventListener('change', checkTextChange, false);
  3375.         }
  3376.     });
  3377.  
  3378.     const autoCleanUpKey = async () => {
  3379.  
  3380.         const lastCheck = await GM.getValue('lastCheck_bWsm5', null) || 0;
  3381.         if (Date.now() - lastCheck < 16000) return; // 16s
  3382.         GM.setValue('lastCheck_bWsm5', Date.now());
  3383.         pLoad.then(async () => {
  3384.             const rArr = [];
  3385.             const arr = await GM.listValues();
  3386.             const cv = await GM.getValue("isEnable_aWsjF", null);
  3387.             const fn = async (entry) => {
  3388.                 try {
  3389.                     if (typeof entry === 'string' && entry.length > 15 && entry.startsWith('isEnable_aWsjF_')) {
  3390.                         const res = await GM.getValue(entry, null);
  3391.                         if (typeof res === 'boolean' && res === cv) {
  3392.                             await GM.deleteValue(entry);
  3393.                             rArr.push(entry);
  3394.                         }
  3395.                     }
  3396.                 } catch (e) {
  3397.                     console.warn(e);
  3398.                 }
  3399.             }
  3400.             arr.length > 1 && (await Promise.all(arr.map(fn)));
  3401.             rArr.length > 0 && console.log('[YouTube Audio Only] autoCleanUpKey', rArr);
  3402.         });
  3403.     };
  3404.  
  3405.     autoCleanUpKey();
  3406.  
  3407.  
  3408. })();
  3409.  
  3410.