☰

YouTube JS Engine Tamer

To enhance YouTube performance by modifying YouTube JS Engine

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

  1. // ==UserScript==
  2. // @name        YouTube JS Engine Tamer
  3. // @namespace   UserScripts
  4. // @match       https://www.youtube.com/*
  5. // @version     0.16.12
  6. // @license     MIT
  7. // @author      CY Fung
  8. // @icon        https://raw.githubusercontent.com/cyfung1031/userscript-supports/main/icons/yt-engine.png
  9. // @description To enhance YouTube performance by modifying YouTube JS Engine
  10. // @grant       none
  11. // @require     https://cdn.jsdelivr.net/gh/cyfung1031/userscript-supports@7221a4efffd49d852de0074ec503d4febb99f28b/library/nextBrowserTick.min.js
  12. // @run-at      document-start
  13. // @unwrap
  14. // @inject-into page
  15. // @allFrames   true
  16. // ==/UserScript==
  17.  
  18. (() => {
  19.  
  20.   const WeakMap = window.WeakMapOriginal || window.WeakMap;
  21.  
  22.   const NATIVE_CANVAS_ANIMATION = false; // for #cinematics
  23.   const FIX_schedulerInstanceInstance = 2 | 4;
  24.   const FIX_yt_player = true; // DONT CHANGE
  25.   const FIX_Animation_n_timeline = true;
  26.   const NO_PRELOAD_GENERATE_204 = false;
  27.   const ENABLE_COMPUTEDSTYLE_CACHE = true;
  28.   const NO_SCHEDULING_DUE_TO_COMPUTEDSTYLE = true;
  29.   const CHANGE_appendChild = true; // discussions#236759
  30.   const FIX_bind_self_this = false;　// EXPERIMENTAL !!!!! this affect page switch after live ends
  31.   const FIX_weakMap_weakRef = false; // EXPERIMENTAL !!!!! Might Incompatible to some userscripts (as the strong relationship is removed)
  32.  
  33.   const FIX_error_many_stack = true; // should be a bug caused by uBlock Origin
  34.   // const FIX_error_many_stack_keepAliveDuration = 200; // ms
  35.   // const FIX_error_many_stack_keepAliveDuration_check_if_n_larger_than = 8;
  36.  
  37.   const FIX_Iframe_NULL_SRC = false;
  38.  
  39.   const IGNORE_bindAnimationForCustomEffect = true; // prevent `v.bindAnimationForCustomEffect(this);` being executed
  40.  
  41.   const FIX_ytdExpander_childrenChanged = true;
  42.   const FIX_paper_ripple_animate = true;
  43.   const FIX_avoid_incorrect_video_meta = true; // omit the incorrect yt-animated-rolling-number
  44.   const FIX_avoid_incorrect_video_meta_emitterBehavior = true;
  45.  
  46.   const FIX_doIdomRender = true;
  47.  
  48.   const FIX_Shady = true;
  49.  
  50.   // [[ 2024.04.24 ]]
  51.   const MODIFY_ShadyDOM_OBJ = true;
  52.   // << if MODIFY_ShadyDOM_OBJ >>
  53.   const WEAKREF_ShadyDOM = true;
  54.   const OMIT_ShadyDOM_EXPERIMENTAL = 1 | 0; // 1 => enable; 2 => composedPath
  55.   const OMIT_ShadyDOM_settings = 0 | 0 | 0; // 1: inUse; 2: handlesDynamicScoping; 4: force // {{ PRELIM TESTING PURPOSE }}
  56.   // << end >>
  57.  
  58.   const WEAK_REF_BINDING_CONTROL = 1 | 2; // 2 - conflict control with ShadyDOM weakref
  59.  
  60.   const FIX_ytAction_ = true; // ytd-app
  61.   const FIX_onVideoDataChange = false;
  62.   // const FIX_onClick = true;
  63.   const FIX_onStateChange = true;
  64.   const FIX_onLoopRangeChange = true;
  65.   // const FIX_maybeUpdateFlexibleMenu = true; // ytd-menu-renderer
  66.   const FIX_VideoEVENTS_v2 = true; // true might cause bug in switching page
  67.  
  68.   const SCRIPTLET_NOFIX_setTimeout = true;
  69.   const ENABLE_discreteTasking = true;
  70.   // << if ENABLE_discreteTasking >>
  71.   const FIX_stampDomArray_stableList = true;
  72.   const ENABLE_weakenStampReferences = true; // disabled in old browsers
  73.   // << end >>
  74.  
  75.   const FIX_perfNow = true; // history state issue; see https://bugzilla.mozilla.org/show_bug.cgi?id=1756970
  76.   const ENABLE_ASYNC_DISPATCHEVENT = false; // problematic
  77.  
  78.   const UNLOAD_DETACHED_POLYMER = false; // unstable
  79.   const FIX_Polymer_dom = true;
  80.  
  81.   const WEAK_REF_BINDING = false; // false if your browser is slow // disabled due to memory leakage
  82.   // << if WEAK_REF_BINDING >>
  83.   const WEAK_REF_PROXY_DOLLAR = true; // false if your browser is slow
  84.   // << end >>
  85.  
  86.   const SCRIPTLET_REMOVE_PRUNE_propNeedles = true; // brave scriptlet related
  87.   const DEBUG_removePrune = false; // true for DEBUG
  88.  
  89.   const FIX_XHR_REQUESTING = true;
  90.   const FIX_VIDEO_BLOCKING = false; // usually it is a ads block issue // disabled due to memory leakage
  91.  
  92.   const LOG_FETCHMETA_UPDATE = false; // for DEBUG
  93.  
  94.   const IGNORE_bufferhealth_CHECK = false; // experimental; true will make "Stats for nerds" no info.
  95.  
  96.   const DENY_requestStorageAccess = true; // remove document.requestStorageAccess
  97.   const DISABLE_IFRAME_requestStorageAccess = true; // no effect if DENY_requestStorageAccess is true
  98.  
  99.   const DISABLE_COOLDOWN_SCROLLING = true; // YT cause scroll hang in MacOS
  100.  
  101.   const FIX_removeChild = true;
  102.  
  103.   // ----------------------------- Shortkey Keyboard Control -----------------------------
  104.   // dependency: FIX_yt_player
  105.  
  106.   const FIX_SHORTCUTKEYS = 2; // 0 - no fix; 1 - basic fix; 2 - advanced fix
  107.   // [0] no fix - not recommended
  108.   // [1] basic fix - just fix the global focus detection variable
  109.   // [2] advanced fix - call the shortcut actions directly, auto foucs change, direct control of spacebar behavior, etc
  110.   // (note) 0 or 1 if you find conflict with other userscripts/plugin
  111.  
  112.   const CHANGE_SPEEDMASTER_SPACEBAR_CONTROL = 0; // 0 - disable; 1 - force true; 2 - force false
  113.   const USE_IMPROVED_PAUSERESUME_UNDER_NO_SPEEDMASTER = true; // only for SPEEDMASTER = false & FIX_SHORTCUTKEYS = 2
  114.  
  115.   const PROP_OverReInclusion_AVOID = true;
  116.   const PROP_OverReInclusion_DEBUGLOG = false;
  117.   const PROP_OverReInclusion_LIST = new Set([
  118.     'hostElement72',
  119.     'parentComponent72',
  120.     'localVisibilityObserver_72',
  121.     'cachedProviderNode_72',
  122.     '__template72',
  123.     '__templatizeOwner72',
  124.     '__templateInfo72',
  125.     '__dataHost72',
  126.     '__CE_shadowRoot72',
  127.     'elements_72',
  128.  
  129.     'ky36',
  130.     'kz62',
  131.     'm822',
  132.  
  133.  
  134.  
  135.     // To be reviewed.
  136.  
  137.     // chat messages
  138.     'disabled', 'allowedProps',
  139.     'filledButtonOverrides', 'openPopupConfig', 'supportsInlineActionButtons', 'allowedProps',
  140.  
  141.     'dimension', 'loadTime', 'pendingPaint',
  142.  
  143.     'countdownDurationMs', 'countdownMs', 'lastCountdownTimeMs', 'rafId', 'playerProgressSec', 'detlaSincePausedSecs', 'behaviorActionMap', 'selected', 'maxLikeCount', 'maxReplyCount', 'isMouseOver',
  144.  
  145.     'respectLangDir', 'noEndpoints',
  146.  
  147.  
  148.     'objectURL',
  149.     'buttonOverrides', 'queuedMessages',
  150.     'STEP', 'BLOCK_ON', 'MIN_PROGESS', 'MAX_PROGESS',
  151.     'DISMISSED_CONTENT_KEYSPACE', 'followUpDialogPromise', 'followUpDialogPromiseResolve', 'followUpDialogPromiseReject',
  152.     'hoverJobId', 'JSC$14573_touched',
  153.  
  154.  
  155.     // tbc
  156.     'toggleable', 'isConnected',
  157.     'scrollDistance', 'dragging', 'dragMouseStart', 'dragOffsetStart', 'containerWidthDiff',
  158.     'disableDeselectEvent',
  159.     'emojiSize',
  160.  
  161.     'buttonOverride',
  162.     'shouldUseStickyPreferences', 'longPressTimeoutId',
  163.  
  164.     // others
  165.     'observeVisibleOption', 'observeHiddenOption', 'observePrescanOption', 'visibilityMonitorKeys',
  166.     // 'filledButtonOverrides', 'openPopupConfig', 'supportsInlineActionButtons',
  167.     'observeVisibleOption', 'observeHiddenOption', 'observePrescanOption', 'visibilityMonitorKeys',
  168.     //  'dimension', 'loadTime', 'pendingPaint',
  169.     //  'disabled', 'allowedProps',
  170.  
  171.  
  172.     // 'enableMssLazyLoad', 'popupContainerConfig', 'actionRouterNode', 'actionRouterIsRoot', 'actionMap', 'dynamicActionMap',
  173.     // 'actionMap',
  174.  
  175.     // 'sharedTooltipPosition', 'sharedTooltipAnimationDelay', 'disableEmojiPickerIncrementalLoading', 'useResolveCommand', 'activeRequest', 'popoutWindowCheckIntervalId', 'supportedTooltipTargets', 'closeActionPanelTimerId', 'delayCloseActionPanelTimerId', 'tooltipTimerIds', 'queuedTooltips', 'isPopupConfigReady', 'popoutWindow', 'actionMap',
  176.  
  177.     'clearTimeout',
  178.     'switchTemplateAtRegistration', 'hasUnmounted',
  179.     'switchTemplateAtRegistration', 'stopKeyboardEventPropagation',
  180.     'tangoConfiguration',
  181.     'itemIdToDockDurationMap',
  182.     'actionMap',
  183.  
  184.     'emojiManager', 'inputMethodEditorActive', 'suggestionIndex', 'JSC$10745_lastSuggestionRange',
  185.     'actionMap', 'asyncHandle', 'shouldAnimateIn', 'lastFrameTimestamp', 'scrollClampRaf',
  186.     'scrollRatePixelsPerSecond', 'scrollStartTime', 'scrollStopHandle'
  187.  
  188.     // 'buttonOverrides', 'queuedMessages', 'clearTimeout', 'actionMap',
  189.     // 'stopKeyboardEventPropagation', 'emojiSize',
  190.     // 'switchTemplateAtRegistration', 'hasUnmounted',
  191.     // 'buttonOverrides', 'queuedMessages', 'clearTimeout', 'actionMap',
  192.     // 'isReusable', 'tangoConfiguration',
  193.     // 'itemIdToDockDurationMap', 'bottomAlignMessages', 'actionMap',
  194.     // */
  195.  
  196.   ]);
  197.  
  198.  
  199.   // const CAN_TUNE_VOLUMN_AFTER_RESUME_OR_PAUSE = false; // NO USE; TO BE REVIEWED
  200.  
  201.   // ----------------------------- Shortkey Keyboard Control -----------------------------
  202.  
  203.   /*
  204.     window.addEventListener('edm',()=>{
  205.       let p = [...this.onerror.errorTokens][0].token; (()=>{ console.log(p); throw new Error(p);console.log(334,p) })()
  206.     });
  207.  
  208.     window.addEventListener('edn',()=>{
  209.       let p = [...this.onerror.errorTokens][0].token+"X"; (()=>{ console.log(p); throw new Error(p);console.log(334,p) })()
  210.     });
  211.     window.addEventListener('edr',()=>{
  212.       let p = '123'; (()=>{ console.log(p); throw new Error(p);console.log(334,p) })()
  213.     });
  214.   */
  215.  
  216.   // only for macOS with Chrome/Firefox 100+
  217.   const advanceLogging = typeof AbortSignal !== 'undefined' && typeof (AbortSignal || 0).timeout === 'function' && typeof navigator !== 'undefined' && /\b(Macintosh|Mac\s*OS)\b/i.test((navigator || 0).userAgent || '');
  218.  
  219.   const win = this instanceof Window ? this : window;
  220.  
  221.   // Create a unique key for the script and check if it is already running
  222.   const hkey_script = 'jswylcojvzts';
  223.   if (win[hkey_script]) throw new Error('Duplicated Userscript Calling'); // avoid duplicated scripting
  224.   win[hkey_script] = true;
  225.  
  226.  
  227.  
  228.   let BY_PASS_KEYBOARD_CONTROL = false;
  229.  
  230.  
  231.   // const setImmediate = ((self || 0).jmt || 0).setImmediate;
  232.   /** @type {(f: ()=>{})=>{}} */
  233.   const nextBrowserTick = (self || 0).nextBrowserTick || 0;
  234.   const nextBrowserTick_ = nextBrowserTick || (f => f());
  235.  
  236.   let p59 = 0;
  237.  
  238.   const Promise = (async () => { })().constructor;
  239.  
  240.   const PromiseExternal = ((resolve_, reject_) => {
  241.     const h = (resolve, reject) => { resolve_ = resolve; reject_ = reject };
  242.     return class PromiseExternal extends Promise {
  243.       constructor(cb = h) {
  244.         super(cb);
  245.         if (cb === h) {
  246.           /** @type {(value: any) => void} */
  247.           this.resolve = resolve_;
  248.           /** @type {(reason?: any) => void} */
  249.           this.reject = reject_;
  250.         }
  251.       }
  252.     };
  253.   })();
  254.  
  255.   /**
  256.     @param {number} x
  257.     @param {number} d */
  258.   const toFixed2 = (x, d) => {
  259.     let t = x.toFixed(d);
  260.     let y = `${+t}`;
  261.     return y.length > t.length ? t : y;
  262.   }
  263.  
  264.  
  265.   let pf31 = new PromiseExternal();
  266.  
  267.   // native RAF
  268.   let __requestAnimationFrame__ = typeof webkitRequestAnimationFrame === 'function' ? window.webkitRequestAnimationFrame.bind(window) : window.requestAnimationFrame.bind(window);
  269.  
  270.   // 1st wrapped RAF
  271.   const baseRAF = (callback) => {
  272.     return p59 ? __requestAnimationFrame__(callback) : __requestAnimationFrame__((hRes) => {
  273.       pf31.then(() => {
  274.         callback(hRes);
  275.       });
  276.     });
  277.   };
  278.  
  279.   // 2nd wrapped RAF
  280.   window.requestAnimationFrame = baseRAF;
  281.  
  282.   const insp = o => o ? (o.polymerController || o.inst || o || 0) : (o || 0);
  283.   const indr = o => insp(o).$ || o.$ || 0;
  284.  
  285.   const prototypeInherit = (d, b) => {
  286.     const m = Object.getOwnPropertyDescriptors(b);
  287.     for (const p in m) {
  288.       if (!Object.getOwnPropertyDescriptor(d, p)) {
  289.         Object.defineProperty(d, p, m[p]);
  290.       }
  291.     }
  292.   };
  293.  
  294.   /** @type {(o: Object | null) => WeakRef | null} */
  295.   const mWeakRef = typeof WeakRef === 'function' ? (o => o ? new WeakRef(o) : null) : (o => o || null);
  296.  
  297.   /** @type {(wr: Object | null) => Object | null} */
  298.   const kRef = (wr => (wr && wr.deref) ? wr.deref() : wr);
  299.  
  300.   if (typeof Document.prototype.requestStorageAccessFor === 'function') {
  301.     if (DENY_requestStorageAccess) {
  302.       // https://developer.mozilla.org/en-US/docs/Web/API/Document/requestStorageAccessFor
  303.       Document.prototype.requestStorageAccessFor = undefined;
  304.       console.log('[yt-js-engine-tamer]', 'requestStorageAccessFor is removed.');
  305.     } else if (DISABLE_IFRAME_requestStorageAccess && window !== top) {
  306.       Document.prototype.requestStorageAccessFor = function () {
  307.         return new Promise((resolve, reject) => {
  308.           reject();
  309.         });
  310.       };
  311.     }
  312.   }
  313.  
  314.   if (FIX_bind_self_this && !Function.prototype.bind488 && !Function.prototype.bind588) {
  315.     // window.m3bb = new Set();
  316.  
  317.     // const smb = Symbol();
  318.     const vmb = 'dtz02' // Symbol(); // return kThis for thisArg
  319.     const vmc = 'dtz04' // Symbol(); // whether it is proxied fn
  320.     const vmd = 'dtz08' // Symbol(); // self fn proxy (fn--fn)
  321.  
  322.     // const fnProxySelf = function (...args) {
  323.     //   if (args[0] === smb) return this;
  324.     //   const cnt = kRef(this.ref);
  325.     //   if (cnt) {
  326.     //     if (typeof cnt[this.prop] !== 'function') console.error(`this.${this.prop} is not a function. [${cnt.is || 'nil'}]`)
  327.     //     return cnt[this.prop](...args); // might throw error
  328.     //   }
  329.     // }
  330.     // fnProxySelf.bind588 = fnProxySelf.bind;
  331.     // const pFnHandler = {
  332.     //   get(target, prop){
  333.     //     if(prop === 'bind588') return 2;
  334.     //     const fnThis = target(smb);
  335.     //     if (fnThis && fnThis.prop && fnThis.ref) {
  336.     //       const cnt = kRef(fnThis.ref || null) || null;
  337.     //       if (cnt) {
  338.     //         const h = cnt[fnThis.prop];
  339.     //         const v = h[prop];
  340.     //         if (typeof v === 'function'){
  341.     //           if(typeof h === 'function'){
  342.     //             if (prop === 'call' || prop === 'bind' || prop === 'bind588' || prop === 'bind488' || prop === 'apply') {
  343.     //               if(h.bind588 === 1){
  344.     //                 const g = function(...args){
  345.     //                   console.log(1288, this)
  346.     //                   return h.call(this, ...args);
  347.     //                 };
  348.     //                 console.log(399, g)
  349.     //                 return g[prop];
  350.     //                 // console.log(12778)
  351.     //                 // console.log(target, target.call)
  352.     //                 // return target[prop];
  353.     //               }
  354.     //               // independent of this
  355.     //               return v; // function.bind, function.call, function.apply
  356.     //             }
  357.     //           }
  358.     //           console.warn('cnt[fnThis.prop][prop] is function; might rely on this', { prop, fProp: fnThis.prop, is: cnt.is, h: h });
  359.               
  360.     //           // return new Proxy(fnProxySelf.bind588({ prop: prop, ref: new WeakRef(cnt[fnThis.prop]) }), pFnHandler);
  361.     //         } 
  362.     //         return v;
  363.     //       }
  364.     //     }
  365.     //   },
  366.     //   set(target, prop, value) {
  367.     //     const fnThis = target(smb);
  368.     //     if (fnThis && fnThis.prop && fnThis.ref) {
  369.     //       const cnt = kRef(fnThis.ref || null) || null;
  370.     //       if (cnt) {
  371.     //         const h = cnt[fnThis.prop];
  372.     //         if (h) {
  373.     //           h[prop] = value;
  374.     //         } else {
  375.     //           console.log('h is nout found', { prop, fProp: fnThis.prop, is: cnt.is, h: h });
  376.     //         }
  377.     //       }
  378.     //     }
  379.     //     return true;
  380.     //   }
  381.     // };
  382.  
  383.     const thisConversionFn = (thisArg) => {
  384.       if (!thisArg) return null;
  385.       const kThis = thisArg[vmb];
  386.       if (kThis) {
  387.         const ref = kThis.ref;
  388.         return (ref ? kRef(ref) : null) || null;
  389.       }
  390.       return thisArg;
  391.     }
  392.  
  393.     const pFnHandler2 = {
  394.       get(target, prop) {
  395.         if (prop === vmc) return target;
  396.         return Reflect.get(target, prop);
  397.       },
  398.       apply(target, thisArg, argumentsList) {
  399.         thisArg = thisConversionFn(thisArg);
  400.         if (thisArg) return Reflect.apply(target, thisArg, argumentsList);
  401.       }
  402.     }
  403.  
  404.     
  405.     const proxySelfHandler = {
  406.       get(target, prop) {
  407.         if(prop === vmb) return target;
  408.         const ref = target.ref;
  409.         const cnt = kRef(ref);
  410.         if (!cnt) return;
  411.         if (typeof cnt[prop] === 'function' && !cnt[prop][vmc] && !cnt[prop][vmb]) {
  412.           if (!cnt[prop][vmd]) cnt[prop][vmd] = new Proxy(cnt[prop], pFnHandler2);
  413.           return cnt[prop][vmd];
  414.         }
  415.         return cnt[prop];
  416.       },
  417.       set(target, prop, value) {
  418.         const cnt = kRef(target.ref);
  419.         if (!cnt) return true;
  420.         if(value && (value[vmc] || value[vmb])){
  421.           cnt[prop] = value[vmc] || thisConversionFn(value);
  422.           return true;
  423.         }
  424.         cnt[prop] = value;
  425.         return true;
  426.       }
  427.     };
  428.  
  429.     const weakWrap = (thisArg) => {
  430.       thisArg = thisConversionFn(thisArg);
  431.       if (!thisArg) {
  432.         console.error('thisArg is not found');
  433.         return null;
  434.       }
  435.       return new Proxy({ ref: mWeakRef(thisArg) }, proxySelfHandler);
  436.     }
  437.  
  438.     if (!window.getComputedStyle533 && typeof window.getComputedStyle === 'function') {
  439.       window.getComputedStyle533 = window.getComputedStyle;
  440.       window.getComputedStyle = function (a, ...args) {
  441.         a = thisConversionFn(a);
  442.         if (a) {
  443.           return getComputedStyle533(a, ...args);
  444.         }
  445.         return null;
  446.       }
  447.     }
  448.  
  449.     Function._count_bind_00 = 0;
  450.     // Function._count_bind_01 = 0;
  451.  
  452.     // let matchNativeCode = (Object+"");
  453.     // let matchNativeCode1 = matchNativeCode.includes("[native code]");
  454.     // let matchNativeLen = matchNativeCode.length  - Object.name.length;
  455.  
  456.     // const matchConstructor = (thisArg) => {
  457.     //   const f = (thisArg || 0).constructor + "";
  458.     //   if (f.length > 45) return true;
  459.     //   if (matchNativeCode1 && f.length - thisArg.constructor.name.length === matchNativeLen) {
  460.     //     if (f.includes('[native code]')){
  461.     //       return false;
  462.     //     } 
  463.     //     return true;
  464.     //   }
  465.     //   return false;
  466.     // }
  467.  
  468.     // const acceptThis = (thisArg)=>{
  469.     //   // if(!thisArg || typeof thisArg !=='object') return false;
  470.     //   // // if((((thisArg||0).constructor||0).name || 'XXXXXXXX').length < 3) return true;
  471.     //   // if(typeof thisArg.path === 'string') return true;
  472.     //   // if(typeof thisArg.fn === 'function') return true;
  473.     //   // if(typeof thisArg.id === 'string') return true;
  474.     //   // if(typeof thisArg.isLoaded === 'boolean') return true;
  475.     //   return false;
  476.     // }
  477.  
  478.     const patchFn = (fn) => {
  479.  
  480.       let s = `${fn}`;
  481.       if (s.length < 11 || s.includes('\n')) return false;
  482.       if(s.includes('bind(this')) return true;
  483.       if(s.includes('=this') && /[,\s][a-zA-Z_][a-zA-Z0-9_]*=this[;,]/.test(s) ) return true;
  484.       // var a=this;
  485.       // f.bind(this)
  486.  
  487.  
  488.       return false;
  489.     }
  490.  
  491.     Function.prototype.bind488 = Function.prototype.bind;
  492.     Function.prototype.bind = function(thisArg, ...args){
  493.   
  494.       if (thisConversionFn(thisArg) !== thisArg) {
  495.         return this.bind488(thisArg, ...args);
  496.       }
  497.       if( thisArg && patchFn(this) ){
  498.  
  499.         // console.log(599,`${this}`)
  500.  
  501.         try {
  502.           // let b1 = thisArg && typeof thisArg === 'object' && typeof thisArg.isAttached === 'boolean' && !thisArg.dtz06; // ready cnt
  503.           // let b2 = !b1 && thisArg && (thisArg instanceof Node) && typeof thisArg.nodeName === 'string' && !thisArg.dtz06; // dom
  504.           // let b3 = !b1 && !b2 && thisArg && typeof thisArg === 'object' && typeof thisArg.is === 'string' && !thisArg.dtz06; // init stage ?
  505.           // // let b4 = !b1 && !b2 && !b3 && thisArg && typeof thisArg === 'object' && !thisArg.dtz06 && matchConstructor(thisArg);
  506.           // // let b5 = !b1 && !b2 && !b3 && !b4 && thisArg && typeof thisArg === 'object' && !thisArg.dtz06 && acceptThis(thisArg);
  507.           // // let b5 = !b1 && !b2 && !b3 && thisArg && typeof thisArg === 'object' && !thisArg.dtz06  && !(thisArg instanceof Window);
  508.           // // let b4 = false;
  509.           // let b4 =  !b1 && !b2 && !b3 && thisArg && !thisArg.dtz06;
  510.   
  511.           // // b3 = false;
  512.           // // b4 = false;
  513.           // // b5 = false;
  514.   
  515.           // if (b1 || b2 || b3 ||b4  ) {
  516.             const f = this;
  517.             const ps = thisArg.__proxySelf0__ || (thisArg.__proxySelf0__ = weakWrap(thisArg));
  518.             if (ps && ps[vmb]) {
  519.               Function._count_bind_00++;
  520.               return f.bind488(ps, ...args)
  521.             }
  522.           // }
  523.         } catch (e) {
  524.           console.warn(e)
  525.          }
  526.       }
  527.       return this.bind488(thisArg, ...args);
  528.     }
  529.     Function.prototype.bind588 = 1;
  530.   }
  531.  
  532.  
  533.   if (FIX_weakMap_weakRef && !window.WeakMapOriginal && typeof window.WeakMap === 'function' && typeof WeakRef === 'function') {
  534.     const WeakMapOriginal = window.WeakMapOriginal = window.WeakMap;
  535.     const wm6 = new WeakMapOriginal();
  536.  
  537.     const skipW = new WeakSet();
  538.  
  539.  
  540.     window.WeakMap = class WeakMap extends WeakMapOriginal {
  541.       constructor(iterable = undefined) {
  542.         super();
  543.         if (iterable && iterable[Symbol.iterator]) {
  544.           for (const entry of iterable) {
  545.             entry && this.set(entry[0], entry[1]);
  546.           }
  547.         }
  548.       }
  549.       delete(a) {
  550.         if (!this.has(a)) return false;
  551.         super.delete(a);
  552.         return true;
  553.       }
  554.       get(a) {
  555.         const p = super.get(a);
  556.         if (p && typeof p === 'object' && p.deref && !skipW.has(p)) {
  557.           let v = kRef(p);
  558.           if (!v) {
  559.             super.delete(a);
  560.           }
  561.           return v || undefined;
  562.         }
  563.         return p;
  564.       }
  565.       has(a) {
  566.         if (!super.has(a)) return false;
  567.         const p = super.get(a);
  568.         if (p && typeof p === 'object' && p.deref && !skipW.has(p)) {
  569.           if (!kRef(p)) {
  570.             super.delete(a);
  571.             return false;
  572.           }
  573.         }
  574.         return true;
  575.       }
  576.       set(a, b) {
  577.         let wq = b;
  578.         if (b && (typeof b === 'function' || typeof b === 'object')) {
  579.           if (b.deref) {
  580.             skipW.add(b);
  581.             wq = b;
  582.           } else {
  583.             wq = wm6.get(b);
  584.             if (!wq) {
  585.               wq = mWeakRef(b);
  586.               wm6.set(b, wq);
  587.             }
  588.           }
  589.         }
  590.         super.set(a, wq);
  591.         return this;
  592.       }
  593.     }
  594.     Object.defineProperty(window.WeakMap, Symbol.toStringTag, {
  595.       configurable: true,
  596.       enumerable: false,
  597.       value: "WeakMap",
  598.       writable: false
  599.     });
  600.   }
  601.  
  602.   const isWatchPageURL = (url) => {
  603.     url = url || location;
  604.     return location.pathname === '/watch' || location.pathname.startsWith('/live/')
  605.   };
  606.  
  607.   const isCustomElementsProvided = typeof customElements !== "undefined" && typeof (customElements || 0).whenDefined === "function";
  608.  
  609.   const promiseForCustomYtElementsReady = isCustomElementsProvided ? Promise.resolve(0) : new Promise((callback) => {
  610.     const EVENT_KEY_ON_REGISTRY_READY = "ytI-ce-registry-created";
  611.     if (typeof customElements === 'undefined') {
  612.       if (!('__CE_registry' in document)) {
  613.         // https://github.com/webcomponents/polyfills/
  614.         Object.defineProperty(document, '__CE_registry', {
  615.           get() {
  616.             // return undefined
  617.           },
  618.           set(nv) {
  619.             if (typeof nv == 'object') {
  620.               delete this.__CE_registry;
  621.               this.__CE_registry = nv;
  622.               this.dispatchEvent(new CustomEvent(EVENT_KEY_ON_REGISTRY_READY));
  623.             }
  624.             return true;
  625.           },
  626.           enumerable: false,
  627.           configurable: true
  628.         })
  629.       }
  630.       let eventHandler = (evt) => {
  631.         document.removeEventListener(EVENT_KEY_ON_REGISTRY_READY, eventHandler, false);
  632.         const f = callback;
  633.         callback = null;
  634.         eventHandler = null;
  635.         f();
  636.       };
  637.       document.addEventListener(EVENT_KEY_ON_REGISTRY_READY, eventHandler, false);
  638.     } else {
  639.       callback();
  640.     }
  641.   });
  642.  
  643.   const whenCEDefined = isCustomElementsProvided
  644.     ? (nodeName) => customElements.whenDefined(nodeName)
  645.     : (nodeName) => promiseForCustomYtElementsReady.then(() => customElements.whenDefined(nodeName));
  646.  
  647.   FIX_perfNow && performance.timeOrigin > 9 && (() => {
  648.     if (performance.now23 || performance.now16 || typeof Performance.prototype.now !== 'function') return;
  649.     const f = performance.now23 = Performance.prototype.now;
  650.  
  651.     let k = 0; // 0 <= k < 9998m
  652.     let u = 0;
  653.     let s = ((performance.timeOrigin % 7) + 1) / 7 - 1e-2 / 7; // s > 0.14
  654.  
  655.     // By definition, performance.now() is mono increasing.
  656.     // Fixing in YouTube.com is required to ensure performance.now() is strictly increasing.
  657.     performance.now = performance.now16 = function () {
  658.       /**
  659.        * Bug 1842437 - When attempting to go back on youtube.com, the content remains the same
  660.        *
  661.        * If consecutive session history entries had history.state.entryTime set to same value,
  662.        * back button doesn't work as expected. The entryTime value is coming from performance.now()
  663.        * and modifying its return value slightly to make sure two close consecutive calls don't
  664.        * get the same result helped with resolving the issue.
  665.        */
  666.       // see https://bugzilla.mozilla.org/show_bug.cgi?id=1756970
  667.       // see https://bugzilla.mozilla.org/show_bug.cgi?id=1842437
  668.  
  669.       const v = typeof (this || 0).now23 === 'function' ? this.now23() + s : f.call(performance) + s; // v > 0.14
  670.       if (u + 0.0015 < (u = v)) k = 0; // note: hRes should be accurate to 5 µs in isolated contexts
  671.       else if (k < 0.001428) k += 1e-6 / 7; // M = 10000 * m; m * 9996 = 0.001428
  672.       else { // more than 9998 consecutive calls
  673.         /**
  674.          *
  675.          * max no. of consecutive calls
  676.          *
  677.          * Sample Size: 4800
  678.          * Sample Avg = 1565.375
  679.          * Sample Median = 1469.5
  680.          * Sample Max = 5660 << 7500 << 9999
  681.          *
  682.          *
  683.          *  */
  684.         k = 0;
  685.         s += 1 / 7;
  686.       }
  687.       return v + k; // 0 < v - M < v - M + k < v
  688.     }
  689.  
  690.     let loggerMsg = '';
  691.     if (`${performance.now()}` === `${performance.now()}`) {
  692.       const msg1 = 'performance.now is modified but performance.now() is not strictly increasing.';
  693.       const msg2 = 'performance.now cannot be modified and performance.now() is not strictly increasing.';
  694.       loggerMsg = performance.now !== performance.now16 ? msg1 : msg2; // might not able to set in Firefox
  695.     }
  696.     loggerMsg && console.warn(loggerMsg);
  697.   })();
  698.  
  699.   FIX_removeChild && (() => {
  700.     if (typeof Node.prototype.removeChild === 'function' && typeof Node.prototype.removeChild062 !== 'function') {
  701.       Node.prototype.removeChild062 = Node.prototype.removeChild;
  702.       Node.prototype.removeChild = function (child) {
  703.         if (typeof this.__shady_native_removeChild !== 'function' || ((child instanceof Node) && child.parentNode === this)) {
  704.           this.removeChild062(child);
  705.         } else if ((child instanceof Element) && child.is === 'tp-yt-paper-tooltip') {
  706.           // tooltip bug
  707.         } else {
  708.           console.warn('[yt-js-engine-tamer] Node is not removed from parent', { parent: this, child: child })
  709.         }
  710.         return child;
  711.       }
  712.     }
  713.   })();
  714.  
  715.   // WEAKREF_ShadyDOM
  716.  
  717.   MODIFY_ShadyDOM_OBJ && ((WeakRef) => {
  718.  
  719.     const setupPlainShadyDOM = (b) => {
  720.       (OMIT_ShadyDOM_settings & 1) && (b.inUse === true) && (b.inUse = false);
  721.       (OMIT_ShadyDOM_settings & 2) && (b.handlesDynamicScoping === true) && (b.handlesDynamicScoping = false);
  722.       (OMIT_ShadyDOM_settings & 4) && (b.force === true) && (b.force = false);
  723.       b.patchOnDemand = true;
  724.       b.preferPerformance = true;
  725.       b.noPatch = true;
  726.     }
  727.  
  728.     const isPlainObject = (b, m) => {
  729.       if (!b || typeof b !== 'object') return false;
  730.       const e = Object.getOwnPropertyDescriptors(b);
  731.       if (e.length <= m) return false;
  732.       let pr = 0;
  733.       for (const k in e) {
  734.         const d = e[k];
  735.         if (!d || d.get || d.set || !d.enumerable || !d.configurable) return false;
  736.         if (!('value' in d) || typeof d.value === 'function') return false;
  737.         pr++;
  738.       }
  739.       return pr > m;
  740.     }
  741.  
  742.     let b;
  743.  
  744.     let lz = 0;
  745.  
  746.     const sdp = Object.getOwnPropertyDescriptor(window, 'ShadyDOM');
  747.     if (sdp && sdp.configurable && sdp.value && sdp.enumerable && sdp.writable) {
  748.  
  749.       // Brave - ShadyDOM exists before userscripting
  750.       b = sdp.value;
  751.  
  752.       if (b && typeof b === 'object' && isPlainObject(b, 0)) {
  753.         OMIT_ShadyDOM_EXPERIMENTAL && setupPlainShadyDOM(b);
  754.         lz = 1;
  755.       }
  756.  
  757.     }
  758.  
  759.  
  760.     if (sdp && sdp.configurable && sdp.value && sdp.enumerable && sdp.writable && !sdp.get && !sdp.set) {
  761.     } else if (!sdp) {
  762.     } else {
  763.       console.log(3719, '[yt-js-engine-tamer] FIX::ShadyDOM is not applied [ PropertyDescriptor issue ]', sdp);
  764.       return;
  765.     }
  766.  
  767.     const shadyDOMNodeWRM = new WeakMap();
  768.  
  769.     console.log(3719, '[yt-js-engine-tamer] FIX::ShadyDOM << 01 >>', b);
  770.  
  771.     const weakWrapperNodeHandlerFn = () => ({
  772.       get() {
  773.         let w = shadyDOMNodeWRM.get(this);
  774.         if (typeof w === 'object') w = kRef(w) || (shadyDOMNodeWRM.delete(this), undefined);
  775.         return w;
  776.       },
  777.       set(nv) {
  778.         shadyDOMNodeWRM.set(this, mWeakRef(nv));
  779.         return true;
  780.       },
  781.       enumerable: true,
  782.       configurable: true
  783.     });
  784.  
  785.     function weakWrapper(_ShadyDOM) {
  786.       const ShadyDOM = _ShadyDOM;
  787.       if (WEAKREF_ShadyDOM && lz < 3 && typeof WeakRef === 'function' && typeof ShadyDOM.Wrapper === 'function' && ShadyDOM.Wrapper.length === 1 && typeof (ShadyDOM.Wrapper.prototype || 0) === 'object') {
  788.         let nullElement = { node: null };
  789.         Object.setPrototypeOf(nullElement, Element.prototype);
  790.         let p = new ShadyDOM.Wrapper(nullElement);
  791.         let d = Object.getOwnPropertyDescriptor(p, 'node');
  792.         if (d.configurable && d.enumerable && !d.get && !d.set && d.writable && d.value === nullElement && !Object.getOwnPropertyDescriptor(ShadyDOM.Wrapper.prototype, 'node')) {
  793.           Object.defineProperty(ShadyDOM.Wrapper.prototype, 'node', weakWrapperNodeHandlerFn());
  794.           console.log('[yt-js-engine-tamer] FIX::ShadyDOM << WEAKREF_ShadyDOM >>')
  795.         }
  796.       }
  797.     }
  798.  
  799.     let previousWrapStore = null;
  800.  
  801.     const standardWrap = function (a) {
  802.       if (a instanceof ShadowRoot || a instanceof ShadyDOM.Wrapper) return a;
  803.       if (previousWrapStore) {
  804.         const s = kRef(previousWrapStore.get(a)); // kRef for play safe only
  805.         if (s) {
  806.           previousWrapStore.delete(a);
  807.           shadyDOMNodeWRM.set(a, mWeakRef(s));
  808.         }
  809.       }
  810.       let u = kRef(shadyDOMNodeWRM.get(a));
  811.       if (!u) {
  812.         u = new ShadyDOM.Wrapper(a);
  813.         shadyDOMNodeWRM.set(a, mWeakRef(u));
  814.       }
  815.       return u;
  816.     }
  817.  
  818.  
  819.     function setupWrapFunc(_ShadyDOM) {
  820.       const ShadyDOM = _ShadyDOM;
  821.  
  822.  
  823.       const wmPD = Object.getOwnPropertyDescriptor(WeakMap.prototype, 'get');
  824.       if (!(wmPD && wmPD.writable && !wmPD.enumerable && wmPD.configurable && wmPD.value && !wmPD.get && !wmPD.set)) {
  825.         return;
  826.       }
  827.       let mm = new Set();
  828.       const pget = wmPD.value;
  829.       WeakMap.prototype.get = function (a) {
  830.         mm.add(this);
  831.         return a;
  832.       }
  833.       try {
  834.         let nullElement = { node: null };
  835.         Object.setPrototypeOf(nullElement, Element.prototype);
  836.         ShadyDOM.wrapIfNeeded(nullElement)
  837.         ShadyDOM.wrap(nullElement)
  838.       } catch (e) { }
  839.       WeakMap.prototype.get = pget;
  840.       if (mm.size !== 1) {
  841.         mm.clear();
  842.         return;
  843.       }
  844.       const p = mm.values().next().value;
  845.       if (!(p instanceof WeakMap)) return;
  846.       // p.clear();
  847.       // p.get = function (a) { return a }
  848.       // p.set = function (a, b) { return this }
  849.       // console.log(188, window.n2n = mm, window.n2p = p)
  850.  
  851.       // console.log(34929,p.size)
  852.       previousWrapStore = p;
  853.  
  854.       if (typeof ShadyDOM.wrap === 'function' && ShadyDOM.wrap.length === 1) {
  855.         ShadyDOM.wrap = function (a) { 0 && console.log(3719, '[yt-js-engine-tamer] (OMIT_ShadyDOM) function call - wrap'); return standardWrap(a) }
  856.       }
  857.       if (typeof ShadyDOM.wrapIfNeeded === 'function' && ShadyDOM.wrapIfNeeded.length === 1) {
  858.         ShadyDOM.wrapIfNeeded = function (a) { console.log(3719, '[yt-js-engine-tamer] (OMIT_ShadyDOM) function call - wrapIfNeeded'); return standardWrap(a) }
  859.       }
  860.  
  861.     }
  862.  
  863.     function setupLZ3(nv) {
  864.  
  865.       const ShadyDOM = nv;
  866.  
  867.       const ShadyDOMSettings = ShadyDOM.settings;
  868.       if (!(ShadyDOMSettings.inUse === true && ShadyDOM.inUse === true && (ShadyDOMSettings.handlesDynamicScoping || ShadyDOM.handlesDynamicScoping) === true)) {
  869.         console.log(3719, '[yt-js-engine-tamer] OMIT_ShadyDOM is not applied [02]', window.ShadyDOM);
  870.         return false;
  871.       }
  872.  
  873.       weakWrapper(ShadyDOM);
  874.  
  875.       if (OMIT_ShadyDOM_EXPERIMENTAL && lz < 3) {
  876.  
  877.         setupPlainShadyDOM(ShadyDOMSettings);
  878.         setupPlainShadyDOM(ShadyDOM);
  879.  
  880.         ShadyDOM.isShadyRoot = function () { console.log(3719, '[yt-js-engine-tamer] (OMIT_ShadyDOM) function call - isShadyRoot'); return false; }
  881.  
  882.         setupWrapFunc(ShadyDOM);
  883.         ShadyDOM.patchElementProto = function () { console.log(3719, '[yt-js-engine-tamer] (OMIT_ShadyDOM) function call - patchElementProto') }
  884.         ShadyDOM.patch = function () { console.log(3719, '[yt-js-engine-tamer] (OMIT_ShadyDOM) function call - patch') }
  885.  
  886.         // To be confirmed
  887.         if (OMIT_ShadyDOM_EXPERIMENTAL & 2) {
  888.           ShadyDOM.composedPath = function (e) {
  889.             const t = (e || 0).target || null;
  890.             if (!(t instanceof HTMLElement)) {
  891.               console.log(3719, '[yt-js-engine-tamer] (OMIT_ShadyDOM&2) composedPath', t)
  892.             }
  893.             return t instanceof HTMLElement ? [t] : [];
  894.           };
  895.         }
  896.  
  897.       }
  898.  
  899.     }
  900.  
  901.  
  902.     function setupLZ6(nv) {
  903.  
  904.       const ShadyDOM = nv;
  905.  
  906.       const ShadyDOMSettings = ShadyDOM.settings;
  907.  
  908.       if (!(ShadyDOMSettings.inUse === true && ShadyDOM.inUse === true && (ShadyDOMSettings.handlesDynamicScoping || ShadyDOM.handlesDynamicScoping) === true)) {
  909.         console.log(3719, '[yt-js-engine-tamer] OMIT_ShadyDOM is not applied [02]', window.ShadyDOM);
  910.         return false;
  911.       }
  912.  
  913.       weakWrapper(ShadyDOM);
  914.  
  915.       if (OMIT_ShadyDOM_EXPERIMENTAL && lz < 3) {
  916.  
  917.         setupPlainShadyDOM(ShadyDOMSettings);
  918.         setupPlainShadyDOM(ShadyDOM);
  919.  
  920.         setupWrapFunc(ShadyDOM);
  921.  
  922.       }
  923.  
  924.     }
  925.  
  926.     if (b && typeof b.Wrapper === 'function' && typeof b.settings === 'object' && typeof b.wrap === 'function') {
  927.  
  928.       const nv = b;
  929.  
  930.       if (setupLZ6(nv) === false) return;
  931.  
  932.       lz = 6;
  933.  
  934.       console.log(3719, '[yt-js-engine-tamer] FIX::ShadyDOM << 02b >>', nv)
  935.  
  936.       return;
  937.     }
  938.  
  939.     delete window.ShadyDOM;
  940.  
  941.     Object.defineProperty(window, 'ShadyDOM', {
  942.       get() {
  943.         return b;
  944.       },
  945.       set(nv) {
  946.         let ret = 0;
  947.         try {
  948.           do {
  949.             if (!nv || !nv.settings) {
  950.               if (lz < 1 && nv && typeof nv === 'object' && isPlainObject(nv, 0)) {
  951.                 OMIT_ShadyDOM_EXPERIMENTAL && setupPlainShadyDOM(nv);
  952.                 lz = 1;
  953.                 break;
  954.               } else {
  955.                 console.log(3719, '[yt-js-engine-tamer] FIX::ShadyDOM is not applied [nv:null]', nv);
  956.                 break;
  957.               }
  958.             }
  959.  
  960.             const sdp = Object.getOwnPropertyDescriptor(this || {}, 'ShadyDOM');
  961.             if (!(sdp && sdp.configurable && sdp.get && sdp.set)) {
  962.               console.log(3719, '[yt-js-engine-tamer] OMIT_ShadyDOM is not applied [ incorrect PropertyDescriptor ]', nv);
  963.               break;
  964.             }
  965.  
  966.             if (setupLZ3(nv) === false) break;
  967.  
  968.             lz = 3;
  969.  
  970.             console.log(3719, '[yt-js-engine-tamer] FIX::ShadyDOM << 02a >>', nv)
  971.  
  972.             ret = 1;
  973.  
  974.           } while (0);
  975.         } catch (e) {
  976.           console.log('[yt-js-engine-tamer] FIX::ShadyDOM << ERROR >>', e)
  977.         }
  978.  
  979.         if (!ret) b = nv;
  980.         else {
  981.           delete this.ShadyDOM;
  982.           this.ShadyDOM = nv;
  983.         }
  984.         return true;
  985.       },
  986.       enumerable: false,
  987.       configurable: true
  988.     });
  989.  
  990.   })(typeof WeakRef !== 'undefined' ? WeakRef : function () { });
  991.  
  992.   if (ENABLE_ASYNC_DISPATCHEVENT && nextBrowserTick) {
  993.     const filter = new Set([
  994.       'yt-action',
  995.       // 'iframe-src-replaced',
  996.       'shown-items-changed',
  997.       'can-show-more-changed', 'collapsed-changed',
  998.  
  999.       'yt-navigate', 'yt-navigate-start', 'yt-navigate-cache',
  1000.       'yt-player-updated', 'yt-page-data-fetched', 'yt-page-type-changed', 'yt-page-data-updated',
  1001.       'yt-navigate-finish',
  1002.  
  1003.       // 'data-changed','yt-watch-comments-ready'
  1004.     ])
  1005.     EventTarget.prototype.dispatchEvent938 = EventTarget.prototype.dispatchEvent;
  1006.     EventTarget.prototype.dispatchEvent = function (event) {
  1007.       const type = (event || 0).type;
  1008.       if (typeof type === 'string' && event.isTrusted === false && (event instanceof CustomEvent) && event.cancelable === false) {
  1009.         if (!filter.has(type) && !type.endsWith('-changed')) {
  1010.           if (this instanceof Node || this instanceof Window) {
  1011.             nextBrowserTick(() => this.dispatchEvent938(event));
  1012.             return true;
  1013.           }
  1014.         }
  1015.       }
  1016.       return this.dispatchEvent938(event);
  1017.     }
  1018.   }
  1019.  
  1020.   // avoid REGEXP testPattern execution in Brave's scriptlet for performance boost
  1021.   SCRIPTLET_REMOVE_PRUNE_propNeedles && (() => {
  1022.     // const xhr = new XMLHttpRequest;
  1023.     const pdOri = Object.getOwnPropertyDescriptor(Map.prototype, 'size');
  1024.     if (!pdOri || pdOri.configurable !== true) return;
  1025.     let propNeedles = null;
  1026.     const pdNew = {
  1027.       configurable: true,
  1028.       enumerable: true,
  1029.       get: function () {
  1030.         propNeedles = this;
  1031.         if (DEBUG_removePrune) debugger; // to locate Brave scriptlets
  1032.         throw new Error();
  1033.       }
  1034.     }
  1035.     Object.defineProperty(Map.prototype, 'size', pdNew);
  1036.     try {
  1037.       XMLHttpRequest.prototype.open.call(0);
  1038.       // xhr.open.call(null)
  1039.     } catch (e) { }
  1040.     Object.defineProperty(Map.prototype, 'size', pdOri);
  1041.     if (!propNeedles) return;
  1042.     const entries = [...propNeedles.entries()];
  1043.     propNeedles.clear();
  1044.     console.log('[yt-js-engine-tamer] propNeedles is cleared from scriptlet', entries, propNeedles);
  1045.   })();
  1046.  
  1047.   if (FIX_XHR_REQUESTING) {
  1048.  
  1049.     const URL = window.URL || new Function('return URL')();
  1050.     const createObjectURL = URL.createObjectURL.bind(URL);
  1051.  
  1052.     XMLHttpRequest = (() => {
  1053.       const XMLHttpRequest_ = XMLHttpRequest;
  1054.       if ('__xmMc8__' in XMLHttpRequest_.prototype) return XMLHttpRequest_;
  1055.       const url0 = createObjectURL(new Blob([], { type: 'text/plain' }));
  1056.       const c = class XMLHttpRequest extends XMLHttpRequest_ {
  1057.         constructor(...args) {
  1058.           super(...args);
  1059.         }
  1060.         open(method, url, ...args) {
  1061.           let skip = false;
  1062.           if (!url || typeof url !== 'string') skip = true;
  1063.           else if (typeof url === 'string') {
  1064.             let turl = url[0] === '/' ? `.youtube.com${url}` : `${url}`;
  1065.             if (turl.includes('googleads') || turl.includes('doubleclick.net')) {
  1066.               skip = true;
  1067.             } else if (turl.includes('.youtube.com/pagead/')) {
  1068.               skip = true;
  1069.             } else if (turl.includes('.youtube.com/ptracking')) {
  1070.               skip = true;
  1071.             } else if (turl.includes('.youtube.com/youtubei/v1/log_event?')) {
  1072.               skip = true;
  1073.             } else if (turl.includes('.youtube.com/api/stats/')) { // /api/stats/
  1074.               if (turl.includes('.youtube.com/api/stats/qoe?')) {
  1075.                 skip = true;
  1076.               } else if (turl.includes('.youtube.com/api/stats/ads?')) {
  1077.                 skip = true;
  1078.               } else {
  1079.                 // skip = true; // for user activity logging e.g. watched videos
  1080.               }
  1081.             } else if (turl.includes('play.google.com/log')) {
  1082.               skip = true;
  1083.             } else if (turl.includes('.youtube.com//?')) { // //?cpn=
  1084.               skip = true;
  1085.             }
  1086.           }
  1087.           if (!skip) {
  1088.             this.__xmMc8__ = 1;
  1089.             return super.open(method, url, ...args);
  1090.           } else {
  1091.             this.__xmMc8__ = 2;
  1092.             return super.open('GET', url0);
  1093.           }
  1094.         }
  1095.         send(...args) {
  1096.           if (this.__xmMc8__ === 1) {
  1097.             return super.send(...args);
  1098.           } else if (this.__xmMc8__ === 2) {
  1099.             return super.send();
  1100.           } else {
  1101.             console.log('[yt-js-engine-tamer]', 'xhr warning');
  1102.             return super.send(...args);
  1103.           }
  1104.         }
  1105.       }
  1106.       c.prototype.__xmMc8__ = 0;
  1107.       prototypeInherit(c.prototype, XMLHttpRequest_.prototype);
  1108.       return c;
  1109.     })();
  1110.   }
  1111.  
  1112.   // Alternative HACK -> Tabview Youtube
  1113.   if (DISABLE_COOLDOWN_SCROLLING && typeof EventTarget.prototype.addEventListener52178 !== 'function' && typeof EventTarget.prototype.addEventListener === 'function') {
  1114.  
  1115.     // ---- << this.overscrollConfig HACK >>  -----
  1116.  
  1117.     // 2024.04.19 - Playlist in Single Column Mode cannot be scrolled correctly.
  1118.  
  1119.     /*
  1120.  
  1121.       ;function gZb(a, b) {
  1122.           b = void 0 === b ? !0 : b;
  1123.           a.addEventListener("wheel", hZb);
  1124.           a.overscrollConfig = {
  1125.               cooldown: b
  1126.           }
  1127.       }
  1128.       function iZb(a) {
  1129.           a.overscrollConfig = void 0;
  1130.           a.removeEventListener("wheel", hZb)
  1131.       }
  1132.       function hZb(a) {
  1133.           var b = a.deltaY
  1134.             , c = a.target
  1135.             , d = null;
  1136.           if (window.Polymer && window.Polymer.Element) {
  1137.               if (c = a.path || a.composedPath && a.composedPath()) {
  1138.                   c = g(c);
  1139.                   for (var e = c.next(); !e.done && (e = e.value,
  1140.                   !jZb(e, b)); e = c.next())
  1141.                       if (e.overscrollConfig) {
  1142.                           d = e;
  1143.                           break
  1144.                       }
  1145.               }
  1146.           } else
  1147.               for (; c && !jZb(c, b); ) {
  1148.                   if (c.overscrollConfig) {
  1149.                       d = c;
  1150.                       break
  1151.                   }
  1152.                   c = c.parentElement
  1153.               }
  1154.           d && (b = d.overscrollConfig,
  1155.           b.cooldown ? (d = a.deltaY,
  1156.           c = b.lastDeltaY || 0,
  1157.           b.lastDeltaY = d,
  1158.           e = b.lastStopped || 0,
  1159.           c && e && 0 < c == 0 < d ? Math.abs(c) >= Math.abs(d) ? (d = e + 1200,
  1160.           c = !1) : (d = e + 600,
  1161.           c = !0) : (d = Date.now() + 600,
  1162.           c = !0),
  1163.           d > Date.now() && (a.preventDefault(),
  1164.           c && (b.lastStopped = Date.now()))) : a.preventDefault())
  1165.       }
  1166.     */
  1167.  
  1168.     let wheelHandler = function (a) {
  1169.       if (window.Polymer && window.Polymer.Element) {
  1170.         let c;
  1171.         if (c = a.path || a.composedPath && a.composedPath()) {
  1172.           for (const e of c) {
  1173.             const cnt = insp(e);
  1174.             if (e.overscrollConfig) e.overscrollConfig = void 0;
  1175.             if (cnt.overscrollConfig) cnt.overscrollConfig = void 0;
  1176.           }
  1177.         }
  1178.       } else {
  1179.         let e = a.target;
  1180.         for (; e instanceof Element; e = e.parentElement) {
  1181.           const cnt = insp(e);
  1182.           if (e.overscrollConfig) e.overscrollConfig = void 0;
  1183.           if (cnt.overscrollConfig) cnt.overscrollConfig = void 0;
  1184.         }
  1185.       }
  1186.     };
  1187.  
  1188.     let checkWheelListenerObjs = null;
  1189.  
  1190.     let getObjsFn = () => {
  1191.       let euyVal = 0;
  1192.       const eukElm = {};
  1193.       Object.setPrototypeOf(eukElm, HTMLElement.prototype);
  1194.       const euzObj = new Proxy(eukElm, {
  1195.         get(target, prop) {
  1196.           throw `ErrorF31.get(${prop})`
  1197.         },
  1198.         set(target, prop, value) {
  1199.           throw `ErrorF33.set(${prop}, ${value})`
  1200.         }
  1201.       });
  1202.       const euxElm = new Proxy(eukElm, {
  1203.         get(target, prop) {
  1204.           if (prop === 'scrollTop') {
  1205.             euyVal = euyVal | 8;
  1206.             return 0;
  1207.           }
  1208.           if (prop === 'overscrollConfig') {
  1209.             euyVal = euyVal | 16;
  1210.             return void 0;
  1211.           }
  1212.           if (prop === 'scrollHeight' || prop === 'clientHeight' || prop === 'offsetHeight') {
  1213.             return 640;
  1214.           }
  1215.           if (prop === 'scrollLeft') {
  1216.             euyVal = euyVal | 8;
  1217.             return 0;
  1218.           }
  1219.           if (prop === 'scrollWidth' || prop === 'clientWidth' || prop === 'offsetWidth') {
  1220.             return 800;
  1221.           }
  1222.           throw `ErrorF45.get(${prop})`
  1223.         },
  1224.         set(target, prop, value) {
  1225.           throw `ErrorF47.set(${prop}, ${value})`
  1226.         }
  1227.       });
  1228.       const eukEvt = {};
  1229.       Object.setPrototypeOf(eukEvt, WheelEvent.prototype);
  1230.       const euyEvt = new Proxy(eukEvt, {
  1231.         get(target, prop) {
  1232.           if (prop === 'deltaY' || prop === 'deltaX') {
  1233.             euyVal = euyVal | 1;
  1234.             return -999;
  1235.           }
  1236.           if (prop === 'target') {
  1237.             euyVal = euyVal | 2;
  1238.             return euxElm
  1239.           }
  1240.           if (prop === 'path' || prop === 'composedPath') {
  1241.             euyVal = euyVal | 2;
  1242.             return [euxElm]
  1243.           }
  1244.           throw `ErrorF51.get(${prop})`
  1245.         },
  1246.         set(target, prop, value) {
  1247.           throw `ErrorF53.set(${prop}, ${value})`
  1248.         }
  1249.       });
  1250.       const setVal = (v) => {
  1251.         euyVal = v;
  1252.       }
  1253.       const getVal = () => {
  1254.         return euyVal;
  1255.       }
  1256.       return { euzObj, euyEvt, setVal, getVal };
  1257.     }
  1258.  
  1259.     let checkWheelListener = (callback) => {
  1260.  
  1261.       let callbackIdentifier = '';
  1262.  
  1263.       let res = null;
  1264.       try {
  1265.         const { euzObj, euyEvt, getVal, setVal } = checkWheelListenerObjs || (checkWheelListenerObjs = getObjsFn());
  1266.         setVal(0);
  1267.         if (callback.call(euzObj, euyEvt) !== void 0) throw 'ErrorF99';
  1268.         throw `RESULT${getVal()}`;
  1269.       } catch (e) {
  1270.         res = e;
  1271.       }
  1272.  
  1273.       res = `${res}` || `${null}`;
  1274.       if (res.length > 20) res = `${res.substring(0, 20)}...`;
  1275.  
  1276.       callbackIdentifier = res;
  1277.       if (callbackIdentifier === 'RESULT27') 0;
  1278.       else if (callbackIdentifier === 'RESULT0') {
  1279.         // a.isSearch && !a.disableWheelScroll && B("desktop_enable_dmpanel_wheel_scroll")
  1280.       } else if (callbackIdentifier.startsWith('RESULT')) {
  1281.         console.log('wheel eventListener - RESULT', callbackIdentifier, callback)
  1282.       }
  1283.       return callbackIdentifier;
  1284.  
  1285.     };
  1286.  
  1287.     let callbackFound = false;
  1288.     EventTarget.prototype.addEventListener52178 = EventTarget.prototype.addEventListener;
  1289.     EventTarget.prototype.addEventListener = function (type, callback, option = void 0) {
  1290.       // M-youtube-js-engine-tamer.52178
  1291.       if (type === 'wheel' && !option && typeof callback === 'function' && callback.length === 1) {
  1292.         // (( match with signature `a.addEventListener("wheel", hZb);` )) [subject to further review]
  1293.         const callbackIdentifier = callback.yaujmoms || (callbackFound ? 'IGNORE' : (callback.yaujmoms = checkWheelListener(callback)));
  1294.         // RESULTXX / ErrorFXX / Other...
  1295.         if (callbackIdentifier === 'RESULT27') {
  1296.           this.overscrollConfigDisable = true;
  1297.           if (!callbackFound) {
  1298.             callbackFound = true; // suppose only one function is assigned to overscrollConfig cooldown [no function binding]
  1299.             getObjsFn = checkWheelListener = null;
  1300.             checkWheelListenerObjs = null;
  1301.             wheelHandler = null;
  1302.           }
  1303.           return void 0;
  1304.         } else if (!callbackFound && !this.overscrollConfigDisable) {
  1305.           this.overscrollConfigDisable = true;
  1306.           this.addEventListener52178('wheel', wheelHandler, { passive: false });
  1307.         }
  1308.       }
  1309.       return this.addEventListener52178(type, callback, option);
  1310.     };
  1311.  
  1312.     // ---- << this.overscrollConfig HACK >>  -----
  1313.  
  1314.   }
  1315.  
  1316.   const { pageMediaWatcher, shortcutKeysFixer, keyboardController } = (() => {
  1317.  
  1318.     let p_a_objWR = null;
  1319.     let isSpaceKeyImmediate = false; // for ADVANCED_FIX_SHORTCUTKEYS
  1320.     let ytPageReady = 0;
  1321.  
  1322.     let isSpeedMastSpacebarControlEnabled = false; // youtube experimental feature // can be forced by CHANGE_SPEEDMASTER_SPACEBAR_CONTROL
  1323.     let isGlobalSpaceControl = true;
  1324.     let mediaPlayerElementWR = null;
  1325.     let focusedElementAtSelection = null;
  1326.  
  1327.     // let want_control_video = false;
  1328.  
  1329.     let spaceBarControl_keyG = '';
  1330.  
  1331.     let lastUserAction = 0;
  1332.  
  1333.     const wmKeyControlPhase = new WeakMap();
  1334.  
  1335.     let currentSelectionText = null;
  1336.  
  1337.     const getCurrentSelectionText = () => {
  1338.       if (currentSelectionText !== null) return currentSelectionText
  1339.       return (currentSelectionText = getSelection() + "")
  1340.     }
  1341.  
  1342.     const pageMediaWatcher = () => {
  1343.  
  1344.       // CAN_TUNE_VOLUMN_AFTER_RESUME_OR_PAUSE && document.addEventListener('wheel', () => {
  1345.       //   want_control_video = false;
  1346.       // }, { capture: true, passive: true });
  1347.  
  1348.       document.addEventListener('yt-navigate', () => {
  1349.         ytPageReady = 0;
  1350.       });
  1351.       document.addEventListener('yt-navigate-start', () => {
  1352.         ytPageReady = 0;
  1353.       });
  1354.       document.addEventListener('yt-navigate-cache', () => {
  1355.         ytPageReady = 0;
  1356.       });
  1357.  
  1358.       document.addEventListener('yt-navigate-finish', () => {
  1359.         ytPageReady = 1;
  1360.       });
  1361.  
  1362.       document.addEventListener('durationchange', () => {
  1363.         for (const elm of document.querySelectorAll('#movie_player video[src], #movie_player audio[src]')) {
  1364.           if (elm.duration > 0.01) {
  1365.             if (elm.closest('[hidden]')) continue;
  1366.             mediaPlayerElementWR = mWeakRef(elm);
  1367.             return;
  1368.           }
  1369.         }
  1370.       }, { capture: true, passive: true });
  1371.  
  1372.       document.addEventListener('selectionchange', (evt) => {
  1373.         if (!evt || !evt.isTrusted || !(evt instanceof Event)) return;
  1374.         currentSelectionText = null;
  1375.         if (!(evt.target instanceof Node)) return;
  1376.         focusedElementAtSelection = evt.target;
  1377.       }, { capture: true, passive: true })
  1378.  
  1379.       document.addEventListener('pointerdown', (evt) => {
  1380.         if (evt.isTrusted && evt instanceof Event) lastUserAction = Date.now();
  1381.       }, { capture: true, passive: true });
  1382.  
  1383.  
  1384.       document.addEventListener('pointerup', (evt) => {
  1385.         if (evt.isTrusted && evt instanceof Event) lastUserAction = Date.now();
  1386.       }, { capture: true, passive: true });
  1387.  
  1388.  
  1389.       document.addEventListener('keydown', (evt) => {
  1390.         if (evt.isTrusted && evt instanceof Event) lastUserAction = Date.now();
  1391.       }, { capture: true, passive: true });
  1392.  
  1393.       document.addEventListener('keyup', (evt) => {
  1394.         if (evt.isTrusted && evt instanceof Event) lastUserAction = Date.now();
  1395.       }, { capture: true, passive: true });
  1396.  
  1397.     };
  1398.  
  1399.  
  1400.     const checkKeyB = (p_a_obj) => {
  1401.  
  1402.       const boolList = new Set();
  1403.       const p_a_obj_api = p_a_obj.api;
  1404.  
  1405.       const nilFunc0 = function () {
  1406.         return void 0
  1407.       };
  1408.       const mt = new Proxy({}, {
  1409.         get(target, prop) {
  1410.           if (prop === 'get') return nilFunc0;
  1411.           return mt;
  1412.         }
  1413.       });
  1414.       const nilFunc = function () {
  1415.         return mt
  1416.       };
  1417.       const mw = new Proxy({}, {
  1418.         get(target, prop) {
  1419.           if (prop in p_a_obj_api) {
  1420.             if (typeof p_a_obj_api.constructor.prototype[prop] === 'function') return nilFunc;
  1421.             let q = Object.getOwnPropertyDescriptor(p_a_obj_api, prop);
  1422.             if (q && q.value) {
  1423.               if (!q.writable) return q.value;
  1424.               if (typeof q.value === 'string') return '';
  1425.               if (typeof q.value === 'number') return 0;
  1426.               if (typeof q.value === 'boolean') return false;
  1427.               if (q.value && typeof q.value === 'object') return {};
  1428.             }
  1429.           }
  1430.           return undefined;
  1431.         },
  1432.         set(target, prop) {
  1433.           throw 'mwSet';
  1434.         }
  1435.       });
  1436.  
  1437.       const mq = new Proxy({}, {
  1438.         get(target, prop) {
  1439.           if (prop === 'api') return mw;
  1440.           if (prop in p_a_obj) {
  1441.             if (typeof p_a_obj.constructor.prototype[prop] === 'function') return nilFunc;
  1442.             let q = Object.getOwnPropertyDescriptor(p_a_obj, prop);
  1443.             if (q && q.value) {
  1444.               if (!q.writable) return q.value;
  1445.               if (typeof q.value === 'string') return '';
  1446.               if (typeof q.value === 'number') return 0;
  1447.               if (typeof q.value === 'boolean') return false;
  1448.               if (q.value && typeof q.value === 'object') return {};
  1449.             }
  1450.           }
  1451.           return undefined;
  1452.         },
  1453.         set(target, prop, val) {
  1454.           if (typeof val === 'boolean') boolList.add(prop)
  1455.           throw `mqSet(${prop},${val})`;
  1456.         }
  1457.       });
  1458.  
  1459.       let res = ''
  1460.       try {
  1461.         res = `RESULT::${p_a_obj.handleGlobalKeyUp.call(mq, 9, false, false, false, false, "Tab", "Tab")}`;
  1462.       } catch (e) {
  1463.         res = `ERROR::${e}`;
  1464.       }
  1465.  
  1466.       if (boolList.size === 1) {
  1467.         const value = boolList.values().next().value;
  1468.         if (res === `ERROR::mqSet(${value},${true})`) {
  1469.           p_a_obj.__uZWaD__ = value;
  1470.         }
  1471.       }
  1472.  
  1473.       console.log('[yt-js-engine-tamer] global shortcut control', { '__uZWaD__': p_a_obj.__uZWaD__ });
  1474.  
  1475.     }
  1476.  
  1477.  
  1478.     let pm_p_a = null;
  1479.  
  1480.     const p_a_init = function () {
  1481.       const r = this.init91();
  1482.       const keyBw = this.__cPzfo__ || '__NIL__';
  1483.       const p_a_obj = this[keyBw];
  1484.       if (!p_a_obj) return;
  1485.       try {
  1486.         checkKeyB(p_a_obj);
  1487.       } catch (e) { }
  1488.       p_a_objWR = mWeakRef(p_a_obj);
  1489.       if (FIX_SHORTCUTKEYS > 0) {
  1490.         if (p_a_obj && !p_a_obj.hVhtg) {
  1491.           p_a_obj.hVhtg = 1;
  1492.  
  1493.           p_a_obj.handleGlobalKeyUp91 = p_a_obj.handleGlobalKeyUp;
  1494.           p_a_obj.handleGlobalKeyUp = p_a_xt.handleGlobalKeyUp;
  1495.           p_a_obj.handleGlobalKeyDown91 = p_a_obj.handleGlobalKeyDown;
  1496.           p_a_obj.handleGlobalKeyDown = p_a_xt.handleGlobalKeyDown;
  1497.           p_a_obj.__handleGlobalKeyBefore__ = p_a_xt.__handleGlobalKeyBefore__;
  1498.           p_a_obj.__handleGlobalKeyAfter__ = p_a_xt.__handleGlobalKeyAfter__;
  1499.  
  1500.         }
  1501.         // if (CAN_TUNE_VOLUMN_AFTER_RESUME_OR_PAUSE && p_a_obj && p_a_obj.api && !p_a_obj.api.hVhtg) {
  1502.         //   const api = p_a_obj.api
  1503.         //   api.hVhtg = 1;
  1504.         //   api.playVideo91 = api.playVideo;
  1505.         //   api.playVideo = p_a_jt.playVideo;
  1506.         //   api.pauseVideo91 = api.pauseVideo;
  1507.         //   api.pauseVideo = p_a_jt.pauseVideo;
  1508.         // }
  1509.       }
  1510.       if (pm_p_a) {
  1511.         pm_p_a.resolve();
  1512.         pm_p_a = null;
  1513.       }
  1514.       return r;
  1515.     };
  1516.  
  1517.     const p_a_xt = {
  1518.  
  1519.       __handleGlobalKeyBefore__(a, b, c, d, e, f, h, activeElement) {
  1520.  
  1521.         if (FIX_SHORTCUTKEYS === 2) {
  1522.  
  1523.           // if (flagSpeedMaster !== false && !getGlobalSpacebarControlFlag()) return false;
  1524.  
  1525.           if (activeElement) {
  1526.  
  1527.             const controlPhaseCache = wmKeyControlPhase.get(activeElement);
  1528.  
  1529.             if (controlPhaseCache === 6 && getCurrentSelectionText() !== "") void 0;
  1530.             else if (controlPhaseCache === 1 || controlPhaseCache === 2 || controlPhaseCache === 5) return false;
  1531.             else if ((controlPhaseCache !== 6 || focusedElementAtSelection === document.activeElement) && getCurrentSelectionText() !== "") return false;
  1532.  
  1533.           }
  1534.  
  1535.           const isSpaceBar = a === 32 && b === false && c === false && d === false && e === false && f === ' ' && h === 'Space';
  1536.           const isDelayedSpaceBar = FIX_SHORTCUTKEYS === 2 && isSpaceBar && !isSpaceKeyImmediate && (isSpeedMastSpacebarControlEnabled = getSpeedMasterControlFlag());
  1537.           // console.log(582, isDelayedSpaceBar)
  1538.           if (isDelayedSpaceBar) return void 0; // accept delay spacebar under isSpeedMastSpacebarControlEnabled (no rejection)
  1539.  
  1540.           if (activeElement && (h === 'Space' || h === 'Enter')) {
  1541.             const controlPhase = wmKeyControlPhase.get(activeElement);
  1542.             if (controlPhase === 4 || controlPhase === 5) return false;
  1543.           }
  1544.           if (focusedElementAtSelection === activeElement && getCurrentSelectionText() !== "") return false;
  1545.           // if (!isSpeedMastSpacebarControlEnabled && a === 32 && b === false && c === false && d === false && e === false && f === ' ' && h === 'Space') {
  1546.           //   if (!isSpaceKeyImmediate) return false;
  1547.           // }
  1548.         }
  1549.  
  1550.       },
  1551.  
  1552.       __handleGlobalKeyAfter__(a, b, c, d, e, f, h, activeElement, ret) {
  1553.  
  1554.         if (FIX_SHORTCUTKEYS === 2 && ret && a >= 32 && ytPageReady === 1 && Date.now() - lastUserAction < 40 && activeElement === document.activeElement) {
  1555.  
  1556.           const isSpaceBar = a === 32 && b === false && c === false && d === false && e === false && f === ' ' && h === 'Space';
  1557.           const isDelayedSpaceBar = FIX_SHORTCUTKEYS === 2 && isSpaceBar && !isSpaceKeyImmediate && (isSpeedMastSpacebarControlEnabled = getSpeedMasterControlFlag());
  1558.           // console.log(583, isDelayedSpaceBar)
  1559.           if (isDelayedSpaceBar) return void 0; // accept delay spacebar under isSpeedMastSpacebarControlEnabled (no rejection)
  1560.  
  1561.           const mediaPlayerElement = kRef(mediaPlayerElementWR);
  1562.  
  1563.           let mediaWorking = false;
  1564.           if (mediaPlayerElement && (mediaPlayerElement.readyState === 4 || mediaPlayerElement.readyState === 1) && mediaPlayerElement.networkState === 2 && mediaPlayerElement.duration > 0.01) {
  1565.             mediaWorking = true;
  1566.           } else if (mediaPlayerElement && !mediaPlayerElement.paused && !mediaPlayerElement.muted && mediaPlayerElement.duration > 0.01) {
  1567.             mediaWorking = true;
  1568.           }
  1569.           // console.log(182, mediaWorking, mediaPlayerElement.readyState , mediaPlayerElement.networkState)
  1570.           mediaWorking && Promise.resolve().then(() => {
  1571.             if (activeElement === document.activeElement) {
  1572.               return activeElement.blur()
  1573.             } else {
  1574.               return false
  1575.             }
  1576.           }).then((r) => {
  1577.             r !== false && mediaPlayerElement.focus();
  1578.           });
  1579.         }
  1580.       },
  1581.  
  1582.  
  1583.       handleGlobalKeyUp(a, b, c, d, e, f, h) {
  1584.  
  1585.         if (BY_PASS_KEYBOARD_CONTROL) return this.handleGlobalKeyUp91(a, b, c, d, e, f, h);
  1586.  
  1587.         const activeElement = document.activeElement;
  1588.  
  1589.         const allow = typeof this.__handleGlobalKeyBefore__ === 'function' ? this.__handleGlobalKeyBefore__(a, b, c, d, e, f, h, activeElement) : void 0;
  1590.         if (allow === false) return false;
  1591.  
  1592.         const ret = this.handleGlobalKeyUp91(a, b, c, d, e, f, h);
  1593.         // console.log('handleGlobalKeyUp',ret, a, b, c, d, e, f, h);
  1594.  
  1595.         typeof this.__handleGlobalKeyAfter__ === 'function' && this.__handleGlobalKeyAfter__(a, b, c, d, e, f, h, activeElement, ret);
  1596.  
  1597.         return ret;
  1598.       },
  1599.       handleGlobalKeyDown(a, b, c, d, e, f, h, l) {
  1600.  
  1601.  
  1602.         if (BY_PASS_KEYBOARD_CONTROL) return this.handleGlobalKeyDown91(a, b, c, d, e, f, h, l);
  1603.  
  1604.         const activeElement = document.activeElement;
  1605.         // if (a === 32 && b === false && c === false && d === false && e === false && f === ' ' && h === 'Space' && !(isSpeedMastSpacebarControlEnabled = getSpeedMasterControlFlag())) {
  1606.         //   return this.handleGlobalKeyDown91(a, b, c, d, e, f, h, l);
  1607.         // }
  1608.         const allow = typeof this.__handleGlobalKeyBefore__ === 'function' ? this.__handleGlobalKeyBefore__(a, b, c, d, e, f, h, activeElement) : void 0;
  1609.         if (allow === false) return false;
  1610.  
  1611.         const ret = this.handleGlobalKeyDown91(a, b, c, d, e, f, h, l);
  1612.         // console.log('handleGlobalKeyDown',ret, a, b, c, d, e, f, h,l)
  1613.  
  1614.         typeof this.__handleGlobalKeyAfter__ === 'function' && this.__handleGlobalKeyAfter__(a, b, c, d, e, f, h, activeElement, ret);
  1615.  
  1616.         return ret;
  1617.       }
  1618.  
  1619.     };
  1620.  
  1621.     // const p_a_jt = { // API
  1622.  
  1623.     //   playVideo(a) { // without spinner effect
  1624.  
  1625.     //     if (CAN_TUNE_VOLUMN_AFTER_RESUME_OR_PAUSE) {
  1626.  
  1627.     //       const mediaPlayerElement = kRef(mediaPlayerElementWR);
  1628.     //       if (mediaPlayerElement && !mediaPlayerElement.paused && !mediaPlayerElement.muted && mediaPlayerElement.duration > 0.01) {
  1629.     //         want_control_video = true;
  1630.     //         // Promise.resolve().then(()=> mediaPlayerElement.focus() );
  1631.     //       }
  1632.  
  1633.     //     }
  1634.     //     return this.playVideo91(a);
  1635.  
  1636.     //   },
  1637.  
  1638.     //   pauseVideo(a) { // without spinner effect
  1639.  
  1640.     //     if (CAN_TUNE_VOLUMN_AFTER_RESUME_OR_PAUSE) {
  1641.  
  1642.     //       const mediaPlayerElement = kRef(mediaPlayerElementWR);
  1643.     //       if (mediaPlayerElement && mediaPlayerElement.paused && !mediaPlayerElement.muted && mediaPlayerElement.duration > 0.01) {
  1644.     //         want_control_video = true;
  1645.     //         // Promise.resolve().then(()=> mediaPlayerElement.focus() );
  1646.     //       }
  1647.  
  1648.     //     }
  1649.     //     return this.pauseVideo91(a);
  1650.  
  1651.     //   }
  1652.     // };
  1653.  
  1654.     let flagSpeedMaster = null;
  1655.     const getSpeedMasterControlFlag = () => {
  1656.  
  1657.       const config = (win.yt || 0).config_ || (win.ytcfg || 0).data_ || 0;
  1658.       isSpeedMastSpacebarControlEnabled = false;
  1659.       if (config && config.EXPERIMENT_FLAGS && config.EXPERIMENT_FLAGS.web_speedmaster_spacebar_control) {
  1660.         isSpeedMastSpacebarControlEnabled = true;
  1661.       }
  1662.       if (config && config.EXPERIMENTS_FORCED_FLAGS && config.EXPERIMENTS_FORCED_FLAGS.web_speedmaster_spacebar_control) {
  1663.         isSpeedMastSpacebarControlEnabled = true;
  1664.       }
  1665.  
  1666.       if (flagSpeedMaster === null) {
  1667.         const p = (((config || 0).WEB_PLAYER_CONTEXT_CONFIGS || 0).WEB_PLAYER_CONTEXT_CONFIG_ID_KEVLAR_WATCH || 0).serializedExperimentFlags;
  1668.         if (!p) {
  1669.           flagSpeedMaster = false;
  1670.         } else {
  1671.  
  1672.           flagSpeedMaster = (p.includes('web_enable_speedmaster=true') && p.includes('web_speedmaster_spacebar_control=true') && p.includes('web_speedmaster_updated_edu=true'));
  1673.  
  1674.         }
  1675.  
  1676.       }
  1677.       if (!flagSpeedMaster) isSpeedMastSpacebarControlEnabled = false;
  1678.  
  1679.       return isSpeedMastSpacebarControlEnabled;
  1680.     }
  1681.  
  1682.  
  1683.     const getGlobalSpacebarControlFlag = () => {
  1684.  
  1685.       const config = (win.yt || 0).config_ || (win.ytcfg || 0).data_ || 0;
  1686.       isGlobalSpaceControl = false;
  1687.       if (config && config.EXPERIMENT_FLAGS && config.EXPERIMENT_FLAGS.global_spacebar_pause) {
  1688.         isGlobalSpaceControl = true;
  1689.       }
  1690.       if (config && config.EXPERIMENTS_FORCED_FLAGS && config.EXPERIMENTS_FORCED_FLAGS.global_spacebar_pause) {
  1691.         isGlobalSpaceControl = true;
  1692.       }
  1693.  
  1694.       return isGlobalSpaceControl;
  1695.     }
  1696.  
  1697.     const keyboardController = async (_yt_player) => {
  1698.  
  1699.       const keyQT = getQT(_yt_player);
  1700.       const keySV = getSV(_yt_player);
  1701.       const keyDX = getDX(_yt_player);
  1702.       console.log(`[QT,SV,DX]`, [keyQT, keySV, keyDX]);
  1703.  
  1704.       if (!keyDX) return;
  1705.       if (keyDX === keyQT || keyDX === keySV) return;
  1706.  
  1707.       if (typeof keyDX !== 'string') return;
  1708.  
  1709.       let lastAccessKey = '';
  1710.       let lastAccessKeyConfirmed = '';
  1711.       const mb = new Proxy({}, {
  1712.         get(target, prop) {
  1713.           if (prop === 'handleGlobalKeyUp') lastAccessKeyConfirmed = lastAccessKey;
  1714.           throw 'mbGet'
  1715.         },
  1716.         set(target, prop, val) {
  1717.           throw 'mbSet'
  1718.         }
  1719.       });
  1720.       const ma = new Proxy({}, {
  1721.         get(target, prop) {
  1722.           lastAccessKey = prop;
  1723.           return mb
  1724.         },
  1725.         set(target, prop, val) {
  1726.           throw 'maSet'
  1727.         }
  1728.       });
  1729.  
  1730.       let keyBw = '';
  1731.       try {
  1732.         _yt_player[keyDX].prototype.handleGlobalKeyUp.call(ma);
  1733.       } catch (e) {
  1734.         if (e === 'mbGet' && typeof lastAccessKeyConfirmed === 'string' && lastAccessKeyConfirmed.length > 0) {
  1735.           keyBw = lastAccessKeyConfirmed;
  1736.         }
  1737.       }
  1738.  
  1739.       if (!keyBw) return;
  1740.  
  1741.       if (typeof _yt_player[keyDX].prototype.init !== 'function' || _yt_player[keyDX].prototype.init.length !== 0) return;
  1742.  
  1743.       pm_p_a = new PromiseExternal();
  1744.  
  1745.       _yt_player[keyDX].prototype.__cPzfo__ = keyBw;
  1746.  
  1747.       _yt_player[keyDX].prototype.init91 = _yt_player[keyDX].prototype.init;
  1748.  
  1749.       _yt_player[keyDX].prototype.init = p_a_init;
  1750.  
  1751.       await pm_p_a.then();
  1752.       const p_a_obj = kRef(p_a_objWR);
  1753.  
  1754.       const isSpeedMastSpacebarControlEnabledA = getSpeedMasterControlFlag();
  1755.  
  1756.  
  1757.       if (CHANGE_SPEEDMASTER_SPACEBAR_CONTROL > 0) {
  1758.  
  1759.         isSpeedMastSpacebarControlEnabled = CHANGE_SPEEDMASTER_SPACEBAR_CONTROL == 1;
  1760.  
  1761.         if (!isSpeedMastSpacebarControlEnabled) {
  1762.  
  1763.           if (config && config.EXPERIMENT_FLAGS) {
  1764.             config.EXPERIMENT_FLAGS.web_speedmaster_spacebar_control = false;
  1765.           }
  1766.           if (config && config.EXPERIMENTS_FORCED_FLAGS) {
  1767.             config.EXPERIMENTS_FORCED_FLAGS.web_speedmaster_spacebar_control = false;
  1768.           }
  1769.  
  1770.         } else {
  1771.  
  1772.           if (config && config.EXPERIMENT_FLAGS) {
  1773.             config.EXPERIMENT_FLAGS.web_speedmaster_spacebar_control = true;
  1774.           }
  1775.           if (config && config.EXPERIMENTS_FORCED_FLAGS) {
  1776.             config.EXPERIMENTS_FORCED_FLAGS.web_speedmaster_spacebar_control = true;
  1777.           }
  1778.  
  1779.         }
  1780.  
  1781.       }
  1782.  
  1783.       const isSpeedMastSpacebarControlEnabledB = getSpeedMasterControlFlag();
  1784.  
  1785.  
  1786.  
  1787.  
  1788.       console.log('[yt-js-engine-tamer] speedmaster by space (yt setting)', isSpeedMastSpacebarControlEnabledA, isSpeedMastSpacebarControlEnabledB);
  1789.  
  1790.       // console.log(p_a_obj.handleGlobalKeyUp)
  1791.       console.log('[yt-js-engine-tamer] p_a', p_a_obj)
  1792.  
  1793.       // console.log(p_a_obj.api)
  1794.  
  1795.  
  1796.       // QT -> DX(SV) -> p_a
  1797.  
  1798.  
  1799.       /*
  1800.        *
  1801.        *
  1802.         g.k.handleGlobalKeyUp = function(a, b, c, d, e, f, h) {
  1803.             b = void 0 === b ? !1 : b;
  1804.             c = void 0 === c ? !1 : c;
  1805.             d = void 0 === d ? !1 : d;
  1806.             e = void 0 === e ? !1 : e;
  1807.             var l = g.PT(this);
  1808.             l && l.handleGlobalKeyUp(a, b, c, d, e, f, h)
  1809.         }
  1810.  
  1811.       */
  1812.  
  1813.       /*
  1814.        *
  1815.        *
  1816.        *
  1817.         g.k.handleGlobalKeyUp = function(a, b, c, d, e, f, h) {
  1818.             return this.Bw ? this.Bw.handleGlobalKeyUp(a, b, c, d, e, f, h) : !1
  1819.         }
  1820.  
  1821.       */
  1822.  
  1823.  
  1824.       // if(!keyDX) return;
  1825.  
  1826.       // console.log(4999, keyDX)
  1827.  
  1828.     };
  1829.  
  1830.  
  1831.     const ytResumeFn = function () { // ADVANCED_FIX_SHORTCUTKEYS
  1832.  
  1833.       const p_a_obj = kRef(p_a_objWR);
  1834.       // const api = p_a_obj.api;
  1835.  
  1836.  
  1837.       // console.log(540);
  1838.  
  1839.       let boolList = null;
  1840.       let ret;
  1841.       isSpaceKeyImmediate = true;
  1842.       try {
  1843.  
  1844.         ret = 0;
  1845.         ret = ret | (p_a_obj.handleGlobalKeyDown(32, false, false, false, false, ' ', 'Space', false) ? 1 : 0);
  1846.         let p_a_objT;
  1847.         if (!spaceBarControl_keyG) { // just in case
  1848.           boolList = new Set();
  1849.           p_a_objT = new Proxy(p_a_obj, {
  1850.             get(target, prop, handler) {
  1851.               const val = target[prop];
  1852.               if (typeof val !== 'boolean') return val;
  1853.               boolList.add(prop);
  1854.               // console.log(555, prop, val);
  1855.               if (typeof prop === 'string' && prop.length <= 3 && val === true && boolList.length === 1) {
  1856.                 spaceBarControl_keyG = prop;
  1857.                 p_a_obj.__uZWaD__ = spaceBarControl_keyG;
  1858.                 val = false;
  1859.               }
  1860.               return val;
  1861.             }
  1862.           });
  1863.  
  1864.  
  1865.         } else if (p_a_obj[spaceBarControl_keyG] === true) {
  1866.           p_a_obj[spaceBarControl_keyG] = false;
  1867.           p_a_objT = p_a_obj;
  1868.           // console.log(p_a_obj, spaceBarControl_keyG, p_a_obj[spaceBarControl_keyG] )
  1869.         } else {
  1870.  
  1871.           p_a_objT = p_a_obj;
  1872.         }
  1873.  
  1874.         ret = ret | (p_a_objT.handleGlobalKeyUp(32, false, false, false, false, ' ', 'Space') ? 2 : 0);
  1875.  
  1876.  
  1877.       } catch (e) {
  1878.         console.log(e)
  1879.       }
  1880.       isSpaceKeyImmediate = false;
  1881.  
  1882.       if (boolList && boolList.size === 1) {
  1883.         const value = boolList.values().next().value;
  1884.         spaceBarControl_keyG = value;
  1885.         p_a_obj.__uZWaD__ = spaceBarControl_keyG;
  1886.  
  1887.       }
  1888.  
  1889.       if (spaceBarControl_keyG && p_a_obj[spaceBarControl_keyG] === true) p_a_obj[spaceBarControl_keyG] = false;
  1890.  
  1891.       return ret;
  1892.     }
  1893.  
  1894.     const shortcutKeysFixer = () => {
  1895.  
  1896.       let pausePromiseControlJ = 0;
  1897.  
  1898.  
  1899.       const obtainCurrentControlPhase = (evt, mediaPlayerElement) => {
  1900.  
  1901.         let controlPhase = 0;
  1902.         const aElm = document.activeElement;
  1903.  
  1904.         if (aElm) {
  1905.  
  1906.           const controlPhaseCache = wmKeyControlPhase.get(aElm);
  1907.  
  1908.           if (typeof controlPhaseCache === 'number') {
  1909.  
  1910.             controlPhase = controlPhaseCache;
  1911.           } else {
  1912.  
  1913.             if (aElm instanceof HTMLInputElement) controlPhase = 1;
  1914.             else if (aElm instanceof HTMLTextAreaElement) controlPhase = 1;
  1915.             else if (aElm instanceof HTMLButtonElement) controlPhase = 2;
  1916.             else if (aElm instanceof HTMLIFrameElement) controlPhase = 2;
  1917.             else if (aElm instanceof HTMLImageElement) controlPhase = 2;
  1918.             else if (aElm instanceof HTMLEmbedElement) controlPhase = 2;
  1919.             else {
  1920.               if (aElm instanceof HTMLElement && aElm.closest('[role]')) controlPhase = 5;
  1921.               if (aElm instanceof HTMLDivElement) controlPhase = 2;
  1922.               else if (aElm instanceof HTMLAnchorElement) controlPhase = 2;
  1923.               else if (!(aElm instanceof HTMLElement) && (aElm instanceof Element)) controlPhase = 2; // svg
  1924.             }
  1925.  
  1926.             if ((controlPhase === 2 || controlPhase === 5) && (aElm instanceof HTMLElement) && aElm.contains(mediaPlayerElement)) {
  1927.               controlPhase = 0;
  1928.             }
  1929.  
  1930.             if ((controlPhase === 2 || controlPhase === 5) && evt && evt.target && evt.target === aElm) {
  1931.               if (aElm.closest('[contenteditable], input, textarea')) {
  1932.                 controlPhase = 5;
  1933.               } else if (aElm.closest('button')) {
  1934.                 controlPhase = 4;
  1935.               }
  1936.             }
  1937.  
  1938.             if (aElm.closest('#movie_player')) controlPhase = 6;
  1939.  
  1940.             wmKeyControlPhase.set(aElm, controlPhase);
  1941.  
  1942.           }
  1943.         }
  1944.  
  1945.         return controlPhase;
  1946.  
  1947.       }
  1948.  
  1949.       const isStateControllable = (api) => {
  1950.         let appState = null;
  1951.         let playerState = null;
  1952.         let adState = null;
  1953.         try {
  1954.           appState = api.getAppState();
  1955.           playerState = api.getPlayerState();
  1956.           adState = api.getAdState();
  1957.         } catch (e) { }
  1958.         // ignore playerState -1
  1959.         return appState === 5 && adState === -1 && (playerState === 1 || playerState === 2 || playerState === 3);
  1960.       };
  1961.  
  1962.  
  1963.       const keyEventListener = (evt) => {
  1964.         if (BY_PASS_KEYBOARD_CONTROL) return;
  1965.  
  1966.         if (evt.isTrusted && evt instanceof Event) lastUserAction = Date.now();
  1967.         if (isSpaceKeyImmediate || !evt.isTrusted || !(evt instanceof KeyboardEvent)) return;
  1968.         if (!ytPageReady) return;
  1969.  
  1970.         if (evt.defaultPrevented === true) return;
  1971.  
  1972.         const p_a_obj = kRef(p_a_objWR);
  1973.  
  1974.         if (!p_a_obj) return;
  1975.  
  1976.  
  1977.         const mediaPlayerElement = kRef(mediaPlayerElementWR);
  1978.         if (!mediaPlayerElement) return;
  1979.  
  1980.         // let focusBodyIfSuccess = false;
  1981.  
  1982.         const controlPhase = obtainCurrentControlPhase(evt, mediaPlayerElement);
  1983.  
  1984.         if (controlPhase === 6 && getCurrentSelectionText() !== "") void 0;
  1985.         else if (controlPhase === 1 || controlPhase === 2 || controlPhase === 5) return;
  1986.         else if ((controlPhase !== 6 || focusedElementAtSelection === document.activeElement) && getCurrentSelectionText() !== "") return;
  1987.  
  1988.  
  1989.         if (evt.code === 'Space' && !getGlobalSpacebarControlFlag()) return;
  1990.  
  1991.         // console.log(`${evt.type}::controlPhase`,controlPhase)
  1992.  
  1993.         // if (controlPhase == 4) {
  1994.         //   focusBodyIfSuccess = true;
  1995.         // }
  1996.  
  1997.         spaceBarControl_keyG = spaceBarControl_keyG || p_a_obj.__uZWaD__ || ''
  1998.         if (spaceBarControl_keyG && p_a_obj[spaceBarControl_keyG] === true) p_a_obj[spaceBarControl_keyG] = false;
  1999.  
  2000.         if (FIX_SHORTCUTKEYS < 2) return;
  2001.         if (!(!evt.shiftKey && !evt.ctrlKey && !evt.altKey && !evt.metaKey)) return; // ignore if modifier key is pressed -> let other event listener to handle first
  2002.  
  2003.         let rr;
  2004.         const isSpaceBar = evt.code === 'Space' && !evt.shiftKey && !evt.ctrlKey && !evt.altKey && !evt.metaKey;
  2005.  
  2006.  
  2007.  
  2008.         let useImprovedPauseResume = false;
  2009.  
  2010.         if (USE_IMPROVED_PAUSERESUME_UNDER_NO_SPEEDMASTER && isSpaceBar && !(isSpeedMastSpacebarControlEnabled = getSpeedMasterControlFlag())) {
  2011.  
  2012.           const api = p_a_obj.api;
  2013.           const stateControllable = isStateControllable(api);
  2014.           // console.log(2122, appState, playerState, adState)
  2015.  
  2016.           if (stateControllable && isWatchPageURL() && mediaPlayerElement.duration > 0.01 && (mediaPlayerElement.readyState === 4 || mediaPlayerElement.readyState === 1) && mediaPlayerElement.networkState === 2) {
  2017.  
  2018.             useImprovedPauseResume = true;
  2019.  
  2020.           }
  2021.  
  2022.  
  2023.         }
  2024.  
  2025.  
  2026.         // force flag: CHANGE_SPEEDMASTER_SPACEBAR_CONTROL
  2027.         if (evt.type === 'keydown') {
  2028.  
  2029.           if (useImprovedPauseResume) {
  2030.  
  2031.             const isPaused = mediaPlayerElement.paused;
  2032.  
  2033.             const cj = ++pausePromiseControlJ;
  2034.             Promise.resolve().then(() => {
  2035.  
  2036.               if (cj !== pausePromiseControlJ) return;
  2037.  
  2038.               if (mediaPlayerElement.paused !== isPaused) return;
  2039.  
  2040.               const ret = ytResumeFn();
  2041.               if (!ret) { // fallback
  2042.                 isPaused ? api.playVideo() : api.pauseVideo();
  2043.               }
  2044.  
  2045.               /*
  2046.                   let a = void 0;
  2047.                   console.log('Rb', api.Rb())
  2048.                   a = !window._yt_player.nL(api.Rb());
  2049.                   p_a_obj.Wd.kG(a)
  2050.                       a ? api.playVideo() : api.pauseVideo();
  2051.  
  2052.               */
  2053.  
  2054.  
  2055.             });
  2056.             rr = true;
  2057.           } else {
  2058.  
  2059.             isSpaceKeyImmediate = true;
  2060.             rr = p_a_obj.handleGlobalKeyDown(evt.keyCode, evt.shiftKey, evt.ctrlKey, evt.altKey, evt.metaKey, evt.key, evt.code, evt.repeat);
  2061.             isSpaceKeyImmediate = false;
  2062.             if (spaceBarControl_keyG && p_a_obj[spaceBarControl_keyG] === true) p_a_obj[spaceBarControl_keyG] = false;
  2063.  
  2064.           }
  2065.  
  2066.  
  2067.         } else if (evt.type === 'keyup') {
  2068.  
  2069.           if (isSpaceBar && useImprovedPauseResume && !(isSpeedMastSpacebarControlEnabled = getSpeedMasterControlFlag())) {
  2070.  
  2071.             rr = true;
  2072.           } else {
  2073.  
  2074.             isSpaceKeyImmediate = true;
  2075.             rr = p_a_obj.handleGlobalKeyUp(evt.keyCode, evt.shiftKey, evt.ctrlKey, evt.altKey, evt.metaKey, evt.key, evt.code);
  2076.             isSpaceKeyImmediate = false;
  2077.             if (spaceBarControl_keyG && p_a_obj[spaceBarControl_keyG] === true) p_a_obj[spaceBarControl_keyG] = false;
  2078.  
  2079.           }
  2080.  
  2081.  
  2082.           /*
  2083.  
  2084.               if (d)
  2085.                   switch (c) {
  2086.                   case 32:
  2087.                   case 13:
  2088.                       if ("BUTTON" === d.tagName || "A" === d.tagName || "INPUT" === d.tagName)
  2089.                           b = !0,
  2090.                           e = !1;
  2091.                       else if (e) {
  2092.                           var m = d.getAttribute("role");
  2093.                           !m || "option" !== m && "button" !== m && 0 !== m.indexOf("menuitem") || (b = !0,
  2094.                           d.click(),
  2095.                           f = !0)
  2096.                       }
  2097.                       break;
  2098.                   case 37:
  2099.                   case 39:
  2100.                   case 36:
  2101.                   case 35:
  2102.                       b = "slider" === d.getAttribute("role");
  2103.                       break;
  2104.                   case 38:
  2105.                   case 40:
  2106.                       m = d.getAttribute("role"),
  2107.                       d = 38 === c ? d.previousSibling : d.nextSibling,
  2108.                       "slider" === m ? b = !0 : e && ("option" === m ? (d && "option" === d.getAttribute("role") && d.focus(),
  2109.                       f = b = !0) : m && 0 === m.indexOf("menuitem") && (d && d.hasAttribute("role") && 0 === d.getAttribute("role").indexOf("menuitem") && d.focus(),
  2110.                       f = b = !0))
  2111.                   }
  2112.               if (e && !f)
  2113.                   switch (c) {
  2114.                   case 38:
  2115.                       f = Math.min(this.api.getVolume() + 5, 100);
  2116.                       XV(this.Wd, f, !1);
  2117.                       this.api.setVolume(f);
  2118.                       h = f = !0;
  2119.                       break;
  2120.                   case 40:
  2121.                       f = Math.max(this.api.getVolume() - 5, 0);
  2122.                       XV(this.Wd, f, !0);
  2123.                       this.api.setVolume(f);
  2124.                       h = f = !0;
  2125.                       break;
  2126.                   case 36:
  2127.                       this.api.Yh() && (this.api.startSeekCsiAction(),
  2128.                       this.api.seekTo(0, void 0, void 0, void 0, 79),
  2129.                       h = f = !0);
  2130.                       break;
  2131.                   case 35:
  2132.                       this.api.Yh() && (this.api.startSeekCsiAction(),
  2133.                       this.api.seekTo(Infinity, void 0, void 0, void 0, 80),
  2134.                       h = f = !0)
  2135.                   }
  2136.           */
  2137.  
  2138.         }
  2139.  
  2140.  
  2141.         if (rr) {
  2142.  
  2143.           // focusBodyIfSuccess && Promise.resolve().then(() => {
  2144.           //   activeElement === document.activeElement && activeElement.blur();
  2145.           // });
  2146.  
  2147.           evt.preventDefault();
  2148.           evt.stopImmediatePropagation();
  2149.           evt.stopPropagation();
  2150.  
  2151.         }
  2152.  
  2153.       };
  2154.  
  2155.       document.addEventListener('keydown', keyEventListener, { capture: true });
  2156.  
  2157.  
  2158.       document.addEventListener('keyup', keyEventListener, { capture: true });
  2159.  
  2160.     }
  2161.  
  2162.     return { pageMediaWatcher, shortcutKeysFixer, keyboardController };
  2163.  
  2164.   })();
  2165.  
  2166.  
  2167.   pageMediaWatcher();
  2168.   FIX_SHORTCUTKEYS > 0 && shortcutKeysFixer();
  2169.  
  2170.  
  2171.   const check_for_set_key_order = (() => {
  2172.  
  2173.     let mySet = new Set();
  2174.  
  2175.     mySet.add("value1");
  2176.     mySet.add("value2");
  2177.     mySet.add("value3");
  2178.  
  2179.     // Function to convert Set values to an array
  2180.     function getSetValues(set) {
  2181.       return Array.from(set.values());
  2182.     }
  2183.  
  2184.     // Function to test if the Set maintains insertion order
  2185.     function testSetOrder(set, expectedOrder) {
  2186.       let values = getSetValues(set);
  2187.       return expectedOrder.join(',') === values.join(',');
  2188.     }
  2189.  
  2190.     // Test 1: Initial order
  2191.     if (mySet.values().next().value !== "value1") return false;
  2192.     if (!testSetOrder(mySet, ["value1", "value2", "value3"])) return false;
  2193.  
  2194.     // Test 2: After deleting an element
  2195.     mySet.delete("value2");
  2196.     if (mySet.values().next().value !== "value1") return false;
  2197.     if (!testSetOrder(mySet, ["value1", "value3"])) return false;
  2198.  
  2199.     // Test 3: After re-adding a deleted element
  2200.     mySet.add("value2");
  2201.     if (mySet.values().next().value !== "value1") return false;
  2202.     if (!testSetOrder(mySet, ["value1", "value3", "value2"])) return false;
  2203.  
  2204.     // Test 4: After adding a new element
  2205.     mySet.add("value4");
  2206.     if (mySet.values().next().value !== "value1") return false;
  2207.     if (!testSetOrder(mySet, ["value1", "value3", "value2", "value4"])) return false;
  2208.  
  2209.     // Test 5: Delete+Add
  2210.     mySet.delete("value1");
  2211.     mySet.delete("value3");
  2212.     mySet.add("value3");
  2213.     mySet.add("value1");
  2214.     if (mySet.values().next().value !== "value2") return false;
  2215.     if (!testSetOrder(mySet, ["value2", "value4", "value3", "value1"])) return false;
  2216.  
  2217.     return true;
  2218.   })();
  2219.  
  2220.  
  2221.   // const qm47 = Symbol();
  2222.   const qm57 = Symbol();
  2223.   const qm53 = Symbol();
  2224.   const qn53 = Symbol();
  2225.  
  2226.  
  2227.   const ump3 = new WeakMap();
  2228.  
  2229.   const stp = document.createElement('noscript');
  2230.   stp.id = 'weakref-placeholder'
  2231.  
  2232.  
  2233.   const handlerWFs = {};
  2234.  
  2235.   const createHandlerWF = (z, usePlaceholder) => {
  2236.  
  2237.     return {
  2238.       get() {
  2239.         const elm = this;
  2240.         const wr = elm[z];
  2241.         if (!wr) return null;
  2242.         const m = kRef(wr);
  2243.         if (!m && usePlaceholder) {
  2244.           if (typeof usePlaceholder === 'function') usePlaceholder(elm);
  2245.           return stp;
  2246.         }
  2247.         return m;
  2248.       },
  2249.       set(nv) {
  2250.         const elm = this;
  2251.         elm[z] = nv ? mWeakRef(nv) : null;
  2252.         return true;
  2253.       },
  2254.       configurable: true,
  2255.       enumerable: true
  2256.  
  2257.     }
  2258.   }
  2259.  
  2260.   const setupWF = typeof WeakRef !== 'undefined' ? (elm, s, usePlaceholder) => {
  2261.     const z = `${s}72`;
  2262.     if (z in elm) return;
  2263.     const pd = Object.getOwnPropertyDescriptor(elm, s);
  2264.     if (pd && pd.configurable && !pd.get && !pd.set) {
  2265.       const p = pd.value;
  2266.       delete elm[s];
  2267.       const handlerWF = handlerWFs[s] || (handlerWFs[s] = createHandlerWF(z, usePlaceholder));
  2268.       Object.defineProperty(elm, s, handlerWF);
  2269.       elm[s] = p;
  2270.       elm = null;
  2271.     }
  2272.   } : null;
  2273.  
  2274.   const mxMapPD = new WeakMap();
  2275.  
  2276.   const identifierWD = Symbol();
  2277.   const handlerWD = {
  2278.     get(obj, prop) {
  2279.       if (prop === identifierWD) return true;
  2280.       const val = obj[prop];
  2281.       if (typeof (val || 0).deref === 'function') {
  2282.         return val.deref();
  2283.       }
  2284.       return val;
  2285.     },
  2286.     set(obj, prop, val) {
  2287.       if (val instanceof Node) {
  2288.         obj[prop] = mWeakRef(val);
  2289.       } else {
  2290.         obj[prop] = val;
  2291.       }
  2292.       return true;
  2293.     }
  2294.   };
  2295.  
  2296.   const setupWD = WEAK_REF_PROXY_DOLLAR && typeof WeakRef !== 'undefined' ? function (dh) {
  2297.  
  2298.     const $ = dh ? dh.$ : 0;
  2299.  
  2300.     if (typeof ($ || 0) === 'object' && $[identifierWD] !== true) {
  2301.  
  2302.       for (const [k, v] of Object.entries($)) {
  2303.         if (v instanceof Node) {
  2304.           $[k] = mWeakRef(v);
  2305.         }
  2306.       }
  2307.  
  2308.       let kPD = mxMapPD.get($);
  2309.       if (!kPD) {
  2310.         kPD = new Proxy($, handlerWD);
  2311.         mxMapPD.set($, kPD);
  2312.       }
  2313.       delete dh.$;
  2314.       dh.$ = kPD;
  2315.  
  2316.     }
  2317.  
  2318.   } : null;
  2319.  
  2320.  
  2321.   const configureVisibilityObserverT_ = function () {
  2322.     const hostElement = this.hostElement;
  2323.     if (!(hostElement instanceof Node) || hostElement.nodeName === 'NOSCRIPT') {
  2324.       this.unobserve_();
  2325.     } else {
  2326.       return this.configureVisibilityObserver27_();
  2327.     }
  2328.   };
  2329.   const getParentRendererT = function () {
  2330.     const hostElement = this.hostElement;
  2331.     if (!(hostElement instanceof Node) || hostElement.nodeName === 'NOSCRIPT') {
  2332.       return null;
  2333.     } else {
  2334.       return this.getParentRenderer27();
  2335.     }
  2336.   }
  2337.  
  2338.   const attachedT = function () {
  2339.     const hostElement = this.hostElement;
  2340.     if (!(hostElement instanceof Node) || hostElement.nodeName === 'NOSCRIPT') {
  2341.       if (this.isAttached === true) this.isAttached = false;
  2342.       return void 0;
  2343.     } else {
  2344.       return this.attached27();
  2345.     }
  2346.   }
  2347.  
  2348.   const hostElementCleanUp = (dh) => {
  2349.     if (typeof dh.dispose === 'function') {
  2350.       try {
  2351.         if (dh.visibilityMonitor || dh.visibilityObserver) {
  2352.           dh.dispose();
  2353.           dh.visibilityMonitor = null;
  2354.           dh.visibilityObserver = null;
  2355.         }
  2356.       } catch (e) { }
  2357.     }
  2358.     if (typeof dh.detached === 'function') {
  2359.       try {
  2360.         if (dh.visibilityObserverForChild_ || dh.localVisibilityObserver_) {
  2361.           dh.detached();
  2362.           dh.visibilityObserverForChild_ = null;
  2363.           dh.localVisibilityObserver_ = null;
  2364.         }
  2365.       } catch (e) { }
  2366.     }
  2367.   };
  2368.  
  2369.   const setupDataHost_ = (eh) => {
  2370.     if (typeof eh.configureVisibilityObserver_ === 'function' && !eh.configureVisibilityObserver27_) {
  2371.       eh.configureVisibilityObserver27_ = eh.configureVisibilityObserver_;
  2372.       eh.configureVisibilityObserver_ = configureVisibilityObserverT_;
  2373.     }
  2374.     if (typeof eh.getParentRenderer === 'function' && !eh.getParentRenderer27) {
  2375.       eh.getParentRenderer27 = eh.getParentRenderer;
  2376.       eh.getParentRenderer = getParentRendererT;
  2377.     }
  2378.     if (typeof eh.attached === 'function' && !eh.attached27) {
  2379.       eh.attached27 = eh.attached;
  2380.       eh.attached = attachedT;
  2381.     }
  2382.   }
  2383.  
  2384.   const setupDataHost = WEAK_REF_BINDING && setupWF && setupWD ? function (dh, opt) {
  2385.  
  2386.     if (typeof (dh || 0) === 'object') {
  2387.  
  2388.       const eh = (dh.constructor || 0).prototype || dh;
  2389.  
  2390.       setupDataHost_(eh);
  2391.       setupDataHost_(dh);
  2392.  
  2393.       dh.m822 = (dh.m822 || 0) + 1;
  2394.  
  2395.       setupWF(dh, 'hostElement', hostElementCleanUp);
  2396.       setupWF(dh, 'parentComponent');
  2397.       setupWF(dh, 'localVisibilityObserver_');
  2398.       setupWF(dh, 'cachedProviderNode_');
  2399.  
  2400.  
  2401.       setupWF(dh, '__template');
  2402.       setupWF(dh, '__templatizeOwner');
  2403.       setupWF(dh, '__templateInfo');
  2404.  
  2405.       // setupD1(dh, 'root', 1);
  2406.  
  2407.       let elements_;
  2408.       if (!('elements_72' in dh) && (elements_ = dh.elements_) && typeof elements_ === 'object' && Object.keys(elements_).length > 0) setupWF(dh, 'elements_');
  2409.  
  2410.       setupWD(dh);
  2411.     }
  2412.  
  2413.  
  2414.  
  2415.  
  2416.   } : null;
  2417.  
  2418.   PROP_OverReInclusion_AVOID && (() => {
  2419.  
  2420.  
  2421.     if (typeof HTMLElement.prototype.hasOwnProperty72 === 'function' || typeof HTMLElement.prototype.hasOwnProperty !== 'function') return;
  2422.     const f = HTMLElement.prototype.hasOwnProperty72 = HTMLElement.prototype.hasOwnProperty;
  2423.     let byPassVal = null;
  2424.     let byPassCount = 0;
  2425.     let mmw = new Set()
  2426.     HTMLElement.prototype.hasOwnProperty = function (prop) {
  2427.       if (arguments.length !== 1) return f.apply(this, arguments);
  2428.       if (byPassVal !== null && typeof prop === 'string') {
  2429.  
  2430.  
  2431.         if (PROP_OverReInclusion_LIST.has(prop)) {
  2432.  
  2433.           byPassCount++;
  2434.           return byPassVal;
  2435.         }
  2436.  
  2437.         // if(byPassVal === true && !this.hasOwnProperty72(prop)){
  2438.  
  2439.         //   Object.de
  2440.  
  2441.         // }
  2442.  
  2443.         PROP_OverReInclusion_DEBUGLOG && mmw.add(prop);
  2444.  
  2445.  
  2446.       }
  2447.       return this.hasOwnProperty72(prop);
  2448.     }
  2449.  
  2450.  
  2451.     /*
  2452.     
  2453.     
  2454.             z.prototype.forwardDynamicProps = function() {
  2455.                 var B = m(this.inst);
  2456.                 B = h(B);
  2457.                 for (var F = B.next(); !F.done; F = B.next()) {
  2458.                     var H = h(F.value);
  2459.                     F = H.next().value;
  2460.                     H = H.next().value;
  2461.                     my(this, F, H);
  2462.                     r(b) && !ly(F) && Wua(this.inst, F)
  2463.                 }
  2464.             }
  2465.     
  2466.             */
  2467.  
  2468.  
  2469.  
  2470.     let byPassZeroShowed = false;
  2471.     const forwardDynamicPropsGeneral = function () {
  2472.       byPassVal = true;
  2473.       byPassCount = 0;
  2474.       PROP_OverReInclusion_DEBUGLOG && mmw.clear();
  2475.       const ret = this.forwardDynamicProps72();
  2476.       byPassVal = null;
  2477.       if (byPassCount === 0 && !byPassZeroShowed) {
  2478.         byPassZeroShowed = true;
  2479.         console.log('[yt-js-engine-tamer] byPassCount = 0 in forwardDynamicProps')
  2480.       }
  2481.       byPassCount = 0;
  2482.       if (PROP_OverReInclusion_DEBUGLOG && mmw.size > 0) console.log(399, '[yt-js-engine-tamer]', [...mmw])
  2483.       PROP_OverReInclusion_DEBUGLOG && mmw.clear();
  2484.       return ret;
  2485.     };
  2486.  
  2487.     const propCheck = (proto) => {
  2488.       if (typeof (proto || 0) == 'object' && typeof proto.forwardDynamicProps === 'function' && typeof proto.forwardDynamicProps72 !== 'function') {
  2489.         proto.forwardDynamicProps72 = proto.forwardDynamicProps;
  2490.         if (proto.forwardDynamicProps.length === 0) {
  2491.           proto.forwardDynamicProps = forwardDynamicPropsGeneral;
  2492.         }
  2493.       }
  2494.     };
  2495.  
  2496.     const valMap = new WeakMap();
  2497.     Object.defineProperty(HTMLElement.prototype, 'didForwardDynamicProps', {
  2498.       get() {
  2499.         propCheck(this.constructor.prototype);
  2500.         return valMap.get(this);
  2501.       },
  2502.       set(nv) {
  2503.         propCheck(this.constructor.prototype);
  2504.         valMap.set(this, nv);
  2505.         return true;
  2506.       },
  2507.       enumerable: false,
  2508.       configurable: true
  2509.  
  2510.     });
  2511.  
  2512.     promiseForCustomYtElementsReady.then(() => {
  2513.       if (typeof customElements !== 'object' || typeof customElements.define72 === 'function' || typeof customElements.define !== 'function') return;
  2514.       if (customElements.define.length !== 2) return;
  2515.       customElements.define72 = customElements.define;
  2516.       customElements.define = function (b, w) {
  2517.         propCheck(w.prototype);
  2518.         const ret = this.define72(b, w);
  2519.         return ret;
  2520.       }
  2521.     });
  2522.  
  2523.   })();
  2524.  
  2525.  
  2526.   let delay300 = null;
  2527.  
  2528.   if (UNLOAD_DETACHED_POLYMER || WEAK_REF_BINDING) {
  2529.     delay300 = new PromiseExternal();
  2530.     setInterval(() => {
  2531.       delay300.resolve();
  2532.       delay300 = new PromiseExternal();
  2533.     }, 300);
  2534.   }
  2535.  
  2536.   const aDelay = async function () {
  2537.     await delay300.then();
  2538.     await delay300.then();
  2539.   }
  2540.  
  2541.   const convertionFuncMap = new WeakMap();
  2542.   let val_kevlar_should_maintain_stable_list = null;
  2543.  
  2544.   const createStampDomArrayFn_ = (fn) => {
  2545.     if (val_kevlar_should_maintain_stable_list === null) {
  2546.       const config_ = ((window.yt || 0).config_ || 0);
  2547.       val_kevlar_should_maintain_stable_list = ((config_ || 0).EXPERIMENT_FLAGS || 0).kevlar_should_maintain_stable_list === true
  2548.     }
  2549.     const gn = function (a, b, c, d, e, h) {
  2550.       const isNonEmptyArray = (a || 0).length >= 1
  2551.       if (!isNonEmptyArray) {
  2552.         return fn.call(this, undefined, b, undefined, d);
  2553.       } else if (h === undefined && typeof b === 'string' && c && typeof c === 'object' && this.is && val_kevlar_should_maintain_stable_list) {
  2554.         if (c.clientSideToggleMenuItemRenderer) {
  2555.           h = false;
  2556.         } else {
  2557.           h = true;
  2558.         }
  2559.       }
  2560.       return fn.call(this, a, b, c, d, e, h)
  2561.     }
  2562.     gn.originalFn = fn;
  2563.     convertionFuncMap.set(fn, gn);
  2564.     return gn;
  2565.   }
  2566.  
  2567.   const fixStampDomArrayStableList = (h) => {
  2568.     if (!h.stampDomArray_) return;
  2569.     const proto = h.__proto__;
  2570.     const f = proto.stampDomArray_;
  2571.     if (!proto.stampDomArrayF001_ && typeof f === 'function' && f.length === 6) {
  2572.       proto.stampDomArrayF001_ = 1;
  2573.       proto.stampDomArray_ = convertionFuncMap.get(f) || createStampDomArrayFn_(f);
  2574.     }
  2575.   }
  2576.  
  2577.   const weakenStampReferences = (() => {
  2578.  
  2579.     const DEBUG_STAMP = false;
  2580.  
  2581.     const s1 = Symbol();
  2582.     const handler1 = {
  2583.       get(target, prop, receiver) {
  2584.         if (prop === 'object') {
  2585.           return kRef(target[s1]); // avoid memory leakage
  2586.         }
  2587.         if (prop === '__proxy312__') return 1;
  2588.         return target[prop];
  2589.       }
  2590.     };
  2591.     const handler2 = {
  2592.       get(target, prop, receiver) {
  2593.         if (prop === 'indexSplices') {
  2594.           return kRef(target[s1]); // avoid memory leakage
  2595.         }
  2596.         if (prop === '__proxy312__') return 1;
  2597.         return target[prop];
  2598.       }
  2599.     }
  2600.     return (h) => {
  2601.  
  2602.       if (h.rendererStamperApplyChangeRecord_ || h.stampDomArraySplices_) {
  2603.         const proto = h.__proto__;
  2604.         if (!proto.yzxer && (proto.rendererStamperApplyChangeRecord_ || proto.stampDomArraySplices_)) {
  2605.           proto.yzxer = 1;
  2606.  
  2607.           const list = [
  2608.             // "rendererStamperObserver_", // 3  ==> rendererStamperApplyChangeRecord_
  2609.             "rendererStamperApplyChangeRecord_", // 3
  2610.             "forwardRendererStamperChanges_", // 3
  2611.             "stampDomArraySplices_", // 3
  2612.             "stampDomArray_", // 6
  2613.             "deferRenderStamperBinding_", // 3
  2614.           ];
  2615.           for (const key of list) {
  2616.             const pey = `${key}$wq0iw_`;
  2617.             const vKey = proto[key];
  2618.             if (typeof vKey !== 'function') continue;
  2619.             if (proto[pey] || vKey.length === 0) continue;
  2620.  
  2621.             if (key === 'stampDomArraySplices_' && vKey.length === 3) {
  2622.               proto[pey] = vKey;
  2623.               proto[key] = function (a, b, c) {
  2624.  
  2625.                 if (typeof a === 'string' && typeof b === 'string' && typeof c === 'object' && c && c.indexSplices && c.indexSplices.length >= 1 && !c.indexSplices.rzgjr) {
  2626.  
  2627.                   c.indexSplices = c.indexSplices.map(e => {
  2628.                     if (e.__proxy312__) return e;
  2629.                     e[s1] = mWeakRef(e.object);
  2630.                     e.object = null;
  2631.                     return new Proxy(e, handler1);
  2632.                   });
  2633.                   c.indexSplices.rzgjr = 1;
  2634.  
  2635.                   c[s1] = mWeakRef(c.indexSplices);
  2636.                   c.indexSplices = null;
  2637.                   c = new Proxy(c, handler2)
  2638.                   arguments[2] = c;
  2639.  
  2640.                 }
  2641.                 // console.log(key, arguments.length, [...arguments]);
  2642.                 return proto[pey].call(this, a, b, c);
  2643.               }
  2644.  
  2645.             } else if (key === 'rendererStamperApplyChangeRecord_' && vKey.length === 3) {
  2646.  
  2647.               // Nil
  2648.  
  2649.             } else if (DEBUG_STAMP) {
  2650.  
  2651.               console.log(proto.isRenderer_, 'ms_' + key, vKey.length, h.is)
  2652.               proto[pey] = vKey;
  2653.               proto[key] = function () {
  2654.                 if (key === 'rendererStamperApplyChangeRecord_' && typeof arguments[3] === 'object') {
  2655.                   console.log(key, arguments.length, { value: arguments[3].value, base: arguments[3].base, })
  2656.                 }
  2657.                 console.log(key, arguments.length, [...arguments]);
  2658.                 return proto[pey].apply(this, arguments);
  2659.               }
  2660.  
  2661.             }
  2662.  
  2663.           }
  2664.  
  2665.  
  2666.           // const m = (Object.mkss = Object.mkss || new Set());
  2667.           // Object.keys(h.__proto__).filter(e => e.toLowerCase().includes('stamp') && typeof h[e] === 'function').forEach(e => m.add(e))
  2668.           // console.log([...m])
  2669.         }
  2670.       }
  2671.  
  2672.     }
  2673.   })();
  2674.  
  2675.   const setupDiscreteTasks = (h, rb) => {
  2676.  
  2677.     if (rb) {
  2678.       if (h.ky36) return;
  2679.     }
  2680.  
  2681.  
  2682.     if (typeof h.onYtRendererstamperFinished === 'function' && !(h.onYtRendererstamperFinished.km34)) {
  2683.       const f = h.onYtRendererstamperFinished;
  2684.       const g = ump3.get(f) || function () {
  2685.         if (this.updateChildVisibilityProperties && !this.markDirty) {
  2686.           return f.apply(this, arguments);
  2687.         }
  2688.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  2689.       }
  2690.       ump3.set(f, g);
  2691.       g.km34 = 1;
  2692.       h.onYtRendererstamperFinished = g;
  2693.  
  2694.     }
  2695.  
  2696.     if (typeof h.onYtUpdateDescriptionAction === 'function' && !(h.onYtUpdateDescriptionAction.km34)) {
  2697.       const f = h.onYtUpdateDescriptionAction;
  2698.       const g = ump3.get(f) || function (a) {
  2699.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  2700.       }
  2701.       ump3.set(f, g);
  2702.       g.km34 = 1;
  2703.       h.onYtUpdateDescriptionAction = g;
  2704.  
  2705.     }
  2706.  
  2707.     if (typeof h.handleUpdateDescriptionAction === 'function' && !(h.handleUpdateDescriptionAction.km34)) {
  2708.       const f = h.handleUpdateDescriptionAction;
  2709.       const g = ump3.get(f) || function (a) {
  2710.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  2711.       }
  2712.       ump3.set(f, g);
  2713.       g.km34 = 1;
  2714.       h.handleUpdateDescriptionAction = g;
  2715.  
  2716.     }
  2717.  
  2718.     if (typeof h.handleUpdateLiveChatPollAction === 'function' && !(h.handleUpdateLiveChatPollAction.km34)) {
  2719.       const f = h.handleUpdateLiveChatPollAction;
  2720.       const g = ump3.get(f) || function (a) {
  2721.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  2722.       }
  2723.       ump3.set(f, g);
  2724.       g.km34 = 1;
  2725.       h.handleUpdateLiveChatPollAction = g;
  2726.  
  2727.     }
  2728.  
  2729.     if (typeof h.onTextChanged === 'function' && !(h.onTextChanged.km34)) {
  2730.       const f = h.onTextChanged;
  2731.       const g = ump3.get(f) || function () {
  2732.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  2733.       }
  2734.       ump3.set(f, g);
  2735.       g.km34 = 1;
  2736.       h.onTextChanged = g;
  2737.  
  2738.     }
  2739.  
  2740.     if (typeof h.onVideoDataChange === 'function' && !(h.onVideoDataChange.km34)) {
  2741.       const f = h.onVideoDataChange;
  2742.       const g = ump3.get(f) || function (a) {
  2743.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  2744.       }
  2745.       ump3.set(f, g);
  2746.       g.km34 = 1;
  2747.       h.onVideoDataChange = g;
  2748.  
  2749.     }
  2750.  
  2751.     if (typeof h.onVideoDataChange_ === 'function' && !(h.onVideoDataChange_.km34)) {
  2752.       const f = h.onVideoDataChange_;
  2753.       const g = ump3.get(f) || function () {
  2754.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  2755.       }
  2756.       ump3.set(f, g);
  2757.       g.km34 = 1;
  2758.       h.onVideoDataChange_ = g;
  2759.  
  2760.     }
  2761.  
  2762.     /*
  2763.     // affect chat message icon tooltips
  2764.     if (typeof h.addTooltips === 'function' && !(h.addTooltips.km34)) {
  2765.  
  2766.       const f = h.addTooltips;
  2767.       const g = ump3.get(f) || function () {
  2768.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  2769.       }
  2770.       ump3.set(f, g);
  2771.       g.km34 = 1;
  2772.       h.addTooltips = g;
  2773.  
  2774.     }
  2775.     */
  2776.     /*
  2777.         if (typeof h.onMouseOver_ === 'function' && !(h.onMouseOver_.km34) && typeof h.createTooltipIfRequired_ === 'function') {
  2778.             console.log(212, h.is);
  2779.             const f = h.onMouseOver_;
  2780.           const g = ump3.get(f) || function () {
  2781.     
  2782.               if (!this.__mEZ__) {
  2783.     
  2784.     
  2785.                   const w = document.createElement;
  2786.                   let EU = null;
  2787.                   document.createElement = function () {
  2788.                       let r = w.apply(this, arguments);
  2789.                       EU = r;
  2790.                       return r;
  2791.                   };
  2792.                   let done = false;
  2793.                   try {
  2794.                       this.polymerController.createTooltipIfRequired_();
  2795.                       done = true;
  2796.                   } catch (e) {
  2797.     
  2798.                   }
  2799.                   if (!done) {
  2800.                       try {
  2801.                           this.createTooltipIfRequired_();
  2802.                           done = true;
  2803.                       } catch (e) {
  2804.     
  2805.                       }
  2806.     
  2807.                   }
  2808.                   this.__mEZ__ = EU;
  2809.                   document.createElement = w;
  2810.               }
  2811.               if(this.__mEZ__){
  2812.                 this.__mEZ__.remove();
  2813.                 // this.__mEZ__.for = null;
  2814.                 [...this.__mEZ__.querySelectorAll('.hidden')].forEach(e=>e.classList.remove('hidden'))
  2815.               }
  2816.             console.log(212,this, this.is, this.__mEZ__)
  2817.             return f.apply(this, arguments)
  2818.           }
  2819.           ump3.set(f, g);
  2820.           g.km34 = 1;
  2821.           h.onMouseOver_ = g;
  2822.     
  2823.         }
  2824.         */
  2825.  
  2826.  
  2827.     if (typeof h.addTooltips_ === 'function' && !(h.addTooltips_.km34)) {
  2828.  
  2829.       const f = h.addTooltips_;
  2830.       const g = ump3.get(f) || function () {
  2831.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  2832.       }
  2833.       ump3.set(f, g);
  2834.       g.km34 = 1;
  2835.       h.addTooltips_ = g;
  2836.  
  2837.     }
  2838.  
  2839.     if (typeof h.updateRenderedElements === 'function' && !(h.updateRenderedElements.km34)) {
  2840.  
  2841.       const f = h.updateRenderedElements;
  2842.       const g = ump3.get(f) || function () {
  2843.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  2844.       }
  2845.       ump3.set(f, g);
  2846.       g.km34 = 1;
  2847.       h.updateRenderedElements = g;
  2848.  
  2849.     }
  2850.  
  2851.     if ((WEAK_REF_BINDING_CONTROL & 2) && typeof h.loadPage_ === 'function' && !(h.loadPage_.km34)) {
  2852.       const f = h.loadPage_;
  2853.       const g = ump3.get(f) || function (a) {
  2854.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  2855.       }
  2856.       ump3.set(f, g);
  2857.       g.km34 = 1;
  2858.       h.loadPage_ = g;
  2859.  
  2860.     }
  2861.     // updatePageData_ : possible conflict with Omit ShadyDOM
  2862.     if ((WEAK_REF_BINDING_CONTROL & 2) && typeof h.updatePageData_ === 'function' && !(h.updatePageData_.km34)) {
  2863.       const f = h.updatePageData_;
  2864.       const g = ump3.get(f) || function (a) {
  2865.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  2866.       }
  2867.       ump3.set(f, g);
  2868.       g.km34 = 1;
  2869.       h.updatePageData_ = g;
  2870.  
  2871.     }
  2872.  
  2873.  
  2874.     if ((WEAK_REF_BINDING_CONTROL & 1) && typeof h.onFocus_ === 'function' && !(h.onFocus_.km34)) {
  2875.  
  2876.       const f = h.onFocus_;
  2877.       const g = ump3.get(f) || function () {
  2878.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  2879.       }
  2880.       ump3.set(f, g);
  2881.       g.km34 = 1;
  2882.       h.onFocus_ = g;
  2883.  
  2884.     }
  2885.  
  2886.     if ((WEAK_REF_BINDING_CONTROL & 1) && typeof h.onBlur_ === 'function' && !(h.onBlur_.km34)) {
  2887.  
  2888.       const f = h.onBlur_;
  2889.       const g = ump3.get(f) || function () {
  2890.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  2891.       }
  2892.       ump3.set(f, g);
  2893.       g.km34 = 1;
  2894.       h.onBlur_ = g;
  2895.  
  2896.     }
  2897.  
  2898.  
  2899.     if ((WEAK_REF_BINDING_CONTROL & 1) && typeof h.buttonClassChanged_ === 'function' && !(h.buttonClassChanged_.km34)) {
  2900.  
  2901.       const f = h.buttonClassChanged_;
  2902.       const g = ump3.get(f) || function (a, b) {
  2903.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  2904.       }
  2905.       ump3.set(f, g);
  2906.       g.km34 = 1;
  2907.       h.buttonClassChanged_ = g;
  2908.  
  2909.     }
  2910.  
  2911.     if ((WEAK_REF_BINDING_CONTROL & 1) && typeof h.buttonIconChanged_ === 'function' && !(h.buttonIconChanged_.km34)) {
  2912.  
  2913.       const f = h.buttonIconChanged_;
  2914.       const g = ump3.get(f) || function (a) {
  2915.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  2916.       }
  2917.       ump3.set(f, g);
  2918.       g.km34 = 1;
  2919.       h.buttonIconChanged_ = g;
  2920.  
  2921.     }
  2922.  
  2923.     if ((WEAK_REF_BINDING_CONTROL & 1) && typeof h.dataChangedInBehavior_ === 'function' && !(h.dataChangedInBehavior_.km34)) {
  2924.  
  2925.       const f = h.dataChangedInBehavior_;
  2926.       const g = ump3.get(f) || function () {
  2927.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  2928.       }
  2929.       ump3.set(f, g);
  2930.       g.km34 = 1;
  2931.       h.dataChangedInBehavior_ = g;
  2932.  
  2933.     }
  2934.  
  2935.     if ((WEAK_REF_BINDING_CONTROL & 1) && typeof h.continuationsChanged_ === 'function' && !(h.continuationsChanged_.km34)) {
  2936.  
  2937.       const f = h.continuationsChanged_;
  2938.       const g = ump3.get(f) || function () {
  2939.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  2940.       }
  2941.       ump3.set(f, g);
  2942.       g.km34 = 1;
  2943.       h.continuationsChanged_ = g;
  2944.  
  2945.     }
  2946.  
  2947.  
  2948.     if ((WEAK_REF_BINDING_CONTROL & 1) && typeof h.forceChatPoll_ === 'function' && !(h.forceChatPoll_.km34)) {
  2949.  
  2950.       const f = h.forceChatPoll_;
  2951.       const g = ump3.get(f) || function (a) {
  2952.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  2953.       }
  2954.       ump3.set(f, g);
  2955.       g.km34 = 1;
  2956.       h.forceChatPoll_ = g;
  2957.  
  2958.     }
  2959.  
  2960.     if ((WEAK_REF_BINDING_CONTROL & 1) && typeof h.onEndpointClick_ === 'function' && !(h.onEndpointClick_.km34)) {
  2961.  
  2962.       const f = h.onEndpointClick_;
  2963.       const g = ump3.get(f) || function (a) {
  2964.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  2965.       }
  2966.       ump3.set(f, g);
  2967.       g.km34 = 1;
  2968.       h.onEndpointClick_ = g;
  2969.  
  2970.     }
  2971.  
  2972.     if ((WEAK_REF_BINDING_CONTROL & 1) && typeof h.onEndpointTap_ === 'function' && !(h.onEndpointTap_.km34)) {
  2973.  
  2974.       const f = h.onEndpointTap_;
  2975.       const g = ump3.get(f) || function (a) {
  2976.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  2977.       }
  2978.       ump3.set(f, g);
  2979.       g.km34 = 1;
  2980.       h.onEndpointTap_ = g;
  2981.  
  2982.     }
  2983.  
  2984.     if ((WEAK_REF_BINDING_CONTROL & 1) && typeof h.handleClick_ === 'function' && !(h.handleClick_.km34)) {
  2985.  
  2986.       const f = h.handleClick_;
  2987.       const g = ump3.get(f) || function (a, b) {
  2988.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  2989.       }
  2990.       ump3.set(f, g);
  2991.       g.km34 = 1;
  2992.       h.handleClick_ = g;
  2993.  
  2994.     }
  2995.  
  2996.     if ((WEAK_REF_BINDING_CONTROL & 1) && typeof h.onReadyStateChange_ === 'function' && !(h.onReadyStateChange_.km34)) {
  2997.  
  2998.       const f = h.onReadyStateChange_;
  2999.       const g = ump3.get(f) || function () {
  3000.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3001.       }
  3002.       ump3.set(f, g);
  3003.       g.km34 = 1;
  3004.       h.onReadyStateChange_ = g;
  3005.  
  3006.     }
  3007.  
  3008.     if ((WEAK_REF_BINDING_CONTROL & 1) && typeof h.onReadyStateChangeEntryPoint_ === 'function' && !(h.onReadyStateChangeEntryPoint_.km34)) {
  3009.  
  3010.       const f = h.onReadyStateChangeEntryPoint_;
  3011.       const g = ump3.get(f) || function () {
  3012.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3013.       }
  3014.       ump3.set(f, g);
  3015.       g.km34 = 1;
  3016.       h.onReadyStateChangeEntryPoint_ = g;
  3017.  
  3018.     }
  3019.  
  3020.     if ((WEAK_REF_BINDING_CONTROL & 1) && typeof h.readyStateChangeHandler_ === 'function' && !(h.readyStateChangeHandler_.km34)) {
  3021.  
  3022.       const f = h.readyStateChangeHandler_;
  3023.       const g = ump3.get(f) || function (a) {
  3024.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3025.       }
  3026.       ump3.set(f, g);
  3027.       g.km34 = 1;
  3028.       h.readyStateChangeHandler_ = g;
  3029.  
  3030.     }
  3031.  
  3032.     if (typeof h.xmlHttpHandler_ === 'function' && !(h.xmlHttpHandler_.km34)) {
  3033.  
  3034.       const f = h.xmlHttpHandler_;
  3035.       const g = ump3.get(f) || function (a) {
  3036.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3037.       }
  3038.       ump3.set(f, g);
  3039.       g.km34 = 1;
  3040.       h.xmlHttpHandler_ = g;
  3041.  
  3042.     }
  3043.  
  3044.     if ((WEAK_REF_BINDING_CONTROL & 1) && typeof h.executeCallbacks_ === 'function' && !(h.executeCallbacks_.km34)) {
  3045.  
  3046.       const f = h.executeCallbacks_; // overloaded
  3047.       const g = ump3.get(f) || function (a) {
  3048.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3049.       }
  3050.       ump3.set(f, g);
  3051.       g.km34 = 1;
  3052.       h.executeCallbacks_ = g;
  3053.  
  3054.     }
  3055.  
  3056.     if ((WEAK_REF_BINDING_CONTROL & 1) && typeof h.handleInvalidationData_ === 'function' && !(h.handleInvalidationData_.km34)) {
  3057.  
  3058.       const f = h.handleInvalidationData_;
  3059.       const g = ump3.get(f) || function (a, b) {
  3060.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3061.       }
  3062.       ump3.set(f, g);
  3063.       g.km34 = 1;
  3064.       h.handleInvalidationData_ = g;
  3065.  
  3066.     }
  3067.  
  3068.     if (typeof h.onInput_ === 'function' && !(h.onInput_.km34)) {
  3069.  
  3070.       const f = h.onInput_;
  3071.       const g = ump3.get(f) || function () {
  3072.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3073.       }
  3074.       ump3.set(f, g);
  3075.       g.km34 = 1;
  3076.       h.onInput_ = g;
  3077.  
  3078.     }
  3079.     if (typeof h.trigger_ === 'function' && !(h.trigger_.km34)) {
  3080.  
  3081.       const f = h.trigger_;
  3082.       const g = ump3.get(f) || function (a) {
  3083.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3084.       }
  3085.       ump3.set(f, g);
  3086.       g.km34 = 1;
  3087.       h.trigger_ = g;
  3088.  
  3089.     }
  3090.  
  3091.     if (typeof h.requestData_ === 'function' && !(h.requestData_.km34)) {
  3092.  
  3093.       const f = h.requestData_;
  3094.       const g = ump3.get(f) || function (a) {
  3095.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3096.       }
  3097.       ump3.set(f, g);
  3098.       g.km34 = 1;
  3099.       h.requestData_ = g;
  3100.  
  3101.     }
  3102.  
  3103.     if (typeof h.onLoadReloadContinuation_ === 'function' && !(h.onLoadReloadContinuation_.km34)) {
  3104.  
  3105.       const f = h.onLoadReloadContinuation_;
  3106.       const g = ump3.get(f) || function (a, b) {
  3107.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3108.       }
  3109.       ump3.set(f, g);
  3110.       g.km34 = 1;
  3111.       h.onLoadReloadContinuation_ = g;
  3112.  
  3113.     }
  3114.  
  3115.     if (typeof h.onLoadIncrementalContinuation_ === 'function' && !(h.onLoadIncrementalContinuation_.km34)) {
  3116.  
  3117.       const f = h.onLoadIncrementalContinuation_;
  3118.       const g = ump3.get(f) || function (a, b) {
  3119.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3120.       }
  3121.       ump3.set(f, g);
  3122.       g.km34 = 1;
  3123.       h.onLoadIncrementalContinuation_ = g;
  3124.  
  3125.     }
  3126.  
  3127.     if (typeof h.onLoadSeekContinuation_ === 'function' && !(h.onLoadSeekContinuation_.km34)) {
  3128.  
  3129.       const f = h.onLoadSeekContinuation_;
  3130.       const g = ump3.get(f) || function (a, b) {
  3131.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3132.       }
  3133.       ump3.set(f, g);
  3134.       g.km34 = 1;
  3135.       h.onLoadSeekContinuation_ = g;
  3136.  
  3137.     }
  3138.     if (typeof h.onLoadReplayContinuation_ === 'function' && !(h.onLoadReplayContinuation_.km34)) {
  3139.  
  3140.       const f = h.onLoadReplayContinuation_;
  3141.       const g = ump3.get(f) || function (a, b) {
  3142.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3143.       }
  3144.       ump3.set(f, g);
  3145.       g.km34 = 1;
  3146.       h.onLoadReplayContinuation_ = g;
  3147.  
  3148.     }
  3149.     if ((WEAK_REF_BINDING_CONTROL & 1) && typeof h.onNavigate_ === 'function' && !(h.onNavigate_.km34)) {
  3150.  
  3151.       const f = h.onNavigate_;
  3152.       const g = ump3.get(f) || function (a) {
  3153.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3154.       }
  3155.       ump3.set(f, g);
  3156.       g.km34 = 1;
  3157.       h.onNavigate_ = g;
  3158.  
  3159.     }
  3160.  
  3161.     if ((WEAK_REF_BINDING_CONTROL & 1) && typeof h.ytRendererBehaviorDataObserver_ === 'function' && !(h.ytRendererBehaviorDataObserver_.km34)) {
  3162.  
  3163.       const f = h.ytRendererBehaviorDataObserver_;
  3164.       const g = ump3.get(f) || function () {
  3165.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3166.       }
  3167.       ump3.set(f, g);
  3168.       g.km34 = 1;
  3169.       h.ytRendererBehaviorDataObserver_ = g;
  3170.  
  3171.     }
  3172.  
  3173.     if ((WEAK_REF_BINDING_CONTROL & 1) && typeof h.ytRendererBehaviorTargetIdObserver_ === 'function' && !(h.ytRendererBehaviorTargetIdObserver_.km34)) {
  3174.  
  3175.       const f = h.ytRendererBehaviorTargetIdObserver_;
  3176.       const g = ump3.get(f) || function () {
  3177.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3178.       }
  3179.       ump3.set(f, g);
  3180.       g.km34 = 1;
  3181.       h.ytRendererBehaviorTargetIdObserver_ = g;
  3182.  
  3183.     }
  3184.  
  3185.     if ((WEAK_REF_BINDING_CONTROL & 1) && typeof h.unregisterRenderer_ === 'function' && !(h.unregisterRenderer_.km34)) {
  3186.  
  3187.       const f = h.unregisterRenderer_;
  3188.       const g = ump3.get(f) || function (a) {
  3189.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3190.       }
  3191.       ump3.set(f, g);
  3192.       g.km34 = 1;
  3193.       h.unregisterRenderer_ = g;
  3194.  
  3195.     }
  3196.  
  3197.     if ((WEAK_REF_BINDING_CONTROL & 1) && typeof h.textChanged_ === 'function' && !(h.textChanged_.km34)) {
  3198.  
  3199.       const f = h.textChanged_;
  3200.       const g = ump3.get(f) || function (a) {
  3201.         if (void 0 !== this.isAttached) {
  3202.           const hostElement = this.hostElement;
  3203.           if (!(hostElement instanceof Node) || hostElement.nodeName === 'NOSCRIPT') {
  3204.             return;
  3205.           }
  3206.         }
  3207.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3208.       }
  3209.       ump3.set(f, g);
  3210.       g.km34 = 1;
  3211.       h.textChanged_ = g;
  3212.  
  3213.     }
  3214.  
  3215.  
  3216.  
  3217.     /**
  3218.      *
  3219.      * Neglect following
  3220.      *
  3221.      * h.onYtAction_
  3222.      * h.startLoadingWatch [ buggy for yt-player-updated ]
  3223.      * h.deferRenderStamperBinding_
  3224.      *
  3225.      * h.stampDomArray_
  3226.      * h.stampDomArraySplices_
  3227.      *
  3228.      */
  3229.  
  3230.  
  3231.     // RP.prototype.searchChanged_ = RP.prototype.searchChanged_;
  3232.     // RP.prototype.skinToneChanged_ = RP.prototype.skinToneChanged_;
  3233.     // RP.prototype.onEmojiHover_ = RP.prototype.onEmojiHover_;
  3234.     // RP.prototype.onSelectCategory_ = RP.prototype.onSelectCategory_;
  3235.     // RP.prototype.onShowEmojiVariantSelector = RP.prototype.onShowEmojiVariantSelector;
  3236.     // RP.prototype.updateCategoriesAndPlaceholder_ = RP.prototype.updateCategoriesAndPlaceholder_;
  3237.  
  3238.     if (typeof h.searchChanged_ === 'function' && !(h.searchChanged_.km34)) {
  3239.  
  3240.       const f = h.searchChanged_;
  3241.       const g = ump3.get(f) || function () {
  3242.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3243.       }
  3244.       ump3.set(f, g);
  3245.       g.km34 = 1;
  3246.       h.searchChanged_ = g;
  3247.  
  3248.     }
  3249.  
  3250.     if (typeof h.skinToneChanged_ === 'function' && !(h.skinToneChanged_.km34)) {
  3251.  
  3252.       const f = h.skinToneChanged_;
  3253.       const g = ump3.get(f) || function (a) {
  3254.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3255.       }
  3256.       ump3.set(f, g);
  3257.       g.km34 = 1;
  3258.       h.skinToneChanged_ = g;
  3259.  
  3260.     }
  3261.  
  3262.     if (typeof h.onEmojiHover_ === 'function' && !(h.onEmojiHover_.km34)) {
  3263.  
  3264.       const f = h.onEmojiHover_;
  3265.       const g = ump3.get(f) || function (a) {
  3266.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3267.       }
  3268.       ump3.set(f, g);
  3269.       g.km34 = 1;
  3270.       h.onEmojiHover_ = g;
  3271.  
  3272.     }
  3273.  
  3274.     if (typeof h.onSelectCategory_ === 'function' && !(h.onSelectCategory_.km34)) {
  3275.  
  3276.       const f = h.onSelectCategory_;
  3277.       const g = ump3.get(f) || function (a) {
  3278.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3279.       }
  3280.       ump3.set(f, g);
  3281.       g.km34 = 1;
  3282.       h.onSelectCategory_ = g;
  3283.  
  3284.     }
  3285.  
  3286.     if (typeof h.onShowEmojiVariantSelector === 'function' && !(h.onShowEmojiVariantSelector.km34)) {
  3287.  
  3288.       const f = h.onShowEmojiVariantSelector;
  3289.       const g = ump3.get(f) || function (a) {
  3290.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3291.       }
  3292.       ump3.set(f, g);
  3293.       g.km34 = 1;
  3294.       h.onShowEmojiVariantSelector = g;
  3295.  
  3296.     }
  3297.  
  3298.     if (typeof h.updateCategoriesAndPlaceholder_ === 'function' && !(h.updateCategoriesAndPlaceholder_.km34)) {
  3299.  
  3300.       const f = h.updateCategoriesAndPlaceholder_;
  3301.       const g = ump3.get(f) || function () {
  3302.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3303.       }
  3304.       ump3.set(f, g);
  3305.       g.km34 = 1;
  3306.       h.updateCategoriesAndPlaceholder_ = g;
  3307.  
  3308.     }
  3309.  
  3310.     if (typeof h.watchPageActiveChanged_ === 'function' && !(h.watchPageActiveChanged_.km34)) {
  3311.  
  3312.       const f = h.watchPageActiveChanged_;
  3313.       const g = ump3.get(f) || function () {
  3314.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3315.       }
  3316.       ump3.set(f, g);
  3317.       g.km34 = 1;
  3318.       h.watchPageActiveChanged_ = g;
  3319.  
  3320.     }
  3321.  
  3322.     if (typeof h.activate_ === 'function' && !(h.activate_.km34)) {
  3323.  
  3324.       const f = h.activate_;
  3325.       const g = ump3.get(f) || function () {
  3326.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3327.       }
  3328.       ump3.set(f, g);
  3329.       g.km34 = 1;
  3330.       h.activate_ = g;
  3331.  
  3332.     }
  3333.     if (typeof h.onYtPlaylistDataUpdated_ === 'function' && !(h.onYtPlaylistDataUpdated_.km34)) {
  3334.  
  3335.       const f = h.onYtPlaylistDataUpdated_;
  3336.       const g = ump3.get(f) || function () {
  3337.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3338.       }
  3339.       ump3.set(f, g);
  3340.       g.km34 = 1;
  3341.       h.onYtPlaylistDataUpdated_ = g;
  3342.  
  3343.     }
  3344.  
  3345.     FIX_stampDomArray_stableList && fixStampDomArrayStableList(h);
  3346.     const ENABLE_weakenStampReferencesQ = ENABLE_weakenStampReferences && typeof DocumentTimeline !== 'undefined' && typeof WeakRef !== 'undefined';
  3347.     ENABLE_weakenStampReferencesQ && weakenStampReferences(h);
  3348.  
  3349.  
  3350.     /**
  3351.      *
  3352.      * Neglect following
  3353.      *
  3354.      * h.rendererStamperObserver_
  3355.      * h.rendererStamperApplyChangeRecord_
  3356.      * h.flushRenderStamperComponentBindings_
  3357.      * h.forwardRendererStamperChanges_
  3358.      *
  3359.      */
  3360.  
  3361.     if (typeof h.tryRenderChunk_ === 'function' && !(h.tryRenderChunk_.km34)) {
  3362.  
  3363.       const f = h.tryRenderChunk_;
  3364.       const g = ump3.get(f) || function () {
  3365.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3366.       }
  3367.       ump3.set(f, g);
  3368.       g.km34 = 1;
  3369.       h.tryRenderChunk_ = g;
  3370.  
  3371.     }
  3372.  
  3373.  
  3374.     if (typeof h.renderChunk_ === 'function' && !(h.renderChunk_.km34)) {
  3375.  
  3376.       const f = h.renderChunk_;
  3377.       const g = ump3.get(f) || function () {
  3378.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3379.       }
  3380.       ump3.set(f, g);
  3381.       g.km34 = 1;
  3382.       h.renderChunk_ = g;
  3383.  
  3384.     }
  3385.  
  3386.     if (typeof h.deepLazyListObserver_ === 'function' && !(h.deepLazyListObserver_.km34)) {
  3387.  
  3388.       const f = h.deepLazyListObserver_;
  3389.       const g = ump3.get(f) || function () {
  3390.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3391.       }
  3392.       ump3.set(f, g);
  3393.       g.km34 = 1;
  3394.       h.deepLazyListObserver_ = g;
  3395.  
  3396.     }
  3397.  
  3398.     if (typeof h.onItemsUpdated_ === 'function' && !(h.onItemsUpdated_.km34)) {
  3399.  
  3400.       const f = h.onItemsUpdated_;
  3401.       const g = ump3.get(f) || function () {
  3402.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3403.       }
  3404.       ump3.set(f, g);
  3405.       g.km34 = 1;
  3406.       h.onItemsUpdated_ = g;
  3407.  
  3408.     }
  3409.  
  3410.     if (typeof h.requestRenderChunk_ === 'function' && !(h.requestRenderChunk_.km34)) {
  3411.  
  3412.       const f = h.requestRenderChunk_;
  3413.       const g = ump3.get(f) || function () {
  3414.         Promise.resolve().then(() => f.apply(this, arguments)).catch(console.log);
  3415.       }
  3416.       ump3.set(f, g);
  3417.       g.km34 = 1;
  3418.       h.requestRenderChunk_ = g;
  3419.  
  3420.     }
  3421.  
  3422.     /**
  3423.      *
  3424.      * Neglect following
  3425.      *
  3426.      * h.dataChanged_ [ buggy for page swtiching ]
  3427.      *
  3428.      * h.updateChangeRecord_ [ see https://github.com/cyfung1031/userscript-supports/issues/20 ]
  3429.      *
  3430.      * h.cancelPendingTasks_
  3431.      * h.fillRange_
  3432.      * h.addTextNodes_
  3433.      * h.updateText_
  3434.      * h.stampTypeChanged_
  3435.      *
  3436.      */
  3437.  
  3438.  
  3439.   }
  3440.  
  3441.   const keyStConnectedCallback = Symbol(); // avoid copying the value
  3442.  
  3443.   // const keyStDisconnectedCallback = Symbol(); // avoid copying the value
  3444.   const cmf = new WeakMap();
  3445.   const dmf = new WeakMap();
  3446.  
  3447.   const gvGenerator = (nv) => {
  3448.     return function () {
  3449.       const cnt = insp(this);
  3450.       const hostElement = cnt.hostElement || 0;
  3451.       const dollar = hostElement ? (this.$ || indr(this)) : 0;
  3452.       let p = (hostElement instanceof HTMLElement) && (dollar || !this.is);
  3453.       if (p && (!dollar && !this.is)) {
  3454.         const nodeName = hostElement.nodeName;
  3455.         if (typeof nodeName !== 'string') {
  3456.           // just in case
  3457.         } else if (nodeName.startsWith("DOM-")) {
  3458.           // dom-if, dom-repeat, etc
  3459.         } else {
  3460.           // yt element - new model, yt-xxxx, anixxxxxx
  3461.           p = false;
  3462.         }
  3463.       }
  3464.       if (p) {
  3465.         if (typeof cnt.markDirty === 'function') {
  3466.           // the yt element might call markDirty (occasionally)
  3467.           p = false;
  3468.         } else if (this.is === 'ytd-engagement-panel-section-list-renderer') {
  3469.           // see https://github.com/cyfung1031/userscript-supports/issues/20
  3470.           p = false;
  3471.         }
  3472.       }
  3473.       if (p) {
  3474.  
  3475.         // << dom-repeat & dom-if >>
  3476.  
  3477.         // sequence on the same instance
  3478.         this[qm57] = (this[qm57] || Promise.resolve()).then(() => nv.apply(this, arguments)).catch(console.log);
  3479.       } else {
  3480.         nv.apply(this, arguments);
  3481.       }
  3482.     };
  3483.   }
  3484.  
  3485.   // const assignedHolderWS = new WeakSet();
  3486.  
  3487.   const setupWeakRef = (h) => {
  3488.  
  3489.  
  3490.  
  3491.     /*
  3492.     if(typeof h.is === 'string'){
  3493.  
  3494.       const holder = h.hostElement || h;
  3495.       if (holder instanceof Node) {
  3496.         if (!assignedHolderWS.has(holder)) {
  3497.           assignedHolderWS.add(holder);
  3498.           h.kz62 = 0;
  3499.         }
  3500.       }
  3501.  
  3502.     }
  3503.  
  3504.     */
  3505.  
  3506.     // if(h.is === 'ytd-metadata-row-container-renderer'){
  3507.  
  3508.     //   if(!h.mk2145) h.mk2145 = crypto.randomUUID();
  3509.  
  3510.     //   let ww = '';
  3511.     //   const holder = h.hostElement || h;
  3512.     //   if(holder && holder.setAttribute){
  3513.     //     holder.setAttribute('sww',(holder.getAttribute('sww' ) || '' )+"*" )
  3514.  
  3515.     //     ww = holder.getAttribute('sww')
  3516.     //   }
  3517.     //   console.log(2929,  `a.${'hostElement' in h};b.${'hostElement72' in h}`, h.mk2145,  h.is ,ww, h, `kz62=${h.kz62}` , !!(setupWD && setupWF && setupDataHost && (h.is || h.__dataHost)) )
  3518.  
  3519.     // }
  3520.  
  3521.     if (setupDataHost !== null && ('hostElement' in h) && !('hostElement72' in h)) {
  3522.  
  3523.       let skip = false;
  3524.       // if (h.is && typeof h.is === 'string' && h.is.length > 15 && h.is.length < 30) {
  3525.       //   if (h.is.includes('yt-') && !h.$ && h.is.length !== 20 && h.is.length !== 21 && h.is.length !== 22) {
  3526.       //     skip = true;
  3527.       //     // return;
  3528.       //   }
  3529.       // }
  3530.  
  3531.       h.kz62 = (h.kz62 || 0) + 1;
  3532.  
  3533.       //
  3534.  
  3535.       setupWD(h);
  3536.       const hostElement = h.hostElement;
  3537.  
  3538.       for (const s of ['__dataHost', '__CE_shadowRoot', '__template', '__templatizeOwner']) {
  3539.         setupWF(h, s);
  3540.         setupWF(hostElement, s);
  3541.       }
  3542.  
  3543.       setupDataHost(h.__dataHost, skip);
  3544.       setupDataHost(hostElement.__dataHost, skip);
  3545.  
  3546.       hostElement && aDelay().then(() => {
  3547.         setupWF(hostElement, '__CE_shadowRoot');
  3548.       });
  3549.  
  3550.       if (!h.m822) setupDataHost(h)
  3551.  
  3552.     }
  3553.  
  3554.   }
  3555.  
  3556.  
  3557.   let nativeHTMLElement = window.HTMLElement;
  3558.  
  3559.   try {
  3560.  
  3561.     const q = document.createElement('template');
  3562.     q.innerHTML = '<ytz-null361></ytz-null361>';
  3563.     nativeHTMLElement = q.content.firstChild.constructor
  3564.  
  3565.   } catch (e) { }
  3566.  
  3567.   if (!nativeHTMLElement.prototype.connectedCallback) {
  3568.     nativeHTMLElement.prototype.connectedCallback79 = nativeHTMLElement.prototype.connectedCallback;
  3569.     nativeHTMLElement.prototype.connectedCallback = function () {
  3570.       let r;
  3571.       if (this.connectedCallback79) r = this.connectedCallback79.apply(this, arguments);
  3572.  
  3573.       if (WEAK_REF_BINDING && (this instanceof Node) && (this.is || this.__dataHost)) {
  3574.  
  3575.         setupWeakRef(insp(this))
  3576.         // setupWeakRef(this.__dataHost)
  3577.       }
  3578.       return r;
  3579.     }
  3580.   }
  3581.  
  3582.   SCRIPTLET_NOFIX_setTimeout && FIX_VIDEO_BLOCKING && typeof AbortSignal !== 'undefined' && (() => {
  3583.     // resolve(1) is already done by JS Tamer (FIX_VIDEO_BLOCKING)
  3584.     // `setTimeout(resolve(1), 5000)` is removed in 2024.05.12 YT Code
  3585.  
  3586.     const delay = 5000;
  3587.     let reNeedle = null;
  3588.     let test;
  3589.     try {
  3590.       test = RegExp.prototype.test;
  3591.       RegExp.prototype.test = function () { reNeedle = this; throw '' }
  3592.       setTimeout(Symbol(), delay);
  3593.     } catch (e) { }
  3594.     if (test) RegExp.prototype.test = test;
  3595.     if (reNeedle) {
  3596.       reNeedle.test = () => false;
  3597.       // reNeedle.test848= reNeedle.test;
  3598.       // reNeedle.test = function(){
  3599.       //   const r = this.test848(...arguments);
  3600.       //   console.log('tested', r)
  3601.       //   return r;
  3602.       // }
  3603.       console.log('[yt-js-engine-tamer] Disabled Scriptlet setTimeout', reNeedle);
  3604.     }
  3605.  
  3606.   })();
  3607.  
  3608.   ENABLE_discreteTasking && Object.defineProperty(Object.prototype, 'connectedCallback', {
  3609.     get() {
  3610.       const f = this[keyStConnectedCallback];
  3611.       if (this.is) {
  3612.         setupDiscreteTasks(this, true);
  3613.         if (f) this.ky36 = 1;
  3614.       }
  3615.       if (WEAK_REF_BINDING && (this.is || this instanceof Node)) {
  3616.         setupWeakRef(this)
  3617.       }
  3618.       return f;
  3619.     },
  3620.     set(nv) {
  3621.       let gv;
  3622.       if (typeof nv === 'function') {
  3623.  
  3624.         gv = cmf.get(nv) || gvGenerator(nv);
  3625.         if (gv !== nv) {
  3626.           cmf.set(nv, gv);
  3627.           cmf.set(gv, gv);
  3628.           dmf.set(gv, nv);
  3629.         }
  3630.  
  3631.       } else {
  3632.         gv = nv;
  3633.       }
  3634.       this[keyStConnectedCallback] = gv; // proto or object
  3635.       if (this.is) {
  3636.         setupDiscreteTasks(this);
  3637.       }
  3638.       if (WEAK_REF_BINDING && (this.is || this instanceof Node)) {
  3639.         setupWeakRef(this)
  3640.       }
  3641.       return true;
  3642.     },
  3643.     enumerable: false,
  3644.     configurable: true
  3645.  
  3646.   });
  3647.  
  3648.   const pLoad = new Promise(resolve => {
  3649.     if (document.readyState !== 'loading') {
  3650.       resolve();
  3651.     } else {
  3652.       window.addEventListener("DOMContentLoaded", resolve, false);
  3653.     }
  3654.   });
  3655.   pLoad.then(() => {
  3656.  
  3657.     let nonce = document.querySelector('style[nonce]');
  3658.     nonce = nonce ? nonce.getAttribute('nonce') : null;
  3659.     const st = document.createElement('style');
  3660.     if (typeof nonce === 'string') st.setAttribute('nonce', nonce);
  3661.     st.textContent = "none-element-k47{order:0}";
  3662.     st.addEventListener('load', () => {
  3663.       pf31.resolve();
  3664.       p59 = 1;
  3665.     }, false);
  3666.     (document.body || document.head || document.documentElement).appendChild(st);
  3667.  
  3668.   });
  3669.  
  3670.   const prepareLogs = [];
  3671.  
  3672.   const skipAdsDetection = new Set(['/robots.txt', '/live_chat', '/live_chat_replay']);
  3673.  
  3674.   let winError00 = window.onerror;
  3675.  
  3676.   let fix_error_many_stack_state = !FIX_error_many_stack ? 0 : skipAdsDetection.has(location.pathname) ? 2 : 1;
  3677.  
  3678.   if (!JSON || !('parse' in JSON)) fix_error_many_stack_state = 0;
  3679.  
  3680.   ; FIX_Iframe_NULL_SRC && typeof kagi === 'undefined' && (() => {
  3681.  
  3682.     const emptyBlobUrl = URL.createObjectURL(new Blob([], { type: 'text/html' }));
  3683.     const lcOpt = { sensitivity: 'base' };
  3684.     document.createElement24 = document.createElement;
  3685.     document.createElement = function (t) {
  3686.       if (typeof t === 'string' && t.length === 6) {
  3687.         if (t.localeCompare('iframe', undefined, lcOpt) === 0) {
  3688.           const p = this.createElement24(t);
  3689.           try {
  3690.             const stack = new Error().stack;
  3691.             const isSearchbox = stack.includes('initializeSearchbox'); // see https://greasyfork.org/scripts/473972-youtube-js-engine-tamer/discussions/217084
  3692.             if (!isSearchbox) {
  3693.               p.src = emptyBlobUrl; // avoid iframe is appended to DOM without any url
  3694.             }
  3695.           } catch (e) { }
  3696.           return p;
  3697.         }
  3698.       }
  3699.       return this.createElement24.apply(this, arguments);
  3700.     };
  3701.  
  3702.   })();
  3703.  
  3704.   ; fix_error_many_stack_state === 1 && (() => {
  3705.  
  3706.  
  3707.     let p1 = winError00;
  3708.  
  3709.     let stackNeedleDetails = null;
  3710.  
  3711.     Object.defineProperty(Object.prototype, 'matchAll', {
  3712.       get() {
  3713.         stackNeedleDetails = this;
  3714.         return true;
  3715.       },
  3716.       enumerable: true,
  3717.       configurable: true
  3718.     });
  3719.  
  3720.     try {
  3721.       JSON.parse("{}");
  3722.     } catch (e) {
  3723.       console.warn(e)
  3724.       fix_error_many_stack_state = 0;
  3725.     }
  3726.  
  3727.     delete Object.prototype['matchAll'];
  3728.  
  3729.     let p2 = window.onerror;
  3730.  
  3731.     window.onerror = p1;
  3732.  
  3733.     if (fix_error_many_stack_state === 0) return;
  3734.  
  3735.     if (stackNeedleDetails) {
  3736.       JSON.parse.stackNeedleDetails = stackNeedleDetails;
  3737.       stackNeedleDetails.matchAll = true;
  3738.     }
  3739.  
  3740.     if (p1 === p2) return (fix_error_many_stack_state = 0);
  3741.  
  3742.     // p1!==p2
  3743.     fix_error_many_stack_state = !stackNeedleDetails ? 4 : 3;
  3744.  
  3745.   })();
  3746.  
  3747.   ; fix_error_many_stack_state === 2 && (() => {
  3748.  
  3749.  
  3750.     let p1 = winError00;
  3751.  
  3752.     let objectPrune = null;
  3753.     let stackNeedleDetails = null;
  3754.  
  3755.     Object.defineProperty(Function.prototype, 'findOwner', {
  3756.       get() {
  3757.         objectPrune = this;
  3758.         return this._findOwner;
  3759.       },
  3760.       set(nv) {
  3761.         this._findOwner = nv;
  3762.         return true;
  3763.       },
  3764.       enumerable: true,
  3765.       configurable: true
  3766.     });
  3767.  
  3768.     Object.defineProperty(Object.prototype, 'matchAll', {
  3769.       get() {
  3770.         stackNeedleDetails = this;
  3771.         return true;
  3772.       },
  3773.       enumerable: true,
  3774.       configurable: true
  3775.     });
  3776.  
  3777.     try {
  3778.       JSON.parse("{}");
  3779.     } catch (e) {
  3780.       console.warn(e)
  3781.       fix_error_many_stack_state = 0;
  3782.     }
  3783.  
  3784.     delete Function.prototype['findOwner'];
  3785.     delete Object.prototype['matchAll'];
  3786.  
  3787.     let p2 = window.onerror;
  3788.  
  3789.     if (p1 !== p2) return (fix_error_many_stack_state = 4); // p1 != p2
  3790.  
  3791.     if (fix_error_many_stack_state == 0) return;
  3792.  
  3793.     // the following will only execute when Brave's scriptlets.js is executed.
  3794.  
  3795.     prepareLogs.push("fix_error_many_stack_state NB")
  3796.  
  3797.     if (stackNeedleDetails) {
  3798.       stackNeedleDetails.pattern = null;
  3799.       stackNeedleDetails.re = null;
  3800.       stackNeedleDetails.expect = null;
  3801.       stackNeedleDetails.matchAll = true;
  3802.     }
  3803.  
  3804.     if (objectPrune) {
  3805.       objectPrune.findOwner = objectPrune.mustProcess = objectPrune.logJson = () => { }
  3806.       delete objectPrune._findOwner;
  3807.     }
  3808.  
  3809.     fix_error_many_stack_state = 3;
  3810.     JSON.parse.stackNeedleDetails = stackNeedleDetails;
  3811.     JSON.parse.objectPrune = objectPrune;
  3812.  
  3813.   })();
  3814.  
  3815.   ; fix_error_many_stack_state === 3 && (() => {
  3816.  
  3817.  
  3818.     let p1 = winError00;
  3819.  
  3820.     try {
  3821.       JSON.parse("{}");
  3822.     } catch (e) {
  3823.       console.warn(e)
  3824.       fix_error_many_stack_state = 0;
  3825.     }
  3826.  
  3827.     let p2 = window.onerror;
  3828.  
  3829.     if (p1 === p2) return;
  3830.  
  3831.     window.onerror = p1;
  3832.  
  3833.     if (fix_error_many_stack_state === 0) return;
  3834.  
  3835.     fix_error_many_stack_state = 4; // p1 != p2
  3836.  
  3837.  
  3838.   })();
  3839.  
  3840.   fix_error_many_stack_state === 4 && (() => {
  3841.  
  3842.     // the following will only execute when Brave's scriptlets.js is executed.
  3843.  
  3844.     prepareLogs.push("fix_error_many_stack_state AB")
  3845.  
  3846.     JSON.parseProxy = JSON.parse;
  3847.  
  3848.     JSON.parse = ((parse) => {
  3849.  
  3850.       parse = parse.bind(JSON); // get a new instance of the current JSON.parse
  3851.       return function (text, reviver) {
  3852.         const onerror = window.onerror;
  3853.         window.onerror = null;
  3854.         let r;
  3855.         try {
  3856.           r = parse(...arguments);
  3857.         } catch (e) {
  3858.           r = e;
  3859.         }
  3860.         window.onerror = onerror;
  3861.         if (r instanceof Error) {
  3862.           throw r;
  3863.         }
  3864.         return r;
  3865.       }
  3866.  
  3867.     })(JSON.parse);
  3868.  
  3869.  
  3870.   })();
  3871.  
  3872.  
  3873.   // << if FIX_yt_player >>
  3874.  
  3875.   // credit to @nopeless (https://greasyfork.org/scripts/471489-youtube-player-perf/)
  3876.   const PERF_471489_ = true;
  3877.   // PERF_471489_ is not exactly the same to Youtube Player perf v0.7
  3878.   // This script uses a much gentle way to tamer the JS engine instead.
  3879.  
  3880.   // << end >>
  3881.  
  3882.   const steppingScaleN = 200; // transform: scaleX(k/N); 0<k<N
  3883.  
  3884.  
  3885.  
  3886.   const nilFn = () => { };
  3887.  
  3888.   let isMainWindow = false;
  3889.   try {
  3890.     isMainWindow = window.document === window.top.document
  3891.   } catch (e) { }
  3892.  
  3893.   let NO_PRELOAD_GENERATE_204_BYPASS = NO_PRELOAD_GENERATE_204 ? false : true;
  3894.   let headLinkCollection = null;
  3895.  
  3896.  
  3897.   // const assertor = (f) => f() || console.assert(false, f + "");
  3898.  
  3899.   const fnIntegrity = (f, d) => {
  3900.     if (!f || typeof f !== 'function') {
  3901.       console.warn('f is not a function', f);
  3902.       return;
  3903.     }
  3904.     let p = f + "", s = 0, j = -1, w = 0;
  3905.     for (let i = 0, l = p.length; i < l; i++) {
  3906.       const t = p[i];
  3907.       if (((t >= 'a' && t <= 'z') || (t >= 'A' && t <= 'Z'))) {
  3908.         if (j < i - 1) w++;
  3909.         j = i;
  3910.       } else {
  3911.         s++;
  3912.       }
  3913.     }
  3914.     let itz = `${f.length}.${s}.${w}`;
  3915.     if (!d) {
  3916.       return itz;
  3917.     } else {
  3918.       return itz === d;
  3919.     }
  3920.   };
  3921.  
  3922.   const getZqOu = (_yt_player) => {
  3923.  
  3924.     const w = 'ZqOu';
  3925.  
  3926.     let arr = [];
  3927.  
  3928.     for (const [k, v] of Object.entries(_yt_player)) {
  3929.  
  3930.       const p = typeof v === 'function' ? v.prototype : 0;
  3931.       if (p
  3932.         && typeof p.start === 'function' && p.start.length === 0 // Ou
  3933.         && typeof p.isActive === 'function' && p.isActive.length === 0
  3934.         && typeof p.stop === 'function' && p.stop.length === 0
  3935.         && !p.isComplete && !p.getStatus && !p.getResponseHeader && !p.getLastError
  3936.         && !p.send && !p.abort
  3937.         && !p.sample && !p.initialize && !p.fail && !p.getName
  3938.         // && !p.dispose && !p.isDisposed
  3939.  
  3940.       ) {
  3941.         arr = addProtoToArr(_yt_player, k, arr) || arr;
  3942.  
  3943.  
  3944.       }
  3945.  
  3946.     }
  3947.  
  3948.     if (arr.length === 0) {
  3949.  
  3950.       console.warn(`Key does not exist. [${w}]`);
  3951.     } else {
  3952.  
  3953.       console.log(`[${w}]`, arr);
  3954.       return arr[0];
  3955.     }
  3956.  
  3957.   }
  3958.  
  3959.   const getZqQu = (_yt_player) => {
  3960.  
  3961.     const w = 'ZqQu';
  3962.  
  3963.     let arr = [];
  3964.  
  3965.  
  3966.     for (const [k, v] of Object.entries(_yt_player)) {
  3967.  
  3968.       const p = typeof v === 'function' ? v.prototype : 0;
  3969.       if (p
  3970.         && typeof p.start === 'function' && p.start.length === 1 // Qu
  3971.         && typeof p.isActive === 'function' && p.isActive.length === 0
  3972.         && typeof p.stop === 'function' && p.stop.length === 0
  3973.         && !p.isComplete && !p.getStatus && !p.getResponseHeader && !p.getLastError
  3974.         && !p.send && !p.abort
  3975.         && !p.sample && !p.initialize && !p.fail && !p.getName
  3976.         // && !p.dispose && !p.isDisposed
  3977.  
  3978.       ) {
  3979.         arr = addProtoToArr(_yt_player, k, arr) || arr;
  3980.  
  3981.  
  3982.       }
  3983.  
  3984.     }
  3985.  
  3986.     if (arr.length === 0) {
  3987.  
  3988.       console.warn(`Key does not exist. [${w}]`);
  3989.     } else {
  3990.  
  3991.       console.log(`[${w}]`, arr);
  3992.       return arr[0];
  3993.     }
  3994.  
  3995.   }
  3996.  
  3997.  
  3998.   const getVG = (_yt_player) => {
  3999.     const w = 'VG';
  4000.  
  4001.     let arr = [];
  4002.  
  4003.     for (const [k, v] of Object.entries(_yt_player)) {
  4004.  
  4005.       const p = typeof v === 'function' ? v.prototype : 0;
  4006.       if (p
  4007.         && typeof p.show === 'function' && p.show.length === 1
  4008.         && typeof p.hide === 'function' && p.hide.length === 0
  4009.         && typeof p.stop === 'function' && p.stop.length === 0) {
  4010.  
  4011.         arr = addProtoToArr(_yt_player, k, arr) || arr;
  4012.  
  4013.       }
  4014.  
  4015.     }
  4016.  
  4017.  
  4018.     if (arr.length === 0) {
  4019.  
  4020.       console.warn(`Key does not exist. [${w}]`);
  4021.     } else {
  4022.  
  4023.       console.log(`[${w}]`, arr);
  4024.       return arr[0];
  4025.     }
  4026.  
  4027.  
  4028.  
  4029.   }
  4030.  
  4031.  
  4032.   const getzo = (_yt_player) => {
  4033.     const w = 'zo';
  4034.  
  4035.     let arr = [];
  4036.  
  4037.     for (const [k, v] of Object.entries(_yt_player)) {
  4038.  
  4039.       if (
  4040.         typeof v === 'function' && v.length === 3 && k.length < 3
  4041.         && (v + "").includes("a.style[b]=c")
  4042.       ) {
  4043.  
  4044.         arr.push(k);
  4045.  
  4046.       }
  4047.  
  4048.     }
  4049.  
  4050.  
  4051.     if (arr.length === 0) {
  4052.  
  4053.       console.warn(`Key does not exist. [${w}]`);
  4054.     } else {
  4055.  
  4056.       console.log(`[${w}]`, arr);
  4057.       return arr[0];
  4058.     }
  4059.  
  4060.   }
  4061.  
  4062.   const addProtoToArr = (parent, key, arr) => {
  4063.  
  4064.  
  4065.     let isChildProto = false;
  4066.     for (const sr of arr) {
  4067.       if (parent[key].prototype instanceof parent[sr]) {
  4068.         isChildProto = true;
  4069.         break;
  4070.       }
  4071.     }
  4072.  
  4073.     if (isChildProto) return;
  4074.  
  4075.     arr = arr.filter(sr => {
  4076.       if (parent[sr].prototype instanceof parent[key]) {
  4077.         return false;
  4078.       }
  4079.       return true;
  4080.     });
  4081.  
  4082.     arr.push(key);
  4083.  
  4084.     return arr;
  4085.  
  4086.  
  4087.   }
  4088.  
  4089.   const getuG = (_yt_player) => {
  4090.  
  4091.     const w = 'uG';
  4092.  
  4093.     let arr = [];
  4094.  
  4095.     for (const [k, v] of Object.entries(_yt_player)) {
  4096.  
  4097.  
  4098.       const p = typeof v === 'function' ? v.prototype : 0;
  4099.  
  4100.       if (p
  4101.         && typeof p.createElement === 'function' && p.createElement.length === 2
  4102.         && typeof p.detach === 'function' && p.detach.length === 0
  4103.         && typeof p.update === 'function' && p.update.length === 1
  4104.         && typeof p.updateValue === 'function' && p.updateValue.length === 2
  4105.       ) {
  4106.  
  4107.         arr = addProtoToArr(_yt_player, k, arr) || arr;
  4108.  
  4109.       }
  4110.  
  4111.     }
  4112.  
  4113.  
  4114.  
  4115.  
  4116.  
  4117.     if (arr.length === 0) {
  4118.  
  4119.       console.warn(`Key does not exist. [${w}]`);
  4120.     } else {
  4121.  
  4122.       console.log(`[${w}]`, arr);
  4123.       return arr[0];
  4124.     }
  4125.  
  4126.   }
  4127.  
  4128.  
  4129.   const getQT = (_yt_player) => {
  4130.     const w = 'QT';
  4131.  
  4132.     let arr = [];
  4133.     let brr = new Map();
  4134.  
  4135.     for (const [k, v] of Object.entries(_yt_player)) {
  4136.  
  4137.       const p = typeof v === 'function' ? v.prototype : 0;
  4138.       if (p) {
  4139.         let q = 0;
  4140.         if (typeof p.handleGlobalKeyUp === 'function' && p.handleGlobalKeyUp.length === 7) q += 400;
  4141.         else if (typeof p.handleGlobalKeyUp === 'function' && p.handleGlobalKeyUp.length === 8) q += 300;
  4142.         else if (typeof p.handleGlobalKeyUp === 'function') q += 200;
  4143.  
  4144.         if (typeof p.handleGlobalKeyUp === 'function' && p.handleGlobalKeyUp.length === 0) q -= 600; // avoid SV
  4145.  
  4146.         if (q < 200) continue; // p.handleGlobalKeyUp must be available
  4147.  
  4148.         if (typeof p.handleGlobalKeyDown === 'function' && p.handleGlobalKeyDown.length === 8) q += 80;
  4149.         if (typeof p.handleGlobalKeyDown === 'function' && p.handleGlobalKeyDown.length === 7) q += 30;
  4150.         if (typeof p.step === 'function' && p.step.length === 1) q += 10;
  4151.         if (typeof p.step === 'function' && p.step.length !== 1) q += 5;
  4152.  
  4153.  
  4154.         // differentiate QT and DX
  4155.  
  4156.         q += 280;
  4157.         if (typeof p.cueVideoByPlayerVars === 'function') q += 4;
  4158.         if (typeof p.loadVideoByPlayerVars === 'function') q += 4;
  4159.         if (typeof p.preloadVideoByPlayerVars === 'function') q += 4;
  4160.         if (typeof p.seekBy === 'function') q += 4;
  4161.         if (typeof p.seekTo === 'function') q += 4;
  4162.         if (typeof p.getStoryboardFormat === 'function') q += 4;
  4163.         if (typeof p.getDuration === 'function') q += 4;
  4164.         if (typeof p.loadModule === 'function') q += 4;
  4165.         if (typeof p.unloadModule === 'function') q += 4;
  4166.         if (typeof p.getOption === 'function') q += 4;
  4167.         if (typeof p.getOptions === 'function') q += 4;
  4168.         if (typeof p.setOption === 'function') q += 4;
  4169.         if (typeof p.addCueRange === 'function') q += 4;
  4170.         if (typeof p.getDebugText === 'function') q += 4;
  4171.         if (typeof p.getCurrentBroadcastId === 'function') q += 4;
  4172.         if (typeof p.setSizeStyle === 'function') q += 4;
  4173.         if (typeof p.showControls === 'function') q += 4;
  4174.         if (typeof p.hideControls === 'function') q += 4;
  4175.         if (typeof p.getVideoContentRect === 'function') q += 4;
  4176.         if (typeof p.toggleFullscreen === 'function') q += 4;
  4177.         if (typeof p.isFullscreen === 'function') q += 4;
  4178.         if (typeof p.cancelPlayback === 'function') q += 4;
  4179.         if (typeof p.getProgressState === 'function') q += 4;
  4180.         if (typeof p.isInline === 'function') q += 4;
  4181.         if (typeof p.setInline === 'function') q += 4;
  4182.         if (typeof p.toggleSubtitles === 'function') q += 4;
  4183.         if (typeof p.getPlayerSize === 'function') q += 4;
  4184.         if (typeof p.wakeUpControls === 'function') q += 4;
  4185.         if (typeof p.setCenterCrop === 'function') q += 4;
  4186.         if (typeof p.getLoopVideo === 'function') q += 4;
  4187.         if (typeof p.setLoopVideo === 'function') q += 4;
  4188.  
  4189.  
  4190.         if (q > 0) arr = addProtoToArr(_yt_player, k, arr) || arr;
  4191.  
  4192.         if (q > 0) brr.set(k, q);
  4193.  
  4194.       }
  4195.  
  4196.     }
  4197.  
  4198.     if (arr.length === 0) {
  4199.  
  4200.       console.warn(`Key does not exist. [${w}]`);
  4201.     } else {
  4202.  
  4203.       arr = arr.map(key => [key, (brr.get(key) || 0)]);
  4204.  
  4205.       if (arr.length > 1) arr.sort((a, b) => b[1] - a[1]);
  4206.  
  4207.       if (arr.length > 2) console.log(`[${w}]`, arr);
  4208.       return arr[0][0];
  4209.     }
  4210.  
  4211.  
  4212.  
  4213.   }
  4214.  
  4215.  
  4216.  
  4217.   const getSV = (_yt_player) => {
  4218.     const w = 'SV';
  4219.  
  4220.     let arr = [];
  4221.     let brr = new Map();
  4222.  
  4223.     for (const [k, v] of Object.entries(_yt_player)) {
  4224.  
  4225.       const p = typeof v === 'function' ? v.prototype : 0;
  4226.       if (p) {
  4227.         let q = 0;
  4228.         if (typeof p.handleGlobalKeyUp === 'function' && p.handleGlobalKeyUp.length === 7) q += 400;
  4229.         else if (typeof p.handleGlobalKeyUp === 'function' && p.handleGlobalKeyUp.length === 8) q += 300;
  4230.         else if (typeof p.handleGlobalKeyUp === 'function') q += 200;
  4231.  
  4232.         if (typeof p.handleGlobalKeyUp === 'function' && p.handleGlobalKeyUp.length === 0) q += 600; // SV
  4233.  
  4234.         if (q < 200) continue; // p.handleGlobalKeyUp must be available
  4235.  
  4236.         if (typeof p.handleGlobalKeyDown === 'function' && p.handleGlobalKeyDown.length === 8) q += 80;
  4237.         if (typeof p.handleGlobalKeyDown === 'function' && p.handleGlobalKeyDown.length === 7) q += 30;
  4238.         if (typeof p.step === 'function' && p.step.length === 1) q += 10;
  4239.         if (typeof p.step === 'function' && p.step.length !== 1) q += 5;
  4240.  
  4241.  
  4242.         // differentiate QT and DX
  4243.  
  4244.  
  4245.         q += 280;
  4246.  
  4247.         if (typeof p.cueVideoByPlayerVars === 'function') q -= 4;
  4248.         if (typeof p.loadVideoByPlayerVars === 'function') q -= 4;
  4249.         if (typeof p.preloadVideoByPlayerVars === 'function') q -= 4;
  4250.         if (typeof p.seekBy === 'function') q -= 4;
  4251.         if (typeof p.seekTo === 'function') q -= 4;
  4252.         if (typeof p.getStoryboardFormat === 'function') q -= 4;
  4253.         if (typeof p.getDuration === 'function') q -= 4;
  4254.         if (typeof p.loadModule === 'function') q -= 4;
  4255.         if (typeof p.unloadModule === 'function') q -= 4;
  4256.         if (typeof p.getOption === 'function') q -= 4;
  4257.         if (typeof p.getOptions === 'function') q -= 4;
  4258.         if (typeof p.setOption === 'function') q -= 4;
  4259.         if (typeof p.addCueRange === 'function') q -= 4;
  4260.         if (typeof p.getDebugText === 'function') q -= 4;
  4261.         if (typeof p.getCurrentBroadcastId === 'function') q -= 4;
  4262.         if (typeof p.setSizeStyle === 'function') q -= 4;
  4263.         if (typeof p.showControls === 'function') q -= 4;
  4264.         if (typeof p.hideControls === 'function') q -= 4;
  4265.         if (typeof p.getVideoContentRect === 'function') q -= 4;
  4266.         if (typeof p.toggleFullscreen === 'function') q -= 4;
  4267.         if (typeof p.isFullscreen === 'function') q -= 4;
  4268.         if (typeof p.cancelPlayback === 'function') q -= 4;
  4269.         if (typeof p.getProgressState === 'function') q -= 4;
  4270.         if (typeof p.isInline === 'function') q -= 4;
  4271.         if (typeof p.setInline === 'function') q -= 4;
  4272.         if (typeof p.toggleSubtitles === 'function') q -= 4;
  4273.         if (typeof p.getPlayerSize === 'function') q -= 4;
  4274.         if (typeof p.wakeUpControls === 'function') q -= 4;
  4275.         if (typeof p.setCenterCrop === 'function') q -= 4;
  4276.         if (typeof p.getLoopVideo === 'function') q -= 4;
  4277.         if (typeof p.setLoopVideo === 'function') q -= 4;
  4278.  
  4279.  
  4280.         if (q > 0) arr = addProtoToArr(_yt_player, k, arr) || arr;
  4281.  
  4282.         if (q > 0) brr.set(k, q);
  4283.  
  4284.       }
  4285.  
  4286.     }
  4287.  
  4288.     if (arr.length === 0) {
  4289.  
  4290.       console.warn(`Key does not exist. [${w}]`);
  4291.     } else {
  4292.  
  4293.       arr = arr.map(key => [key, (brr.get(key) || 0)]);
  4294.  
  4295.       if (arr.length > 1) arr.sort((a, b) => b[1] - a[1]);
  4296.  
  4297.       if (arr.length > 2) console.log(`[${w}]`, arr);
  4298.       return arr[0][0];
  4299.     }
  4300.  
  4301.  
  4302.  
  4303.   }
  4304.  
  4305.  
  4306.  
  4307.  
  4308.   const getDX = (_yt_player) => {
  4309.     const w = 'DX';
  4310.  
  4311.     let arr = [];
  4312.     let brr = new Map();
  4313.  
  4314.     for (const [k, v] of Object.entries(_yt_player)) {
  4315.  
  4316.       const p = typeof v === 'function' ? v.prototype : 0;
  4317.       if (p) {
  4318.         let q = 0;
  4319.         if (typeof p.handleGlobalKeyUp === 'function' && p.handleGlobalKeyUp.length === 7) q += 400;
  4320.         else if (typeof p.handleGlobalKeyUp === 'function' && p.handleGlobalKeyUp.length === 8) q += 300;
  4321.         else if (typeof p.handleGlobalKeyUp === 'function') q += 200;
  4322.  
  4323.         if (typeof p.handleGlobalKeyUp === 'function' && p.handleGlobalKeyUp.length === 0) q -= 600; // avoid SV
  4324.  
  4325.  
  4326.         if (!(typeof p.init === 'function' && p.init.length === 0)) q -= 300; // init is required
  4327.  
  4328.         if (q < 200) continue; // p.handleGlobalKeyUp must be available
  4329.  
  4330.         if (typeof p.handleGlobalKeyDown === 'function' && p.handleGlobalKeyDown.length === 8) q += 80;
  4331.         if (typeof p.handleGlobalKeyDown === 'function' && p.handleGlobalKeyDown.length === 7) q += 30;
  4332.         if (typeof p.step === 'function' && p.step.length === 1) q += 10;
  4333.         if (typeof p.step === 'function' && p.step.length !== 1) q += 5;
  4334.  
  4335.  
  4336.         // differentiate QT and DX
  4337.  
  4338.  
  4339.         q += 280;
  4340.  
  4341.         if (typeof p.cueVideoByPlayerVars === 'function') q -= 4;
  4342.         if (typeof p.loadVideoByPlayerVars === 'function') q -= 4;
  4343.         if (typeof p.preloadVideoByPlayerVars === 'function') q -= 4;
  4344.         if (typeof p.seekBy === 'function') q -= 4;
  4345.         if (typeof p.seekTo === 'function') q -= 4;
  4346.         if (typeof p.getStoryboardFormat === 'function') q -= 4;
  4347.         if (typeof p.getDuration === 'function') q -= 4;
  4348.         if (typeof p.loadModule === 'function') q -= 4;
  4349.         if (typeof p.unloadModule === 'function') q -= 4;
  4350.         if (typeof p.getOption === 'function') q -= 4;
  4351.         if (typeof p.getOptions === 'function') q -= 4;
  4352.         if (typeof p.setOption === 'function') q -= 4;
  4353.         if (typeof p.addCueRange === 'function') q -= 4;
  4354.         if (typeof p.getDebugText === 'function') q -= 4;
  4355.         if (typeof p.getCurrentBroadcastId === 'function') q -= 4;
  4356.         if (typeof p.setSizeStyle === 'function') q -= 4;
  4357.         if (typeof p.showControls === 'function') q -= 4;
  4358.         if (typeof p.hideControls === 'function') q -= 4;
  4359.         if (typeof p.getVideoContentRect === 'function') q -= 4;
  4360.         if (typeof p.toggleFullscreen === 'function') q -= 4;
  4361.         if (typeof p.isFullscreen === 'function') q -= 4;
  4362.         if (typeof p.cancelPlayback === 'function') q -= 4;
  4363.         if (typeof p.getProgressState === 'function') q -= 4;
  4364.         if (typeof p.isInline === 'function') q -= 4;
  4365.         if (typeof p.setInline === 'function') q -= 4;
  4366.         if (typeof p.toggleSubtitles === 'function') q -= 4;
  4367.         if (typeof p.getPlayerSize === 'function') q -= 4;
  4368.         if (typeof p.wakeUpControls === 'function') q -= 4;
  4369.         if (typeof p.setCenterCrop === 'function') q -= 4;
  4370.         if (typeof p.getLoopVideo === 'function') q -= 4;
  4371.         if (typeof p.setLoopVideo === 'function') q -= 4;
  4372.  
  4373.  
  4374.         if (q > 0) arr = addProtoToArr(_yt_player, k, arr) || arr;
  4375.  
  4376.         if (q > 0) brr.set(k, q);
  4377.  
  4378.       }
  4379.  
  4380.     }
  4381.  
  4382.     if (arr.length === 0) {
  4383.  
  4384.       console.warn(`Key does not exist. [${w}]`);
  4385.     } else {
  4386.  
  4387.       arr = arr.map(key => [key, (brr.get(key) || 0)]);
  4388.  
  4389.       if (arr.length > 1) arr.sort((a, b) => b[1] - a[1]);
  4390.  
  4391.       if (arr.length > 2) console.log(`[${w}]`, arr);
  4392.       return arr[0][0];
  4393.     }
  4394.  
  4395.  
  4396.  
  4397.   }
  4398.  
  4399.  
  4400.  
  4401.   const isPrepareCachedV = (FIX_avoid_incorrect_video_meta ? true : false) && (window === top);
  4402.  
  4403.   let pageSetupVideoId = null; // set at finish; '' for indeterminate state
  4404.   let pageSetupState = 0;
  4405.  
  4406.   isPrepareCachedV && (() => {
  4407.  
  4408.     pageSetupVideoId = '';
  4409.     const clearCachedV = () => {
  4410.       pageSetupVideoId = '';
  4411.       pageSetupState = 0;
  4412.     }
  4413.     document.addEventListener('yt-navigate-start', clearCachedV, false); // user action
  4414.     document.addEventListener('yt-navigate-cache', clearCachedV, false); // pop state
  4415.     document.addEventListener('yt-page-data-fetched', clearCachedV, false); // still consider invalid until url is ready in yt-navigate-finish
  4416.     document.addEventListener('yt-navigate-finish', () => {
  4417.       pageSetupState = 1;
  4418.       try {
  4419.         const url = new URL(location.href);
  4420.         if (!url || !isWatchPageURL(url)) {
  4421.           pageSetupVideoId = '';
  4422.         } else {
  4423.           pageSetupVideoId = url.searchParams.get('v') || '';
  4424.         }
  4425.       } catch (e) {
  4426.         pageSetupVideoId = '';
  4427.       }
  4428.     }, false);
  4429.  
  4430.   })();
  4431.  
  4432.   let videoPlayingY = null;
  4433.  
  4434.   isPrepareCachedV && (() => {
  4435.  
  4436.     let getNext = true;
  4437.     let videoPlayingX = {
  4438.       get videoId() {
  4439.         if (getNext) {
  4440.           getNext = false;
  4441.  
  4442.           let elements = document.querySelectorAll('ytd-watch-flexy[video-id]');
  4443.           const arr = [];
  4444.           for (const element of elements) {
  4445.             if (!element.closest('[hidden]')) arr.push(element);
  4446.           }
  4447.           if (arr.length !== 1) this.__videoId__ = '';
  4448.           else {
  4449.             this.__videoId__ = arr[0].getAttribute('video-id');
  4450.           }
  4451.  
  4452.         }
  4453.         return this.__videoId__ || '';
  4454.       }
  4455.     }
  4456.  
  4457.     videoPlayingY = videoPlayingX;
  4458.     const handler = (evt) => {
  4459.       const target = (evt || 0).target;
  4460.       if (target instanceof HTMLVideoElement) {
  4461.         getNext = true;
  4462.       }
  4463.     }
  4464.     document.addEventListener('loadedmetadata', handler, true);
  4465.     document.addEventListener('durationchange', handler, true);
  4466.  
  4467.   })();
  4468.  
  4469.  
  4470.  
  4471.   const cleanContext = async (win) => {
  4472.     const waitFn = requestAnimationFrame; // shall have been binded to window
  4473.     try {
  4474.       let mx = 16; // MAX TRIAL
  4475.       const frameId = 'vanillajs-iframe-v1';
  4476.       /** @type {HTMLIFrameElement | null} */
  4477.       let frame = document.getElementById(frameId);
  4478.       let removeIframeFn = null;
  4479.       if (!frame) {
  4480.         frame = document.createElement('iframe');
  4481.         frame.id = frameId;
  4482.         const blobURL = typeof webkitCancelAnimationFrame === 'function' && typeof kagi === 'undefined' ? (frame.src = URL.createObjectURL(new Blob([], { type: 'text/html' }))) : null; // avoid Brave Crash
  4483.         frame.sandbox = 'allow-same-origin'; // script cannot be run inside iframe but API can be obtained from iframe
  4484.         let n = document.createElement('noscript'); // wrap into NOSCRPIT to avoid reflow (layouting)
  4485.         n.appendChild(frame);
  4486.         while (!document.documentElement && mx-- > 0) await new Promise(waitFn); // requestAnimationFrame here could get modified by YouTube engine
  4487.         const root = document.documentElement;
  4488.         root.appendChild(n); // throw error if root is null due to exceeding MAX TRIAL
  4489.         if (blobURL) Promise.resolve().then(() => URL.revokeObjectURL(blobURL));
  4490.  
  4491.         removeIframeFn = (setTimeout) => {
  4492.           const removeIframeOnDocumentReady = (e) => {
  4493.             e && win.removeEventListener("DOMContentLoaded", removeIframeOnDocumentReady, false);
  4494.             e = n;
  4495.             n = win = removeIframeFn = 0;
  4496.             setTimeout ? setTimeout(() => e.remove(), 200) : e.remove();
  4497.           }
  4498.           if (!setTimeout || document.readyState !== 'loading') {
  4499.             removeIframeOnDocumentReady();
  4500.           } else {
  4501.             win.addEventListener("DOMContentLoaded", removeIframeOnDocumentReady, false);
  4502.           }
  4503.         }
  4504.       }
  4505.       while (!frame.contentWindow && mx-- > 0) await new Promise(waitFn);
  4506.       const fc = frame.contentWindow;
  4507.       if (!fc) throw "window is not found."; // throw error if root is null due to exceeding MAX TRIAL
  4508.       try {
  4509.         const { requestAnimationFrame, setTimeout, clearTimeout, cancelAnimationFrame, setInterval, clearInterval, requestIdleCallback, getComputedStyle } = fc;
  4510.         const res = { requestAnimationFrame, setTimeout, clearTimeout, cancelAnimationFrame, setInterval, clearInterval, requestIdleCallback, getComputedStyle };
  4511.         for (let k in res) res[k] = res[k].bind(win); // necessary
  4512.         if (removeIframeFn) Promise.resolve(res.setTimeout).then(removeIframeFn);
  4513.         res.animate = fc.HTMLElement.prototype.animate;
  4514.         res.perfNow = fc.performance.now;
  4515.         return res;
  4516.       } catch (e) {
  4517.         if (removeIframeFn) removeIframeFn();
  4518.         return null;
  4519.       }
  4520.     } catch (e) {
  4521.       console.warn(e);
  4522.       return null;
  4523.     }
  4524.   };
  4525.  
  4526.   const promiseForYtActionCalled = new Promise(resolve => {
  4527.     if (typeof AbortSignal !== 'undefined') {
  4528.       let hn = () => {
  4529.         if (!hn) return;
  4530.         hn = null;
  4531.         resolve(document.querySelector('ytd-app'));
  4532.       };
  4533.       document.addEventListener('yt-action', hn, { capture: true, passive: true, once: true });
  4534.     } else {
  4535.       let hn = () => {
  4536.         if (!hn) return;
  4537.         document.removeEventListener('yt-action', hn, true);
  4538.         hn = null;
  4539.         resolve(document.querySelector('ytd-app'));
  4540.       };
  4541.       document.addEventListener('yt-action', hn, true);
  4542.     }
  4543.   });
  4544.  
  4545.  
  4546.  
  4547.   cleanContext(window).then(__CONTEXT__ => {
  4548.     if (!__CONTEXT__) return null;
  4549.  
  4550.     const { requestAnimationFrame, setTimeout, clearTimeout, cancelAnimationFrame, setInterval, clearInterval, animate, requestIdleCallback, getComputedStyle, perfNow } = __CONTEXT__;
  4551.  
  4552.  
  4553.     performance.now17 = perfNow.bind(performance);
  4554.  
  4555.  
  4556.  
  4557.     __requestAnimationFrame__ = requestAnimationFrame;
  4558.  
  4559.  
  4560.     const isGPUAccelerationAvailable = (() => {
  4561.       // https://gist.github.com/cvan/042b2448fcecefafbb6a91469484cdf8
  4562.       try {
  4563.         const canvas = document.createElement('canvas');
  4564.         return !!(canvas.getContext('webgl') || canvas.getContext('experimental-webgl'));
  4565.       } catch (e) {
  4566.         return false;
  4567.       }
  4568.     })();
  4569.  
  4570.     const foregroundPromiseFn_noGPU = (() => {
  4571.  
  4572.       if (isGPUAccelerationAvailable) return null;
  4573.  
  4574.       const pd = Object.getOwnPropertyDescriptor(Document.prototype, 'visibilityState');
  4575.       if (!pd || typeof pd.get !== 'function') return null;
  4576.       const pdGet = pd.get;
  4577.  
  4578.       let pr = null;
  4579.  
  4580.       let hState = pdGet.call(document) === 'hidden';
  4581.       // let cid = 0;
  4582.       pureAddEventListener.call(document, 'visibilitychange', (evt) => {
  4583.         const newHState = pdGet.call(document) === 'hidden';
  4584.         if (hState !== newHState) {
  4585.           // if (cid > 0) cid = clearInterval(cid);
  4586.           hState = newHState;
  4587.           if (!hState && pr) pr = pr.resolve();
  4588.         }
  4589.       });
  4590.  
  4591.       // cid = setInterval(() => {
  4592.       //   const newHState = document.visibilityState === 'hidden';
  4593.       //   if (hState !== newHState) {
  4594.       //     hState = newHState;
  4595.       //     if (!hState && pr) pr = pr.resolve();
  4596.       //   }
  4597.       // }, 100);
  4598.  
  4599.  
  4600.       return (() => {
  4601.         if (pr) return pr;
  4602.         const w = ((!hState && setTimeout(() => {
  4603.           if (!hState && pr === w) pr = pr.resolve();
  4604.         })), (pr = new PromiseExternal()));
  4605.         return w;
  4606.       });
  4607.  
  4608.     })();
  4609.  
  4610.  
  4611.     let rafPromise = null;
  4612.     const getRafPromise = () => rafPromise || (rafPromise = new Promise(resolve => {
  4613.       requestAnimationFrame(hRes => {
  4614.         rafPromise = null;
  4615.         resolve(hRes);
  4616.       });
  4617.     }));
  4618.  
  4619.     const foregroundPromiseFn = foregroundPromiseFn_noGPU || getRafPromise;
  4620.  
  4621.  
  4622.     const wmComputedStyle = new WeakMap();
  4623.  
  4624.     if (!window.__native__getComputedStyle__ && !window.__jst__getComputedStyle__ && typeof window.getComputedStyle === 'function' && window.getComputedStyle.length === 1) {
  4625.       window.__native__getComputedStyle__ = getComputedStyle;
  4626.       if (ENABLE_COMPUTEDSTYLE_CACHE) {
  4627.         window.__original__getComputedStyle__ = window.getComputedStyle;
  4628.         window.getComputedStyle = function (elem) {
  4629.           if (!(elem instanceof Element) || (arguments.length === 2 && arguments[1]) || (arguments.length > 2)) {
  4630.             return window.__original__getComputedStyle__(...arguments);
  4631.           }
  4632.           let cs = wmComputedStyle.get(elem);
  4633.           if (!cs) {
  4634.             cs = window.__native__getComputedStyle__(elem);
  4635.             wmComputedStyle.set(elem, cs);
  4636.           }
  4637.           return cs;
  4638.         };
  4639.       } else {
  4640.         window.__original__getComputedStyle__ = null;
  4641.       }
  4642.       window.__jst__getComputedStyle__ = window.getComputedStyle;
  4643.     }
  4644.  
  4645.     NO_SCHEDULING_DUE_TO_COMPUTEDSTYLE && promiseForYtActionCalled.then(() => {
  4646.       if (typeof window.__jst__getComputedStyle__ === 'function' && window.__jst__getComputedStyle__.length === 1 && window.__jst__getComputedStyle__ !== window.getComputedStyle) {
  4647.         window.getComputedStyle = window.__jst__getComputedStyle__;
  4648.       }
  4649.     });
  4650.  
  4651.     const isUrlInEmbed = location.href.includes('.youtube.com/embed/');
  4652.     const isAbortSignalSupported = typeof AbortSignal !== "undefined";
  4653.  
  4654.     const promiseForTamerTimeout = new Promise(resolve => {
  4655.       !isUrlInEmbed && isAbortSignalSupported && document.addEventListener('yt-action', function () {
  4656.         setTimeout(resolve, 480);
  4657.       }, { capture: true, passive: true, once: true });
  4658.       !isUrlInEmbed && isAbortSignalSupported && typeof customElements === "object" && whenCEDefined('ytd-app').then(() => {
  4659.         setTimeout(resolve, 1200);
  4660.       });
  4661.       setTimeout(resolve, 3000);
  4662.     });
  4663.  
  4664.     const promiseForPageInitied = new Promise(resolve => {
  4665.       !isUrlInEmbed && isAbortSignalSupported && document.addEventListener('yt-action', function () {
  4666.         setTimeout(resolve, 450);
  4667.       }, { capture: true, passive: true, once: true });
  4668.       !isUrlInEmbed && isAbortSignalSupported && typeof customElements === "object" && whenCEDefined('ytd-app').then(() => {
  4669.         setTimeout(resolve, 900);
  4670.       });
  4671.       setTimeout(resolve, 1800);
  4672.     });
  4673.  
  4674.     NO_PRELOAD_GENERATE_204_BYPASS || promiseForPageInitied.then(() => {
  4675.       NO_PRELOAD_GENERATE_204_BYPASS = true;
  4676.       headLinkCollection = null;
  4677.     });
  4678.  
  4679.  
  4680.     NATIVE_CANVAS_ANIMATION && (() => {
  4681.  
  4682.       observablePromise(() => {
  4683.         HTMLCanvasElement.prototype.animate = animate;
  4684.       }, promiseForTamerTimeout).obtain();
  4685.  
  4686.     })();
  4687.  
  4688.     FIX_ytAction_ && (async () => {
  4689.  
  4690.       const ytdApp = await new Promise(resolve => {
  4691.  
  4692.         whenCEDefined('ytd-app').then(() => {
  4693.           const ytdApp = document.querySelector('ytd-app');
  4694.           if (ytdApp) {
  4695.             resolve(ytdApp);
  4696.             return;
  4697.           }
  4698.           let mo = new MutationObserver(() => {
  4699.             const ytdApp = document.querySelector('ytd-app');
  4700.             if (!ytdApp) return;
  4701.             if (mo) {
  4702.               mo.disconnect();
  4703.               mo.takeRecords();
  4704.               mo = null;
  4705.             }
  4706.             resolve(ytdApp);
  4707.           });
  4708.           mo.observe(document, { subtree: true, childList: true });
  4709.         });
  4710.  
  4711.       });
  4712.  
  4713.       if (!ytdApp) return;
  4714.       const cProto = insp(ytdApp).constructor.prototype;
  4715.  
  4716.       if (!cProto) return;
  4717.       let mbd = 0;
  4718.  
  4719.       const fixer = (_ytdApp) => {
  4720.         const ytdApp = insp(_ytdApp);
  4721.         if (ytdApp && typeof ytdApp.onYtActionBoundListener_ === 'function' && !ytdApp.onYtActionBoundListener57_) {
  4722.           ytdApp.onYtActionBoundListener57_ = ytdApp.onYtActionBoundListener_;
  4723.           ytdApp.onYtActionBoundListener_ = ytdApp.onYtAction_.bind(ytdApp);
  4724.           mbd++;
  4725.         }
  4726.       }
  4727.  
  4728.       observablePromise(() => {
  4729.  
  4730.         if (typeof cProto.created === 'function' && !cProto.created56) {
  4731.           cProto.created56 = cProto.created;
  4732.           cProto.created = function (...args) {
  4733.             const r = this.created56(...args);
  4734.             fixer(this);
  4735.             return r;
  4736.           };
  4737.           mbd++;
  4738.         }
  4739.  
  4740.         if (typeof cProto.onYtAction_ === 'function' && !cProto.onYtAction57_) {
  4741.           cProto.onYtAction57_ = cProto.onYtAction_;
  4742.           cProto.onYtAction_ = function (...args) {
  4743.             Promise.resolve().then(() => this.onYtAction57_(...args));
  4744.           };
  4745.           mbd++;
  4746.         }
  4747.  
  4748.         if (ytdApp) fixer(ytdApp);
  4749.  
  4750.         /*
  4751.         const actionRouter_ = ytdApp ? ytdApp.actionRouter_ : null;
  4752.         if (actionRouter_ && typeof actionRouter_.handleAction === 'function' && !actionRouter_.handleAction57) {
  4753.           actionRouter_.handleAction57 = actionRouter_.handleAction;
  4754.           actionRouter_.handleAction = function (...args) {
  4755.             Promise.resolve().then(() => this.handleAction57(...args));
  4756.           }
  4757.           mbd++;
  4758.         }
  4759.         */
  4760.  
  4761.         // if(mbd === 3) return 1;
  4762.         if (mbd >= 3) return 1;
  4763.  
  4764.       }, new Promise(r => setTimeout(r, 1000))).obtain();
  4765.  
  4766.     })();
  4767.  
  4768.     const observablePromise = (proc, timeoutPromise) => {
  4769.       let promise = null;
  4770.       return {
  4771.         obtain() {
  4772.           if (!promise) {
  4773.             promise = new Promise(resolve => {
  4774.               let mo = null;
  4775.               const f = () => {
  4776.                 let t = proc();
  4777.                 if (t) {
  4778.                   mo.disconnect();
  4779.                   mo.takeRecords();
  4780.                   mo = null;
  4781.                   resolve(t);
  4782.                 }
  4783.               }
  4784.               mo = new MutationObserver(f);
  4785.               mo.observe(document, { subtree: true, childList: true })
  4786.               f();
  4787.               timeoutPromise && timeoutPromise.then(() => {
  4788.                 resolve(null)
  4789.               });
  4790.             });
  4791.           }
  4792.           return promise
  4793.         }
  4794.       }
  4795.     }
  4796.  
  4797.     // let _yt_player_promise = null;
  4798.     /*
  4799.     const getYtPlayerPromise = () => {
  4800.       if (!_yt_player_promise) {
  4801.         _yt_player_promise = new Promise(resolve => {
  4802.           let cid = setInterval(() => {
  4803.             let t = (((window || 0)._yt_player || 0) || 0);
  4804.             if (t) {
  4805.               clearInterval(cid);
  4806.               resolve(t);
  4807.             }
  4808.           }, 1);
  4809.           promiseForTamerTimeout.then(() => {
  4810.             resolve(null)
  4811.           });
  4812.         });
  4813.       }
  4814.       return _yt_player_promise;
  4815.     }
  4816.     */
  4817.     const _yt_player_observable = observablePromise(() => {
  4818.       return (((window || 0)._yt_player || 0) || 0);
  4819.     }, promiseForTamerTimeout);
  4820.  
  4821.     const polymerObservable = observablePromise(() => {
  4822.       const Polymer = window.Polymer;
  4823.       if (typeof Polymer !== 'function') return;
  4824.       if (!(Polymer.Base || 0).connectedCallback || !(Polymer.Base || 0).disconnectedCallback) return;
  4825.       return Polymer;
  4826.     }, promiseForTamerTimeout);
  4827.  
  4828.     const schedulerInstanceObservable = observablePromise(() => {
  4829.       return (((window || 0).ytglobal || 0).schedulerInstanceInstance_ || 0);
  4830.     }, promiseForTamerTimeout);
  4831.  
  4832.     const timelineObservable = observablePromise(() => {
  4833.       let t = (((document || 0).timeline || 0) || 0);
  4834.       if (t && typeof t._play === 'function') {
  4835.         return t;
  4836.       }
  4837.     }, promiseForTamerTimeout);
  4838.     const animationObservable = observablePromise(() => {
  4839.       let t = (((window || 0).Animation || 0) || 0);
  4840.       if (t && typeof t === 'function' && t.length === 2 && typeof t.prototype._updatePromises === 'function') {
  4841.         return t;
  4842.       }
  4843.     }, promiseForTamerTimeout);
  4844.  
  4845.  
  4846.  
  4847.  
  4848.     const generalEvtHandler = async (_evKey, _fvKey, _debug) => {
  4849.  
  4850.       const evKey = `${_evKey}`;
  4851.       const fvKey = `${_fvKey}`;
  4852.       const debug = !!_debug;
  4853.  
  4854.       const _yt_player = await _yt_player_observable.obtain();
  4855.  
  4856.  
  4857.       if (!_yt_player || typeof _yt_player !== 'object') return;
  4858.  
  4859.  
  4860.       const getArr = (_yt_player) => {
  4861.  
  4862.         let arr = [];
  4863.  
  4864.         for (const [k, v] of Object.entries(_yt_player)) {
  4865.  
  4866.           const p = typeof v === 'function' ? v.prototype : 0;
  4867.           if (p
  4868.             && typeof p[evKey] === 'function' && p[evKey].length >= 0 && !p[fvKey]
  4869.  
  4870.           ) {
  4871.             arr = addProtoToArr(_yt_player, k, arr) || arr;
  4872.  
  4873.           }
  4874.  
  4875.         }
  4876.  
  4877.         if (arr.length === 0) {
  4878.  
  4879.           console.warn(`Key prop [${evKey}] does not exist.`);
  4880.         } else {
  4881.  
  4882.           return arr;
  4883.         }
  4884.  
  4885.       };
  4886.  
  4887.       const arr = getArr(_yt_player);
  4888.  
  4889.  
  4890.       if (!arr) return;
  4891.  
  4892.       debug && console.log(`FIX_${evKey}`, arr);
  4893.  
  4894.       const f = function (...args) {
  4895.         Promise.resolve().then(() => this[fvKey](...args));
  4896.       };
  4897.  
  4898.  
  4899.       for (const k of arr) {
  4900.  
  4901.         const g = _yt_player;
  4902.         const gk = g[k];
  4903.         const gkp = gk.prototype;
  4904.  
  4905.         debug && console.log(237, k, gkp)
  4906.  
  4907.         if (typeof gkp[evKey] == 'function' && !gkp[fvKey]) {
  4908.           gkp[fvKey] = gkp[evKey];
  4909.           gkp[evKey] = f;
  4910.         }
  4911.       }
  4912.  
  4913.  
  4914.  
  4915.  
  4916.     }
  4917.  
  4918.     FIX_onVideoDataChange && generalEvtHandler('onVideoDataChange', 'onVideoDataChange57');
  4919.     // FIX_onClick && generalEvtHandler('onClick', 'onClick57');
  4920.     FIX_onStateChange && generalEvtHandler('onStateChange', 'onStateChange57');
  4921.     FIX_onLoopRangeChange && generalEvtHandler('onLoopRangeChange', 'onLoopRangeChange57');
  4922.     if (FIX_VideoEVENTS_v2) {
  4923.       const FIX_VideoEVENTS_DEBUG = 0;
  4924.       generalEvtHandler('onVideoProgress', 'onVideoProgress57', FIX_VideoEVENTS_DEBUG); // --
  4925.       // generalEvtHandler('onAutoplayBlocked', 'onAutoplayBlocked57', FIX_VideoEVENTS_DEBUG);
  4926.       // generalEvtHandler('onLoadProgress', 'onLoadProgress57', FIX_VideoEVENTS_DEBUG); // << CAUSE ISSUE >>
  4927.       generalEvtHandler('onFullscreenChange', 'onFullscreenChange57', FIX_VideoEVENTS_DEBUG); // --
  4928.       // generalEvtHandler('onLoadedMetadata', 'onLoadedMetadata57', FIX_VideoEVENTS_DEBUG);
  4929.       // generalEvtHandler('onDrmOutputRestricted', 'onDrmOutputRestricted57', FIX_VideoEVENTS_DEBUG);
  4930.       // generalEvtHandler('onAirPlayActiveChange', 'onAirPlayActiveChange57', FIX_VideoEVENTS_DEBUG);
  4931.       // generalEvtHandler('onAirPlayAvailabilityChange', 'onAirPlayAvailabilityChange57', FIX_VideoEVENTS_DEBUG);
  4932.       // generalEvtHandler('onApiChange', 'onApiChange57', FIX_VideoEVENTS_DEBUG);
  4933.  
  4934.     }
  4935.     // onMutedAutoplayChange
  4936.     // onVolumeChange
  4937.     // onPlaybackRateChange
  4938.  
  4939.     // onAirPlayActiveChange
  4940.     // onAirPlayAvailabilityChange
  4941.     // onApiChange
  4942.     // onAutoplayBlocked
  4943.     // onDrmOutputRestricted
  4944.     // onFullscreenChange
  4945.     // onLoadProgress
  4946.     // onLoadedMetadata
  4947.     // onVideoDataChange
  4948.     // onVideoProgress
  4949.  
  4950.  
  4951.     (ENABLE_discreteTasking || UNLOAD_DETACHED_POLYMER || FIX_Polymer_dom) && (async () => {
  4952.  
  4953.       const Polymer = await polymerObservable.obtain();
  4954.       if (!Polymer) return;
  4955.  
  4956.       if (FIX_Polymer_dom) {
  4957.  
  4958.         const checkPDFuncValue = (pd) => {
  4959.           return pd && pd.writable && pd.enumerable && pd.configurable && typeof pd.value == 'function'
  4960.         }
  4961.         const checkPDFuncValue2 = (pd) => {
  4962.           return pd && typeof pd.value == 'function'
  4963.         }
  4964.  
  4965.         const checkPDFuncGet = (pd) => {
  4966.           return pd && typeof pd.get == 'function'
  4967.         }
  4968.  
  4969.         const domX = Polymer.dom(document.createElement('null'));
  4970.         const domXP = (((domX || 0).constructor || 0).prototype || 0);
  4971.         const pd1 = Object.getOwnPropertyDescriptor(domXP, 'getOwnerRoot');
  4972.         const pd2 = Object.getOwnPropertyDescriptor(Node.prototype, 'parentElement');
  4973.         const pd3 = Object.getOwnPropertyDescriptor(domXP, 'querySelector'); // undefined
  4974.         const pd4 = Object.getOwnPropertyDescriptor(Element.prototype, 'querySelector');
  4975.         const pd4b = Object.getOwnPropertyDescriptor(Document.prototype, 'querySelector');
  4976.         const pd5 = Object.getOwnPropertyDescriptor(domXP, 'querySelectorAll'); // undefined
  4977.         const pd6 = Object.getOwnPropertyDescriptor(Element.prototype, 'querySelectorAll');
  4978.         const pd6b = Object.getOwnPropertyDescriptor(Document.prototype, 'querySelectorAll');
  4979.  
  4980.  
  4981.         // getOwnerRoot - to be reviewed
  4982.         if (0 && checkPDFuncValue(pd1) && checkPDFuncGet(pd2) && !domXP.getOwnerRoot15 && typeof domXP.getOwnerRoot === 'function') {
  4983.  
  4984.           domXP.getOwnerRoot15 = domXP.getOwnerRoot;
  4985.           domXP.getOwnerRoot = function () {
  4986.             try {
  4987.               const p = this.node;
  4988.  
  4989.               if (p instanceof HTMLElement) {
  4990.                 const pp = pd2.get.call(p);
  4991.                 if (pp instanceof HTMLElement && pp.isConnected === true) {
  4992.                   return pp.getRootNode();
  4993.                 }
  4994.  
  4995.               }
  4996.             } catch (e) { }
  4997.             return this.getOwnerRoot15();
  4998.           }
  4999.  
  5000.           Polymer.__fixedGetOwnerRoot__ = 1;
  5001.         }
  5002.  
  5003.  
  5004.  
  5005.  
  5006.         if ((!pd3 || checkPDFuncValue(pd3)) && checkPDFuncValue2(pd4) && checkPDFuncValue2(pd4b) && !('querySelector15' in domXP)) {
  5007.  
  5008.           domXP.querySelector15 = domXP.querySelector;
  5009.  
  5010.           const querySelectorFn = function (query) {
  5011.             try {
  5012.               const p = this.node;
  5013.  
  5014.               // if (p instanceof HTMLElement && p.isConnected === true) {
  5015.               //     return pd4.value.call(p, query);
  5016.               // }
  5017.  
  5018.               if (p instanceof Document && p.isConnected === true) {
  5019.                 return pd4b.value.call(p, query);
  5020.               }
  5021.  
  5022.             } catch (e) { }
  5023.             return this.querySelector15(query);
  5024.           }
  5025.  
  5026.           Object.defineProperty(domXP, 'querySelector', {
  5027.             get() {
  5028.               return querySelectorFn;
  5029.             },
  5030.             set(nv) {
  5031.               if (nv === querySelectorFn) return true;
  5032.               this.querySelector15 = nv;
  5033.               return true;
  5034.             },
  5035.  
  5036.             enumerable: false,
  5037.             configurable: true
  5038.           });
  5039.  
  5040.           Polymer.__fixedQuerySelector__ = 1;
  5041.         }
  5042.  
  5043.         if ((!pd5 || checkPDFuncValue(pd5)) && checkPDFuncValue2(pd6) && checkPDFuncValue2(pd6b) && !('querySelectorAll15' in domXP)) {
  5044.  
  5045.           domXP.querySelectorAll15 = domXP.querySelectorAll;
  5046.  
  5047.           const querySelectorAllFn = function (query) {
  5048.  
  5049.             try {
  5050.  
  5051.               const p = this.node;
  5052.  
  5053.               // if (p instanceof HTMLElement && p.isConnected === true) {
  5054.               //     return pd6.value.call(p, query);
  5055.               // }
  5056.  
  5057.               if (p instanceof Document && p.isConnected === true) {
  5058.                 return pd6b.value.call(p, query);
  5059.               }
  5060.  
  5061.             } catch (e) {
  5062.  
  5063.             }
  5064.             return this.querySelectorAll15(query);
  5065.           }
  5066.  
  5067.           Object.defineProperty(domXP, 'querySelectorAll', {
  5068.             get() {
  5069.               return querySelectorAllFn;
  5070.             },
  5071.             set(nv) {
  5072.               if (nv === querySelectorAllFn) return true;
  5073.               this.querySelectorAll15 = nv;
  5074.               return true;
  5075.             },
  5076.  
  5077.             enumerable: false,
  5078.             configurable: true
  5079.           });
  5080.  
  5081.           Polymer.__fixedQuerySelectorAll__ = 1;
  5082.         }
  5083.       }
  5084.  
  5085.       if (UNLOAD_DETACHED_POLYMER && typeof Polymer.Base.detached === 'function' && !Polymer.Base.detached92 && Polymer.Base.detached.length === 0) {
  5086.         Polymer.Base.detached92 = Polymer.Base.detached;
  5087.  
  5088.         const detachedPlus = async function (elem) {
  5089.           await delay300.then();
  5090.           if (elem.isAttached !== false) return;
  5091.           await delay300.then();
  5092.           if (elem.isAttached !== false) return;
  5093.  
  5094.           if (elem.__dataClientsReady === true) elem.__dataClientsReady = false;
  5095.           // if (elem.__dataEnabled === true) elem.__dataEnabled = false;
  5096.           if (elem.__dataReady === true) elem.__dataReady = false;
  5097.  
  5098.           elem.__dataLinkedPaths = elem.__dataToNotify = elem.__dataPendingClients = null;
  5099.           elem.__dataHasPaths = false;
  5100.           // elem.__dataCompoundStorage = null;
  5101.           elem.__dataHost = null;
  5102.           elem.__dataTemp = null;
  5103.           elem.__dataClientsInitialized = false;
  5104.  
  5105.  
  5106.           // elem.data = {};
  5107.           elem.data = null;
  5108.           elem.__dataPending = null;
  5109.           elem.__dataOld = null;
  5110.           elem.__dataInstanceProps = null;
  5111.  
  5112.           elem.__dataCounter = 0;
  5113.           elem.__serializing = false;
  5114.  
  5115.         }
  5116.         Polymer.Base.detached = function () {
  5117.           Promise.resolve(this).then(detachedPlus);
  5118.           return Polymer.Base.detached92();
  5119.         };
  5120.       }
  5121.  
  5122.  
  5123.       if (ENABLE_discreteTasking) {
  5124.  
  5125.         Polymer.Base.__connInit__ = function () {
  5126.           setupDiscreteTasks(this);
  5127.           // if (WEAK_REF_BINDING && (this.is || this instanceof Node)) {
  5128.           //   setupWeakRef(this)
  5129.           // }
  5130.         }
  5131.  
  5132.  
  5133.         /** @type {Function} */
  5134.         const connectedCallbackK = function (...args) {
  5135.           !this.mh35 && typeof this.__connInit__ === 'function' && this.__connInit__();
  5136.           const r = this[qm53](...args);
  5137.           !this.mh35 && typeof this.__connInit__ === 'function' && this.__connInit__();
  5138.           this.mh35 = 1;
  5139.           return r;
  5140.         };
  5141.  
  5142.         connectedCallbackK.m353 = 1;
  5143.  
  5144.  
  5145.         const qt53 = Polymer.Base.connectedCallback;
  5146.         Polymer.Base[qm53] = dmf.get(qt53) || qt53;
  5147.  
  5148.         Polymer.Base.connectedCallback = connectedCallbackK;
  5149.  
  5150.  
  5151.         /** @type {Function} */
  5152.         const createdK = function (...args) {
  5153.           !this.mh36 && typeof this.__connInit__ === 'function' && this.__connInit__();
  5154.           const r = this[qn53](...args);
  5155.           !this.mh36 && typeof this.__connInit__ === 'function' && this.__connInit__();
  5156.           this.mh36 = 1;
  5157.           return r;
  5158.         };
  5159.  
  5160.  
  5161.         createdK.m353 = 1;
  5162.         Polymer.Base[qn53] = Polymer.Base.created;
  5163.         Polymer.Base.created = createdK;
  5164.  
  5165.       }
  5166.  
  5167.     })();
  5168.  
  5169.  
  5170.     /*
  5171.  
  5172.       e.nativeAppendChild = d.prototype.appendChild,
  5173.       d.prototype.appendChild = function(h) {
  5174.           return function(l) {
  5175.               if (l instanceof DocumentFragment) {
  5176.                   var m = Array.from(l.children);
  5177.                   l = h.nativeAppendChild.call(this, l);
  5178.                   if (this.isConnected) {
  5179.                       m = g(m);
  5180.                       for (var p = m.next(); !p.done; p = m.next())
  5181.                           YD(p.value)
  5182.                   }
  5183.                   return l
  5184.               }
  5185.               m = l instanceof Element && l.isConnected;
  5186.               p = h.nativeAppendChild.call(this, l);
  5187.               m && ZD(l);
  5188.               this.isConnected && YD(l);
  5189.               return p
  5190.           }
  5191.       }(e),
  5192.  
  5193.     */
  5194.  
  5195.     CHANGE_appendChild && !Node.prototype.appendChild73 && Node.prototype.appendChild && (() => {
  5196.  
  5197.       let __src__ = '';
  5198.       const handlerCanplay = (evt) => {
  5199.         const a = evt.target;
  5200.         console.log('[yt-js-engine-tamer]', `video element added to dom | canplay`, mWeakRef(a), a.readyState, a.networkState, a.currentTime);
  5201.         if (a.currentTime < 1e-8 && a.currentTime > -1e-9 && a.autoplay === false) a.currentTime += 1e-8;
  5202.       };
  5203.  
  5204.       const handlerTimeupdate = (evt) => {
  5205.         const a = evt.target;
  5206.         console.log('[yt-js-engine-tamer]', `video element added to dom | ontimeupdate`, mWeakRef(a), a.readyState, a.networkState, a.currentTime);
  5207.         if (a.duration < 2.01 && a.duration > 1.99 && a.currentSrc === __src__) {
  5208.           try {
  5209.             URL.revokeObjectURL(__src__);
  5210.             __src__ = '';
  5211.           } finally {
  5212.             console.log('[yt-js-engine-tamer]', `video element added to dom | revokeObjectURL`, mWeakRef(a), a.readyState, a.networkState, a.currentTime);
  5213.           }
  5214.         }
  5215.       };
  5216.  
  5217.       const f = Node.prototype.appendChild73 = Node.prototype.appendChild;
  5218.       if (f) Node.prototype.appendChild = function (a) {
  5219.         if (this instanceof Element) { // exclude DocumentFragment
  5220.           try {
  5221.             if (a instanceof HTMLVideoElement && FIX_VIDEO_BLOCKING && typeof AbortSignal !== 'undefined') {
  5222.               const src = `${a.src}`;
  5223.               const b = src.length > 5 && src.startsWith('blob:') && typeof a.ontimeupdate === 'function' && a.autoplay === false && a.paused === true && a.isConnected === false;
  5224.               if (b) {
  5225.                 __src__ = src;
  5226.                 a.addEventListener('canplay', handlerCanplay, { once: true, passive: true, capture: false });
  5227.                 a.addEventListener('timeupdate', handlerTimeupdate, { once: true, passive: true, capture: false });
  5228.               }
  5229.               console.log('[yt-js-engine-tamer]', `video element added to dom | treatment = ${b}`, mWeakRef(a), a.readyState, a.networkState);
  5230.             } else {
  5231.               let checkFragmentA = (a instanceof DocumentFragment);
  5232.               if (!NO_PRELOAD_GENERATE_204_BYPASS && document.head === this) {
  5233.                 if (headLinkCollection === null) headLinkCollection = document.head.getElementsByTagName('LINK');
  5234.                 for (const node of headLinkCollection) {
  5235.                   if (node.rel === 'preload' && node.as === 'fetch') {
  5236.                     node.rel = 'prefetch'; // see https://github.com/GoogleChromeLabs/quicklink
  5237.                   }
  5238.                 }
  5239.               } else if (checkFragmentA && this.nodeName.startsWith('YT-')) { // yt-animated-rolling-number, yt-attributed-string
  5240.                 checkFragmentA = false;
  5241.               }
  5242.               if (checkFragmentA && a.firstElementChild === null) {
  5243.                 // no element in fragmentA
  5244.                 let doNormal = false;
  5245.                 for (let child = a.firstChild; child instanceof Node; child = child.nextSibling) {
  5246.                   if (child.nodeType === 3) { doNormal = true; break; }
  5247.                 }
  5248.                 if (!doNormal) return a;
  5249.               }
  5250.             }
  5251.           } catch (e) {
  5252.             console.log(e);
  5253.           }
  5254.         }
  5255.         return arguments.length === 1 ? f.call(this, a) : f.apply(this, arguments);
  5256.       }
  5257.  
  5258.  
  5259.     })();
  5260.  
  5261.     if (FIX_Shady) {
  5262.  
  5263.       observablePromise(() => {
  5264.         const { ShadyDOM, ShadyCSS } = window;
  5265.         if (ShadyDOM) {
  5266.           ShadyDOM.handlesDynamicScoping = false; // 9 of 10
  5267.           ShadyDOM.noPatch = true; // 1 of 10
  5268.           ShadyDOM.patchOnDemand = false; // 1 of 10
  5269.           ShadyDOM.preferPerformance = true; // 1 of 10
  5270.           ShadyDOM.querySelectorImplementation = undefined; // 1 of 10
  5271.         }
  5272.         if (ShadyCSS) {
  5273.           ShadyCSS.nativeCss = true; // 1 of 10
  5274.           ShadyCSS.nativeShadow = true; // 6 of 10
  5275.           ShadyCSS.cssBuild = undefined; // 1 of 10
  5276.           ShadyCSS.disableRuntime = true; // 1 of 10
  5277.         }
  5278.         if (ShadyDOM && ShadyCSS) return 1;
  5279.       }, promiseForTamerTimeout).obtain(); // clear until 1 is return
  5280.  
  5281.     }
  5282.  
  5283.  
  5284.     // let schedulerInstancePropOfTimerType = '';
  5285.     // let schedulerInstancePropOfTimerId = '';
  5286.     (FIX_schedulerInstanceInstance & 2) && (async () => {
  5287.  
  5288.       const schedulerInstanceInstance_ = await schedulerInstanceObservable.obtain();
  5289.  
  5290.       if (!schedulerInstanceInstance_) return;
  5291.  
  5292.       const checkOK = typeof schedulerInstanceInstance_.start === 'function' && !schedulerInstanceInstance_.start993 && !schedulerInstanceInstance_.stop && !schedulerInstanceInstance_.cancel && !schedulerInstanceInstance_.terminate && !schedulerInstanceInstance_.interupt;
  5293.       if (checkOK) {
  5294.  
  5295.         schedulerInstanceInstance_.start993 = schedulerInstanceInstance_.start;
  5296.  
  5297.         let requestingFn = null;
  5298.         let requestingArgs = null;
  5299.  
  5300.         const f = function () {
  5301.           requestingFn = this.fn;
  5302.           requestingArgs = [...arguments];
  5303.           return 12373;
  5304.         };
  5305.  
  5306.         const fakeFns = [
  5307.           f.bind({ fn: requestAnimationFrame }),
  5308.           f.bind({ fn: setInterval }),
  5309.           f.bind({ fn: setTimeout }),
  5310.           f.bind({ fn: requestIdleCallback })
  5311.         ];
  5312.  
  5313.         let mzt = 0;
  5314.  
  5315.         let _fnSelectorProp = null;
  5316.         const mkFns = new Array(4);
  5317.  
  5318.         /*
  5319.           case 1:
  5320.               var a = this.K;
  5321.               this.g = this.I ? window.requestIdleCallback(a, {
  5322.                   timeout: 3E3
  5323.               }) : window.setTimeout(a, ma);
  5324.               break;
  5325.           case 2:
  5326.               this.g = window.setTimeout(this.M, this.N);
  5327.               break;
  5328.           case 3:
  5329.               this.g = window.requestAnimationFrame(this.L);
  5330.               break;
  5331.           case 4:
  5332.               this.g = window.setTimeout(this.J, 0)
  5333.           }
  5334.  
  5335.         */
  5336.         const startFnHandler = {
  5337.           get(target, prop, receiver) {
  5338.             if (prop === '$$12377$$') return true;
  5339.             if (prop === '$$12378$$') return target;
  5340.  
  5341.             // console.log('get',prop)
  5342.             return target[prop]
  5343.           },
  5344.           set(target, prop, value, receiver) {
  5345.             // console.log('set', prop, value)
  5346.  
  5347.             if (value >= 1 && value <= 4) _fnSelectorProp = prop;
  5348.             if (value === 12373 && _fnSelectorProp) {
  5349.  
  5350.               const schedulerTypeSelection = target[_fnSelectorProp];
  5351.               const timerIdProp = prop;
  5352.  
  5353.               // if (schedulerTypeSelection && schedulerTypeSelection >= 1 && schedulerTypeSelection <= 4 && timerIdProp) {
  5354.               //   schedulerInstancePropOfTimerType = _fnSelectorProp || '';
  5355.               //   schedulerInstancePropOfTimerId = timerIdProp || '';
  5356.               // }
  5357.  
  5358.               if (schedulerTypeSelection === 3 && requestingFn === requestAnimationFrame) { // rAF(fn)
  5359.                 target[timerIdProp] = baseRAF.apply(window, requestingArgs);
  5360.               } else if (schedulerTypeSelection === 2 && requestingFn === setTimeout) { // setTimeout(fn, delay)
  5361.                 // rare
  5362.                 target[timerIdProp] = mkFns[2].apply(window, requestingArgs);
  5363.               } else if (schedulerTypeSelection === 4 && requestingFn === setTimeout && !requestingArgs[1]) { // setTimeout(fn, 0)
  5364.                 // often
  5365.                 if ((FIX_schedulerInstanceInstance & 4) && typeof nextBrowserTick == 'function') {
  5366.                   const f = requestingArgs[0];
  5367.                   const tir = ++mzt;
  5368.                   nextBrowserTick(() => {
  5369.                     if (target[timerIdProp] === -tir) f();
  5370.                   });
  5371.                   target[_fnSelectorProp] = 940;
  5372.                   target[timerIdProp] = -tir;
  5373.                 } else {
  5374.                   const f = requestingArgs[0];
  5375.                   const tir = ++mzt;
  5376.                   Promise.resolve().then(() => {
  5377.                     if (target[timerIdProp] === -tir) f();
  5378.                   });
  5379.                   target[_fnSelectorProp] = 930;
  5380.                   target[timerIdProp] = -tir;
  5381.                 }
  5382.               } else if (schedulerTypeSelection === 1 && (requestingFn === requestIdleCallback || requestingFn === setTimeout)) { // setTimeout(requestIdleCallback)
  5383.                 // often
  5384.                 if (requestingFn === requestIdleCallback) {
  5385.                   target[timerIdProp] = requestIdleCallback.apply(window, requestingArgs);
  5386.                 } else {
  5387.                   target[timerIdProp] = mkFns[2].apply(window, requestingArgs);
  5388.                 }
  5389.               } else {
  5390.                 target[_fnSelectorProp] = 0;
  5391.                 target[timerIdProp] = 0;
  5392.               }
  5393.             } else {
  5394.               target[prop] = value;
  5395.             }
  5396.             return true;
  5397.           }
  5398.         };
  5399.  
  5400.         let startBusy = false;
  5401.         schedulerInstanceInstance_.start = function () {
  5402.           if (startBusy) return;
  5403.           startBusy = true;
  5404.           try {
  5405.             mkFns[0] = window.requestAnimationFrame;
  5406.             mkFns[1] = window.setInterval;
  5407.             mkFns[2] = window.setTimeout;
  5408.             mkFns[3] = window.requestIdleCallback;
  5409.             const tThis = this['$$12378$$'] || this;
  5410.             window.requestAnimationFrame = fakeFns[0]
  5411.             window.setInterval = fakeFns[1]
  5412.             window.setTimeout = fakeFns[2]
  5413.             window.requestIdleCallback = fakeFns[3]
  5414.             _fnSelectorProp = null;
  5415.             tThis.start993.call(new Proxy(tThis, startFnHandler));
  5416.             _fnSelectorProp = null;
  5417.             window.requestAnimationFrame = mkFns[0];
  5418.             window.setInterval = mkFns[1];
  5419.             window.setTimeout = mkFns[2];
  5420.             window.requestIdleCallback = mkFns[3];
  5421.           } catch (e) {
  5422.             console.warn(e);
  5423.           }
  5424.           startBusy = false;
  5425.         }
  5426.  
  5427.         schedulerInstanceInstance_.start.toString = schedulerInstanceInstance_.start993.toString.bind(schedulerInstanceInstance_.start993);
  5428.  
  5429.       }
  5430.     })();
  5431.  
  5432.     FIX_yt_player && (async () => {
  5433.       // rAf scheduling
  5434.  
  5435.       const _yt_player = await _yt_player_observable.obtain();
  5436.  
  5437.       if (!_yt_player || typeof _yt_player !== 'object') return;
  5438.  
  5439.       let keyZqOu = getZqOu(_yt_player);
  5440.  
  5441.  
  5442.       if (!keyZqOu) return;
  5443.  
  5444.  
  5445.       const g = _yt_player
  5446.       let k = keyZqOu
  5447.  
  5448.       const gk = g[k];
  5449.       if (typeof gk !== 'function') return;
  5450.       const gkp = gk.prototype;
  5451.  
  5452.       let dummyObject = new gk;
  5453.       let nilFunc = () => { };
  5454.  
  5455.       let nilObj = {};
  5456.  
  5457.       // console.log(1111111111)
  5458.  
  5459.       let keyBoolD = '';
  5460.       let keyWindow = '';
  5461.       let keyFuncC = '';
  5462.       let keyCidj = '';
  5463.  
  5464.       for (const [t, y] of Object.entries(dummyObject)) {
  5465.         if (y instanceof Window) keyWindow = t;
  5466.       }
  5467.  
  5468.       const dummyObjectProxyHandler = {
  5469.         get(target, prop) {
  5470.           let v = target[prop]
  5471.           if (v instanceof Window && !keyWindow) {
  5472.             keyWindow = t;
  5473.           }
  5474.           let y = typeof v === 'function' ? nilFunc : typeof v === 'object' ? nilObj : v;
  5475.           if (prop === keyWindow) y = {
  5476.             requestAnimationFrame(f) {
  5477.               return 3;
  5478.             },
  5479.             cancelAnimationFrame() {
  5480.  
  5481.             }
  5482.           }
  5483.           if (!keyFuncC && typeof v === 'function' && !(prop in target.constructor.prototype)) {
  5484.             keyFuncC = prop;
  5485.           }
  5486.           // console.log('[get]', prop, typeof target[prop])
  5487.  
  5488.  
  5489.           return y;
  5490.         },
  5491.         set(target, prop, value) {
  5492.  
  5493.           if (typeof value === 'boolean' && !keyBoolD) {
  5494.             keyBoolD = prop;
  5495.           }
  5496.           if (typeof value === 'number' && !keyCidj && value >= 2) {
  5497.             keyCidj = prop;
  5498.           }
  5499.  
  5500.           // console.log('[set]', prop, value)
  5501.           target[prop] = value
  5502.  
  5503.           return true;
  5504.         }
  5505.       };
  5506.  
  5507.       dummyObject.start.call(new Proxy(dummyObject, dummyObjectProxyHandler));
  5508.  
  5509.       // console.log('gkp.start',gkp.start);
  5510.       // console.log('gkp.stop',gkp.stop);
  5511.       gkp._activation = false;
  5512.  
  5513.       gkp.start = function () {
  5514.         // p59 || console.log(12100)
  5515.         if (!this._activation) {
  5516.           this._activation = true;
  5517.           foregroundPromiseFn().then(() => {
  5518.             this._activation = false;
  5519.             if (this[keyCidj]) {
  5520.               Promise.resolve().then(this[keyFuncC]);
  5521.             }
  5522.           });
  5523.         }
  5524.         this[keyCidj] = 1;
  5525.         this[keyBoolD] = true;
  5526.       }
  5527.         ;
  5528.       gkp.stop = function () {
  5529.         this[keyCidj] = null
  5530.       }
  5531.  
  5532.  
  5533.       /*
  5534.         g[k].start = function() {
  5535.             this.stop();
  5536.             this.D = true;
  5537.             var a = requestAnimationFrame
  5538.               , b = cancelAnimationFrame;
  5539.             this.j =  a.call(this.B, this.C)
  5540.         }
  5541.         ;
  5542.         g[k].stop = function() {
  5543.             if (this.isActive()) {
  5544.                 var a = requestAnimationFrame
  5545.                   , b = cancelAnimationFrame;
  5546.                 b.call(this.B, this.j)
  5547.             }
  5548.             this.j = null
  5549.         }
  5550.       */
  5551.  
  5552.       const keyzo = PERF_471489_ ? getzo(_yt_player) : null;
  5553.  
  5554.       if (keyzo) {
  5555.  
  5556.         k = keyzo;
  5557.  
  5558.         const attrUpdateFn = g[k];
  5559.         // console.log(5992, attrUpdateFn)
  5560.         g['$$original$$' + k] = attrUpdateFn;
  5561.         const zoTransform = async (a, c) => {
  5562.  
  5563.           let transformType = '';
  5564.           let transformValue = 0;
  5565.           let transformUnit = '';
  5566.           let transformTypeI = 0;
  5567.  
  5568.           const aStyle = a.style;
  5569.  
  5570.           if (c.length < 9) {
  5571.  
  5572.           } else if (c.startsWith('scalex(0.') || (c === 'scalex(0)' || c === 'scalex(1)')) {
  5573.             let p = c.substring(7, c.length - 1);
  5574.             let q = p.length >= 1 ? parseFloat(p) : -1;
  5575.             if (q > -1e-5 && q < 1 + 1e-5) {
  5576.               transformType = 'scaleX'
  5577.               transformValue = q;
  5578.               transformUnit = '';
  5579.               transformTypeI = 1;
  5580.             }
  5581.           } else if (c.startsWith('translateX(') && c.endsWith('px)')) {
  5582.             let p = c.substring(11, c.length - 3);
  5583.             let q = p.length >= 1 ? parseFloat(p) : NaN;
  5584.             if (typeof q === 'number' && !isNaN(q)) {
  5585.               transformType = 'translateX'
  5586.               transformValue = q;
  5587.               transformUnit = 'px';
  5588.               transformTypeI = 2;
  5589.             } else if (p === 'NaN') {
  5590.               return;
  5591.             }
  5592.           } else if (c.startsWith('scaley(0.') || (c === 'scaley(0)' || c === 'scaley(1)')) {
  5593.             let p = c.substring(7, c.length - 1);
  5594.             let q = p.length >= 1 ? parseFloat(p) : -1;
  5595.             if (q > -1e-5 && q < 1 + 1e-5) {
  5596.               transformType = 'scaleY'
  5597.               transformValue = q;
  5598.               transformUnit = '';
  5599.               transformTypeI = 1;
  5600.             }
  5601.           } else if (c.startsWith('translateY(') && c.endsWith('px)')) {
  5602.             let p = c.substring(11, c.length - 3);
  5603.             let q = p.length >= 1 ? parseFloat(p) : NaN;
  5604.             if (typeof q === 'number' && !isNaN(q)) {
  5605.               transformType = 'translateY'
  5606.               transformValue = q;
  5607.               transformUnit = 'px';
  5608.               transformTypeI = 2;
  5609.             } else if (p === 'NaN') {
  5610.               return;
  5611.             }
  5612.           } else if (c.startsWith('scalex(') && c.includes('e-')) {
  5613.             // scalex(1.252057684158767e-16)
  5614.             // scalex(3.0393632069734948e-9)
  5615.             let p = c.substring(7, c.length - 1);
  5616.             let q = p.length >= 1 ? parseFloat(p) : -1;
  5617.             if (q > -1e-5 && q < 1e-5) {
  5618.               transformType = 'scaleX'
  5619.               transformValue = 0;
  5620.               transformUnit = '';
  5621.               transformTypeI = 1;
  5622.             }
  5623.           } else if (c.startsWith('scaley(') && c.includes('e-')) {
  5624.             let p = c.substring(7, c.length - 1);
  5625.             let q = p.length >= 1 ? parseFloat(p) : -1;
  5626.             if (q > -1e-5 && q < 1e-5) {
  5627.               transformType = 'scaleY'
  5628.               transformValue = 0;
  5629.               transformUnit = '';
  5630.               transformTypeI = 1;
  5631.             }
  5632.           }
  5633.  
  5634.           if (transformTypeI === 1) {
  5635.             const q = Math.round(transformValue * steppingScaleN) / steppingScaleN;
  5636.             const vz = toFixed2(q, 3);
  5637.             c = `${transformType}(${vz})`;
  5638.             const cv = aStyle.transform;
  5639.             if (c === cv) return;
  5640.             aStyle.transform = c;
  5641.           } else if (transformTypeI === 2) {
  5642.             const q = transformValue;
  5643.             const vz = toFixed2(q, 1);
  5644.             c = `${transformType}(${vz}${transformUnit})`;
  5645.             const cv = aStyle.transform;
  5646.             if (c === cv) return;
  5647.             aStyle.transform = c;
  5648.           } else { // eg empty
  5649.             const cv = aStyle.transform;
  5650.             if (!c && !cv) return;
  5651.             else if (c === cv) return;
  5652.             aStyle.transform = c;
  5653.           }
  5654.  
  5655.         };
  5656.  
  5657.         const elmTransformTemp = new WeakMap();
  5658.         const elmPropTemps = {
  5659.           'display': new WeakMap(),
  5660.           'width': new WeakMap(),
  5661.           'height': new WeakMap(),
  5662.           'outlineWidth': new WeakMap(),
  5663.           'position': new WeakMap(),
  5664.           'padding': new WeakMap(),
  5665.           "cssText": new WeakMap(),
  5666.           "right": new WeakMap(),
  5667.           "left": new WeakMap(),
  5668.           "top": new WeakMap(),
  5669.           "bottom": new WeakMap(),
  5670.           "transitionDelay": new WeakMap(),
  5671.           "marginLeft": new WeakMap(),
  5672.           "marginTop": new WeakMap(),
  5673.           "marginRight": new WeakMap(),
  5674.           "marginBottom": new WeakMap(),
  5675.         }
  5676.  
  5677.         const ns5 = Symbol();
  5678.         const nextModify = (a, c, m, f, immediate) => {
  5679.           const a_ = a;
  5680.           const m_ = m;
  5681.           const noKey = !m_.has(a_);
  5682.           if (immediate || noKey) {
  5683.             m_.set(a_, ns5);
  5684.             f(a_, c);
  5685.             noKey && nextBrowserTick_(() => {
  5686.               const d = m_.get(a_);
  5687.               if (d === undefined) return;
  5688.               m_.delete(a_);
  5689.               if (d !== ns5) f(a_, d);
  5690.             });
  5691.           } else {
  5692.             m_.set(a_, c);
  5693.           }
  5694.         };
  5695.  
  5696.         const set66 = new Set();
  5697.         // const set77 = new Set(['top', 'left', 'bottom', 'right']); // caption positioning - immediate change
  5698.  
  5699.         const modifiedFn = function (a, b, c, immediateChange = false) { // arrow function does not have function.prototype
  5700.  
  5701.           // console.log(140000, a, b, c);
  5702.           if (typeof c === 'number' && typeof b === 'string' && a instanceof HTMLElement) {
  5703.             const num = c;
  5704.             c = `${num}`;
  5705.             if (c.length > 5) c = (num < 10 && num > -10) ? toFixed2(num, 3) : toFixed2(num, 1);
  5706.           }
  5707.  
  5708.           if (typeof b === 'string' && typeof c === 'string' && a instanceof HTMLElement) {
  5709.  
  5710.             let elmPropTemp = null;
  5711.  
  5712.             if (b === "transform") {
  5713.  
  5714.               nextModify(a, c, elmTransformTemp, zoTransform, immediateChange);
  5715.               return;
  5716.  
  5717.             } else if (elmPropTemp = elmPropTemps[b]) {
  5718.  
  5719.               // if (c.length > 5 && c.includes('.')) {
  5720.               //   console.log(123213, c)
  5721.               // }
  5722.  
  5723.               const b_ = b;
  5724.               nextModify(a, c, elmPropTemp, (a, c) => {
  5725.                 const style = a.style;
  5726.                 const cv = style[b_];
  5727.                 if (!cv && !c) return;
  5728.                 if (cv === c) return;
  5729.                 style[b_] = c;
  5730.               }, immediateChange);
  5731.               return;
  5732.  
  5733.             } else if (b === "outline-width") {
  5734.  
  5735.               const b_ = 'outlineWidth';
  5736.               elmPropTemp = elmPropTemps[b_];
  5737.               nextModify(a, c, elmPropTemp, (a, c) => {
  5738.                 const style = a.style;
  5739.                 const cv = style[b_];
  5740.                 if (!cv && !c) return;
  5741.                 if (cv === c) return;
  5742.                 style[b_] = c;
  5743.               }, immediateChange);
  5744.               return;
  5745.  
  5746.             } else if (b === 'maxWidth' || b === 'maxHeight') {
  5747.               // I think these can be directly assigned.
  5748.  
  5749.               const b_ = b;
  5750.               const style = a.style;
  5751.               const cv = style[b_];
  5752.               if (!cv && !c) return;
  5753.               if (cv === c) return;
  5754.               style[b_] = c;
  5755.               return;
  5756.  
  5757.             } else {
  5758.               // if(immediate && elmPropTemps[b]){
  5759.               //   console.log(5191, b)
  5760.               // }
  5761.               // caption-window
  5762.               // margin-left max-height max-width font-family fill color font-size background white-space margin
  5763.               // text-align background-color
  5764.               // console.log(27304, a, b, c)
  5765.               if (!set66.has(b)) {
  5766.                 set66.add(b);
  5767.                 nextBrowserTick_(() => {
  5768.                   if (!a.classList.contains('caption-window') && !a.classList.contains('ytp-caption-segment')) {
  5769.                     console.log(27304, a, b, c)
  5770.                   }
  5771.                 })
  5772.               }
  5773.             }
  5774.  
  5775.             attrUpdateFn.call(this, a, b, c);
  5776.             return;
  5777.           } else if (typeof (b || 0) === 'object') {
  5778.  
  5779.             // this is to fix caption positioning
  5780.             // const immediate = (a.id || 0).length > 14 && (('top' in b) || ('left' in b) || ('right' in b) || ('bottom' in b));
  5781.             const immediate = (a.id || 0).length > 14;
  5782.             for (const [k, v] of Object.entries(b)) {
  5783.               modifiedFn.call(this, a, k, v, immediate);
  5784.             }
  5785.  
  5786.           } else {
  5787.             console.log(27306, a, b, c);
  5788.  
  5789.             attrUpdateFn.call(this, a, b, c);
  5790.             return;
  5791.           }
  5792.  
  5793.           // console.log(130000, a, b, c);
  5794.  
  5795.         };
  5796.         g[k] = modifiedFn;
  5797.  
  5798.  
  5799.         /*
  5800.  
  5801.             g.zo = function(a, b, c) {
  5802.                 if ("string" === typeof b)
  5803.                     (b = yo(a, b)) && (a.style[b] = c);
  5804.                 else
  5805.                     for (var d in b) {
  5806.                         c = a;
  5807.                         var e = b[d]
  5808.                           , f = yo(c, d);
  5809.                         f && (c.style[f] = e)
  5810.                     }
  5811.             }
  5812.  
  5813.  
  5814.         */
  5815.  
  5816.  
  5817.       }
  5818.  
  5819.  
  5820.  
  5821.       const keyuG = PERF_471489_ ? getuG(_yt_player) : null;
  5822.  
  5823.       if (keyuG) {
  5824.  
  5825.         k = keyuG;
  5826.  
  5827.         const gk = g[k];
  5828.         const gkp = gk.prototype;
  5829.  
  5830.  
  5831.         /** @type { Map<string, WeakMap<any, any>> } */
  5832.         const ntLogs = new Map();
  5833.  
  5834.         if (typeof gkp.updateValue === 'function' && gkp.updateValue.length === 2 && !gkp.updateValue31) {
  5835.  
  5836.           gkp.updateValue31 = gkp.updateValue;
  5837.           gkp.updateValue = function (a, b) {
  5838.             if (typeof a !== 'string') return this.updateValue31(a, b);
  5839.  
  5840.             const element = this.element;
  5841.             if (!(element instanceof HTMLElement)) return this.updateValue31(a, b);
  5842.  
  5843.             let ntLog = ntLogs.get(a);
  5844.             if (!ntLog) ntLogs.set(a, (ntLog = new WeakMap()));
  5845.  
  5846.             let cache = ntLog.get(element);
  5847.             if (cache && cache.value === b) {
  5848.               return;
  5849.             }
  5850.             if (!cache) {
  5851.               this.__oldValueByUpdateValue__ = null;
  5852.               ntLog.set(element, cache = { value: b });
  5853.             } else {
  5854.               this.__oldValueByUpdateValue__ = cache.value;
  5855.               cache.value = b;
  5856.             }
  5857.  
  5858.             return this.updateValue31(a, b);
  5859.           }
  5860.  
  5861.           /*
  5862.             g.k.update = function(a) {
  5863.                 for (var b = g.u(Object.keys(a)), c = b.next(); !c.done; c = b.next())
  5864.                     c = c.value,
  5865.                     this.updateValue(c, a[c])
  5866.             }
  5867.             ;
  5868.             g.k.updateValue = function(a, b) {
  5869.                 (a = this.Td["{{" + a + "}}"]) && wG(this, a[0], a[1], b)
  5870.             }
  5871.           */
  5872.  
  5873.         }
  5874.  
  5875.  
  5876.       }
  5877.  
  5878.  
  5879.  
  5880.  
  5881.     })();
  5882.  
  5883.  
  5884.     FIX_yt_player && FIX_SHORTCUTKEYS > 0 && (async () => {
  5885.       // keyboard shortcut keys controller
  5886.  
  5887.       const _yt_player = await _yt_player_observable.obtain();
  5888.  
  5889.       if (!_yt_player || typeof _yt_player !== 'object') return;
  5890.  
  5891.       keyboardController(_yt_player);
  5892.  
  5893.     })();
  5894.  
  5895.     FIX_yt_player && (async () => {
  5896.       // timer scheduling
  5897.  
  5898.       const _yt_player = await _yt_player_observable.obtain();
  5899.  
  5900.       if (!_yt_player || typeof _yt_player !== 'object') return;
  5901.  
  5902.       let keyZqQu = getZqQu(_yt_player);
  5903.  
  5904.       if (!keyZqQu) return;
  5905.  
  5906.       const g = _yt_player
  5907.       let k = keyZqQu
  5908.  
  5909.       const gk = g[k];
  5910.       if (typeof gk !== 'function') return;
  5911.       const gkp = gk.prototype;
  5912.  
  5913.       const extractKeysZqQu = () => {
  5914.  
  5915.  
  5916.         let _keyeC = '';
  5917.         try {
  5918.           gkp.stop.call(new Proxy({
  5919.             isActive: () => { }
  5920.           }, {
  5921.             set(target, prop, value) {
  5922.               if (value === 0) _keyeC = prop;
  5923.               return true;
  5924.             }
  5925.           }));
  5926.         } catch (e) { }
  5927.         if (!_keyeC) return;
  5928.         const keyeC = _keyeC;
  5929.  
  5930.         let keyC = ''; // this.C = this.ST.bind(this)
  5931.         let keyhj = ''; // 1000ms
  5932.         try {
  5933.           gkp.start.call(new Proxy({
  5934.             stop: () => { },
  5935.             [keyeC]: 0,
  5936.           }, {
  5937.             get(target, prop) {
  5938.               if (prop in target) return target[prop];
  5939.               if (!keyC) {
  5940.                 keyC = prop;
  5941.                 return null; // throw error
  5942.               }
  5943.               else if (!keyhj) {
  5944.                 keyhj = prop;
  5945.               }
  5946.  
  5947.             }
  5948.           }));
  5949.         } catch (e) {
  5950.           if (!keyC || !keyhj) {
  5951.             console.log(e)
  5952.           }
  5953.         }
  5954.  
  5955.         if (!keyC || !keyhj) return;
  5956.         let keyST = '';
  5957.         let keyj = '';
  5958.         let keyB = '';
  5959.         let keyxa = '';
  5960.  
  5961.         const possibleKs = new Set();
  5962.  
  5963.         for (const [k, v] of Object.entries(gkp)) {
  5964.           if (k === 'stop' || k === 'start' || k === 'isActive' || k === 'constructor' || k === keyeC || k === keyC || k === keyhj) {
  5965.             continue;
  5966.           }
  5967.           if (typeof v === 'function') {
  5968.             const m = /this\.(\w+)\.call\(this\.(\w+)\)/.exec(v + '');
  5969.             if (m) {
  5970.               keyST = k;
  5971.               keyj = m[1];
  5972.               keyB = m[2];
  5973.             } else {
  5974.               possibleKs.add(k);
  5975.             }
  5976.           }
  5977.         }
  5978.  
  5979.         if (!keyST || !keyj || !keyB) return;
  5980.  
  5981.         for (const k of possibleKs) {
  5982.           if (k === keyST || k === keyj || k === keyB) {
  5983.             continue;
  5984.           }
  5985.           const v = gkp[k];
  5986.           if (typeof v === 'function' && (v + '').includes(`this.stop();delete this.${keyj};delete this.${keyB}`)) {
  5987.             keyxa = k;
  5988.           }
  5989.         }
  5990.  
  5991.         return [keyeC, keyC, keyhj, keyST, keyj, keyB, keyxa];
  5992.  
  5993.       }
  5994.  
  5995.       const keys = extractKeysZqQu();
  5996.       if (!keys || !keys.length) return;
  5997.       const [keyeC, keyC, keyhj, keyST, keyj, keyB, keyxa] = keys; // [timerId, binded executorFn, 1000ms, executorFn, dataJ, objectB, disposeFn]
  5998.  
  5999.       if (!keyeC || !keyC || !keyhj || !keyST || !keyj || !keyB || !keyxa) return;
  6000.  
  6001.       let disposeKeys = null;
  6002.  
  6003.       gkp[keyxa] = function () {
  6004.         // dispose
  6005.         if (!disposeKeys) {
  6006.           disposeKeys = Object.getOwnPropertyNames(this).filter(key => {
  6007.             if (key != keyeC && key != keyC && key != keyhj && key != keyST && key != keyj && key != keyB && key != keyxa) {
  6008.               const t = typeof this[key];
  6009.               return t === 'undefined' || t === 'object'
  6010.             }
  6011.             return false;
  6012.           });
  6013.         }
  6014.         for (const key of disposeKeys) {
  6015.           const v = this[key];
  6016.           if ((v || 0).length >= 1) v.length = 0; // function (){if(this.fn)for(;this.fn.length;)this.fn.shift()()}
  6017.         }
  6018.         if (this[keyeC] > 0) this.stop();
  6019.         this[keyj] = null;
  6020.         this[keyB] = null;
  6021.       };
  6022.  
  6023.       gkp.start = function (a) {
  6024.         if (this[keyeC] > 0) this.stop();
  6025.         const delay = void 0 !== a ? a : this[keyhj];
  6026.         this[keyeC] = window.setTimeout(this[keyC], delay);
  6027.       };
  6028.       gkp.stop = function () {
  6029.         if (this[keyeC] > 0) {
  6030.           window.clearTimeout(this[keyeC]);
  6031.           this[keyeC] = 0;
  6032.         }
  6033.       };
  6034.  
  6035.       gkp.isActive = function () {
  6036.         return this[keyeC] > 0;
  6037.       };
  6038.  
  6039.       gkp[keyST] = function () {
  6040.         this.stop(); // this[keyeC] = 0;
  6041.         const fn = this[keyj];
  6042.         const obj = this[keyB];
  6043.         let skip = false;
  6044.         if (!fn) skip = true;
  6045.         else if (IGNORE_bufferhealth_CHECK && obj) {
  6046.           let m;
  6047.           if ((m = obj[keyC]) instanceof Map || (m = obj[keyj]) instanceof Map) {
  6048.             if (m.has("bufferhealth")) skip = true;
  6049.           }
  6050.         }
  6051.         if (!skip) {
  6052.           fn.call(obj);
  6053.         }
  6054.       };
  6055.  
  6056.  
  6057.  
  6058.  
  6059.       /*
  6060.  
  6061.       g.k.eC = 0;
  6062.       g.k.xa = function() {
  6063.           g.Qu.Vf.xa.call(this);
  6064.           this.stop();
  6065.           delete this.j;
  6066.           delete this.B
  6067.       }
  6068.       ;
  6069.       g.k.start = function(a) {
  6070.           this.stop();
  6071.           this.eC = g.gg(this.C, void 0 !== a ? a : this.hj)
  6072.       }
  6073.       ;
  6074.       g.k.stop = function() {
  6075.           this.isActive() && g.Sa.clearTimeout(this.eC);
  6076.           this.eC = 0
  6077.       }
  6078.       ;
  6079.       g.k.isActive = function() {
  6080.           return 0 != this.eC
  6081.       }
  6082.       ;
  6083.       g.k.ST = function() {
  6084.           this.eC = 0;
  6085.           this.j && this.j.call(this.B)
  6086.       }
  6087.       ;
  6088.       */
  6089.  
  6090.  
  6091.  
  6092.  
  6093.     })();
  6094.  
  6095.     FIX_Animation_n_timeline && (async () => {
  6096.  
  6097.       const [timeline, Animation] = await Promise.all([timelineObservable.obtain(), animationObservable.obtain()]);
  6098.  
  6099.       if (!timeline || !Animation) return;
  6100.  
  6101.       const aniProto = Animation.prototype;
  6102.       // aniProto.sequenceNumber = 0; // native YouTube engine bug - sequenceNumber is not set
  6103.  
  6104.       const getXroto = (x) => {
  6105.         try {
  6106.           return x.__proto__;
  6107.         } catch (e) { }
  6108.         return null;
  6109.       }
  6110.       const timProto = getXroto(timeline);
  6111.       if (!timProto) return;
  6112.       if (
  6113.         (
  6114.           typeof timProto.getAnimations === 'function' && typeof timProto.play === 'function' &&
  6115.           typeof timProto._discardAnimations === 'function' && typeof timProto._play === 'function' &&
  6116.           typeof timProto._updateAnimationsPromises === 'function' && !timProto.nofCQ &&
  6117.           typeof aniProto._updatePromises === 'function' && !aniProto.nofYH
  6118.         )
  6119.  
  6120.       ) {
  6121.  
  6122.         timProto.nofCQ = 1;
  6123.         aniProto.nofYH = 1;
  6124.  
  6125.         const originalAnimationsWithPromises = ((_updateAnimationsPromises) => {
  6126.  
  6127.  
  6128.           /*
  6129.             v.animationsWithPromises = v.animationsWithPromises.filter(function (c) {
  6130.               return c._updatePromises();
  6131.             });
  6132.           */
  6133.  
  6134.           const p = Array.prototype.filter;
  6135.  
  6136.           let res = null;
  6137.           Array.prototype.filter = function () {
  6138.  
  6139.             res = this;
  6140.             return this;
  6141.  
  6142.           };
  6143.  
  6144.           _updateAnimationsPromises.call({});
  6145.  
  6146.           Array.prototype.filter = p;
  6147.  
  6148.           if (res && typeof res.length === 'number') {
  6149.             /** @type {any[]} */
  6150.             const _res = res;
  6151.             return _res;
  6152.           }
  6153.  
  6154.  
  6155.           return null;
  6156.  
  6157.  
  6158.  
  6159.  
  6160.         })(timProto._updateAnimationsPromises);
  6161.  
  6162.         if (!originalAnimationsWithPromises || typeof originalAnimationsWithPromises.length !== 'number') return;
  6163.  
  6164.         // console.log('originalAnimationsWithPromises', originalAnimationsWithPromises)
  6165.  
  6166.         aniProto._updatePromises31 = aniProto._updatePromises;
  6167.  
  6168.         /*
  6169.         aniProto._updatePromises = function(){
  6170.           console.log('eff',this._oldPlayState, this.playState)
  6171.           return this._updatePromises31.apply(this, arguments)
  6172.         }
  6173.         */
  6174.  
  6175.         aniProto._updatePromises = function () {
  6176.           var oldPlayState = this._oldPlayState;
  6177.           var newPlayState = this.playState;
  6178.           // console.log('ett', oldPlayState, newPlayState)
  6179.           if (newPlayState !== oldPlayState) {
  6180.             this._oldPlayState = newPlayState;
  6181.             if (this._readyPromise) {
  6182.               if ("idle" == newPlayState) {
  6183.                 this._rejectReadyPromise();
  6184.                 this._readyPromise = void 0;
  6185.               } else if ("pending" == oldPlayState) {
  6186.                 this._resolveReadyPromise();
  6187.               } else if ("pending" == newPlayState) {
  6188.                 this._readyPromise = void 0;
  6189.               }
  6190.             }
  6191.             if (this._finishedPromise) {
  6192.               if ("idle" == newPlayState) {
  6193.                 this._rejectFinishedPromise();
  6194.                 this._finishedPromise = void 0;
  6195.               } else if ("finished" == newPlayState) {
  6196.                 this._resolveFinishedPromise();
  6197.               } else if ("finished" == oldPlayState) {
  6198.                 this._finishedPromise = void 0;
  6199.               }
  6200.             }
  6201.           }
  6202.           return this._readyPromise || this._finishedPromise;
  6203.         };
  6204.  
  6205.  
  6206.         let restartWebAnimationsNextTickFlag = false;
  6207.  
  6208.         const looperMethodT = () => {
  6209.  
  6210.           const runnerFn = (hRes) => {
  6211.             var b = timeline;
  6212.             b.currentTime = hRes;
  6213.             b._discardAnimations();
  6214.             if (0 == b._animations.length) {
  6215.               restartWebAnimationsNextTickFlag = false;
  6216.             } else {
  6217.               getRafPromise().then(runnerFn);
  6218.             }
  6219.           }
  6220.  
  6221.           const restartWebAnimationsNextTick = () => {
  6222.             if (!restartWebAnimationsNextTickFlag) {
  6223.               restartWebAnimationsNextTickFlag = true;
  6224.               getRafPromise().then(runnerFn);
  6225.             }
  6226.           }
  6227.  
  6228.           return { restartWebAnimationsNextTick }
  6229.         };
  6230.  
  6231.  
  6232.         const looperMethodN = () => {
  6233.  
  6234.           const acs = document.createElement('a-f');
  6235.           acs.id = 'a-f';
  6236.  
  6237.           if (!document.getElementById('afscript')) {
  6238.             const style = document.createElement('style');
  6239.             style.id = 'afscript';
  6240.             style.textContent = `
  6241.               @keyFrames aF1 {
  6242.                 0% {
  6243.                   order: 0;
  6244.                 }
  6245.                 100% {
  6246.                   order: 1;
  6247.                 }
  6248.               }
  6249.               #a-f[id] {
  6250.                 visibility: collapse !important;
  6251.                 position: fixed !important;
  6252.                 display: block !important;
  6253.                 top: -100px !important;
  6254.                 left: -100px !important;
  6255.                 margin:0 !important;
  6256.                 padding:0 !important;
  6257.                 outline:0 !important;
  6258.                 border:0 !important;
  6259.                 z-index:-1 !important;
  6260.                 width: 0px !important;
  6261.                 height: 0px !important;
  6262.                 contain: strict !important;
  6263.                 pointer-events: none !important;
  6264.                 animation: 1ms steps(2, jump-none) 0ms infinite alternate forwards running aF1 !important;
  6265.               }
  6266.             `;
  6267.             (document.head || document.documentElement).appendChild(style);
  6268.           }
  6269.  
  6270.           document.documentElement.insertBefore(acs, document.documentElement.firstChild);
  6271.  
  6272.           const _onanimationiteration = function (evt) {
  6273.             const hRes = evt.timeStamp;
  6274.             var b = timeline;
  6275.             b.currentTime = hRes;
  6276.             b._discardAnimations();
  6277.             if (0 == b._animations.length) {
  6278.               restartWebAnimationsNextTickFlag = false;
  6279.               acs.onanimationiteration = null;
  6280.             } else {
  6281.               acs.onanimationiteration = _onanimationiteration;
  6282.             }
  6283.  
  6284.           }
  6285.  
  6286.  
  6287.  
  6288.           const restartWebAnimationsNextTick = () => {
  6289.             if (!restartWebAnimationsNextTickFlag) {
  6290.               restartWebAnimationsNextTickFlag = true;
  6291.               acs.onanimationiteration = _onanimationiteration;
  6292.  
  6293.             }
  6294.           }
  6295.  
  6296.           return { restartWebAnimationsNextTick }
  6297.         };
  6298.  
  6299.  
  6300.  
  6301.         const { restartWebAnimationsNextTick } = ('onanimationiteration' in document.documentElement) ? looperMethodN() : looperMethodT();
  6302.  
  6303.  
  6304.         // console.log(571, timProto);
  6305.         timProto._play = function (c) {
  6306.           c = new Animation(c, this);
  6307.           this._animations.push(c);
  6308.           restartWebAnimationsNextTick();
  6309.           c._updatePromises();
  6310.           c._animation.play();
  6311.           c._updatePromises();
  6312.           return c
  6313.         }
  6314.  
  6315.         const animationsWithPromisesMap = new Set(originalAnimationsWithPromises);
  6316.         originalAnimationsWithPromises.length = 0;
  6317.         originalAnimationsWithPromises.push = null;
  6318.         originalAnimationsWithPromises.splice = null;
  6319.         originalAnimationsWithPromises.slice = null;
  6320.         originalAnimationsWithPromises.indexOf = null;
  6321.         originalAnimationsWithPromises.unshift = null;
  6322.         originalAnimationsWithPromises.shift = null;
  6323.         originalAnimationsWithPromises.pop = null;
  6324.         originalAnimationsWithPromises.filter = null;
  6325.         originalAnimationsWithPromises.forEach = null;
  6326.         originalAnimationsWithPromises.map = null;
  6327.  
  6328.  
  6329.         const _updateAnimationsPromises = () => {
  6330.           animationsWithPromisesMap.forEach(c => {
  6331.             if (!c._updatePromises()) animationsWithPromisesMap.delete(c);
  6332.           });
  6333.           /*
  6334.           v.animationsWithPromises = v.animationsWithPromises.filter(function (c) {
  6335.             return c._updatePromises();
  6336.           });
  6337.           */
  6338.         }
  6339.  
  6340.         timProto._updateAnimationsPromises31 = timProto._updateAnimationsPromises;
  6341.  
  6342.         timProto._updateAnimationsPromises = _updateAnimationsPromises;
  6343.  
  6344.         delete timProto._updateAnimationsPromises;
  6345.         Object.defineProperty(timProto, '_updateAnimationsPromises', {
  6346.           get() {
  6347.             if (animationsWithPromisesMap.size === 0) return nilFn;
  6348.             return _updateAnimationsPromises;
  6349.           },
  6350.           set(nv) {
  6351.             delete this._updateAnimationsPromises;
  6352.             this._updateAnimationsPromises = nv;
  6353.           },
  6354.           enumerable: true,
  6355.           configurable: true,
  6356.         });
  6357.  
  6358.  
  6359.         let pdFinished = Object.getOwnPropertyDescriptor(aniProto, 'finished');
  6360.         aniProto.__finished_native_get__ = pdFinished.get;
  6361.         if (typeof pdFinished.get === 'function' && !pdFinished.set && pdFinished.configurable === true && pdFinished.enumerable === true) {
  6362.  
  6363.  
  6364.           Object.defineProperty(aniProto, 'finished', {
  6365.             get() {
  6366.               this._finishedPromise || (!animationsWithPromisesMap.has(this) && animationsWithPromisesMap.add(this),
  6367.                 this._finishedPromise = new Promise((resolve, reject) => {
  6368.                   this._resolveFinishedPromise = function () {
  6369.                     resolve(this)
  6370.                   };
  6371.                   this._rejectFinishedPromise = function () {
  6372.                     reject({
  6373.                       type: DOMException.ABORT_ERR,
  6374.                       name: "AbortError"
  6375.                     })
  6376.                   };
  6377.                 }),
  6378.                 "finished" == this.playState && this._resolveFinishedPromise());
  6379.               return this._finishedPromise
  6380.             },
  6381.             set: undefined,
  6382.             enumerable: true,
  6383.             configurable: true
  6384.           });
  6385.  
  6386.         }
  6387.  
  6388.  
  6389.  
  6390.         let pdReady = Object.getOwnPropertyDescriptor(aniProto, 'ready');
  6391.         aniProto.__ready_native_get__ = pdReady.get;
  6392.         if (typeof pdReady.get === 'function' && !pdReady.set && pdReady.configurable === true && pdReady.enumerable === true) {
  6393.  
  6394.           Object.defineProperty(aniProto, 'ready', {
  6395.             get() {
  6396.               this._readyPromise || (!animationsWithPromisesMap.has(this) && animationsWithPromisesMap.add(this),
  6397.                 this._readyPromise = new Promise((resolve, reject) => {
  6398.                   this._resolveReadyPromise = function () {
  6399.                     resolve(this)
  6400.                   };
  6401.                   this._rejectReadyPromise = function () {
  6402.                     reject({
  6403.                       type: DOMException.ABORT_ERR,
  6404.                       name: "AbortError"
  6405.                     })
  6406.                   };
  6407.                 }),
  6408.                 "pending" !== this.playState && this._resolveReadyPromise());
  6409.               return this._readyPromise
  6410.             },
  6411.             set: undefined,
  6412.             enumerable: true,
  6413.             configurable: true
  6414.           });
  6415.  
  6416.         }
  6417.  
  6418.  
  6419.         if (IGNORE_bindAnimationForCustomEffect && typeof aniProto._rebuildUnderlyingAnimation === 'function' && !aniProto._rebuildUnderlyingAnimation21 && aniProto._rebuildUnderlyingAnimation.length === 0) {
  6420.  
  6421.           aniProto._rebuildUnderlyingAnimation21 = aniProto._rebuildUnderlyingAnimation;
  6422.           const _rebuildUnderlyingAnimation = function () {
  6423.             // if (isNaN(this._sequenceNumber)) return; // do not rebuild underlying animation if native animation is used.
  6424.             this.effect && this.effect._onsample && (this.effect._onsample = null);
  6425.             return this._rebuildUnderlyingAnimation21();
  6426.           }
  6427.           aniProto._rebuildUnderlyingAnimation = _rebuildUnderlyingAnimation;
  6428.           // delete aniProto._rebuildUnderlyingAnimation;
  6429.           // Object.defineProperty(aniProto, '_rebuildUnderlyingAnimation', {
  6430.           //   get() {
  6431.           //     if (isNaN(this._sequenceNumber)) return nilFn;
  6432.           //     return this._rebuildUnderlyingAnimation21;
  6433.           //   },
  6434.           //   set(nv) {
  6435.           //     delete this._rebuildUnderlyingAnimation;
  6436.           //     this._rebuildUnderlyingAnimation = nv;
  6437.           //   },
  6438.           //   enumerable: true,
  6439.           //   configurable: true
  6440.           // });
  6441.         }
  6442.  
  6443.  
  6444.         /*
  6445.  
  6446.  
  6447.           function f(c) {
  6448.               var b = v.timeline;
  6449.               b.currentTime = c;
  6450.               b._discardAnimations();
  6451.               0 == b._animations.length ? d = !1 : requestAnimationFrame(f)
  6452.           }
  6453.           var h = window.requestAnimationFrame;
  6454.           window.requestAnimationFrame = function(c) {
  6455.               return h(function(b) {
  6456.                   v.timeline._updateAnimationsPromises();
  6457.                   c(b);
  6458.                   v.timeline._updateAnimationsPromises()
  6459.               })
  6460.           }
  6461.           ;
  6462.           v.AnimationTimeline = function() {
  6463.               this._animations = [];
  6464.               this.currentTime = void 0
  6465.           }
  6466.           ;
  6467.           v.AnimationTimeline.prototype = {
  6468.               getAnimations: function() {
  6469.                   this._discardAnimations();
  6470.                   return this._animations.slice()
  6471.               },
  6472.               _updateAnimationsPromises: function() {
  6473.                   v.animationsWithPromises = v.animationsWithPromises.filter(function(c) {
  6474.                       return c._updatePromises()
  6475.                   })
  6476.               },
  6477.               _discardAnimations: function() {
  6478.                   this._updateAnimationsPromises();
  6479.                   this._animations = this._animations.filter(function(c) {
  6480.                       return "finished" != c.playState && "idle" != c.playState
  6481.                   })
  6482.               },
  6483.               _play: function(c) {
  6484.                   c = new v.Animation(c,this);
  6485.                   this._animations.push(c);
  6486.                   v.restartWebAnimationsNextTick();
  6487.                   c._updatePromises();
  6488.                   c._animation.play();
  6489.                   c._updatePromises();
  6490.                   return c
  6491.               },
  6492.               play: function(c) {
  6493.                   c && c.remove();
  6494.                   return this._play(c)
  6495.               }
  6496.           };
  6497.           var d = !1;
  6498.           v.restartWebAnimationsNextTick = function() {
  6499.               d || (d = !0,
  6500.               requestAnimationFrame(f))
  6501.           }
  6502.           ;
  6503.           var a = new v.AnimationTimeline;
  6504.           v.timeline = a;
  6505.           try {
  6506.               Object.defineProperty(window.document, "timeline", {
  6507.                   configurable: !0,
  6508.                   get: function() {
  6509.                       return a
  6510.                   }
  6511.               })
  6512.           } catch (c) {}
  6513.           try {
  6514.               window.document.timeline = a
  6515.           } catch (c) {}
  6516.  
  6517.         */
  6518.  
  6519.  
  6520.  
  6521.         /*
  6522.  
  6523.       var g = window.getComputedStyle;
  6524.       Object.defineProperty(window, "getComputedStyle", {
  6525.           configurable: !0,
  6526.           enumerable: !0,
  6527.           value: function() {
  6528.               v.timeline._updateAnimationsPromises();
  6529.               var e = g.apply(this, arguments);
  6530.               h() && (e = g.apply(this, arguments));
  6531.               v.timeline._updateAnimationsPromises();
  6532.               return e
  6533.           }
  6534.       });
  6535.  
  6536.       */
  6537.  
  6538.  
  6539.  
  6540.  
  6541.       }
  6542.  
  6543.  
  6544.  
  6545.  
  6546.     })();
  6547.  
  6548.     !isUrlInEmbed && Promise.resolve().then(() => {
  6549.  
  6550.       // ==================================== FIX_avoid_incorrect_video_meta ====================================
  6551.  
  6552.  
  6553.  
  6554.       class LimitedSizeSet extends Set {
  6555.         constructor(n) {
  6556.           super();
  6557.           this.limit = n;
  6558.         }
  6559.  
  6560.         add(key) {
  6561.           if (!super.has(key)) {
  6562.             super.add(key);
  6563.             let n = super.size - this.limit;
  6564.             if (n > 0) {
  6565.               const iterator = super.values();
  6566.               do {
  6567.                 const firstKey = iterator.next().value; // Get the first (oldest) key
  6568.                 super.delete(firstKey); // Delete the oldest key
  6569.               } while (--n > 0)
  6570.             }
  6571.           }
  6572.         }
  6573.  
  6574.         removeAdd(key) {
  6575.           super.delete(key);
  6576.           super.add(key);
  6577.         }
  6578.  
  6579.       }
  6580.  
  6581.       // const wk3 = new WeakMap();
  6582.  
  6583.       // let mtxVideoId = '';
  6584.       // let aje3 = [];
  6585.       const mfvContinuationRecorded = new LimitedSizeSet(8);      // record all success continuation keys
  6586.       const mfyContinuationIgnored = new LimitedSizeSet(8);       // ignore continuation keys by copying the keys in the past
  6587.       let mtzlastAllowedContinuation = '';  // the key stored at the last success; clear when scheduling changes
  6588.       let mtzCount = 0;             // the key keeps unchanged
  6589.       // let mjtNextMainKey = '';
  6590.       let mjtRecordedPrevKey = ''; // the key stored at the last success (no clear)
  6591.       let mjtLockPreviousKey = ''; // the key before fetch() should be discarded. (uncertain continuation)
  6592.       let mbCId322 = 0;              // cid for delay fetchUpdatedMetadata
  6593.       // let allowNoDelay322=false;
  6594.       let mbDelayBelowNCalls = 0;   // after N calls, by pass delay; reset when scheduling changes
  6595.  
  6596.       let mpKey22 = '';           // last success continutation key & url pair
  6597.       let mpUrl22 = '';          // last success continutation key & url pair
  6598.       let mpKey21 = '';           // latest requested continutation key & url pair
  6599.       let mpUrl21 = '';         // latest requested continutation key & url pair
  6600.  
  6601.  
  6602.       async function sha1Hex(message) {
  6603.         const msgUint8 = new TextEncoder().encode(message); // encode as (utf-8) Uint8Array
  6604.         const hashBuffer = await crypto.subtle.digest("SHA-1", msgUint8); // hash the message
  6605.         const hashArray = Array.from(new Uint8Array(hashBuffer)); // convert buffer to byte array
  6606.         const hashHex = hashArray
  6607.           .map((b) => b.toString(16).padStart(2, "0"))
  6608.           .join(""); // convert bytes to hex string
  6609.         return hashHex;
  6610.       }
  6611.  
  6612.       async function continuationLog(a, ...args) {
  6613.         let b = a;
  6614.         try {
  6615.           if (advanceLogging) b = await sha1Hex(a);
  6616.           let c = args.map(e => {
  6617.             return e === a ? b : e
  6618.           });
  6619.           console.log(...c)
  6620.         } catch (e) { console.warn(e) }
  6621.       }
  6622.  
  6623.       function copyPreviousContiuationToIgnored374(toClearRecorded) {
  6624.  
  6625.  
  6626.         if (mfvContinuationRecorded.length > 0) {
  6627.           for (const [e, d] of mfvContinuationRecorded) {
  6628.             mfyContinuationIgnored.removeAdd(e);
  6629.           }
  6630.           toClearRecorded && mfvContinuationRecorded.clear();
  6631.         }
  6632.  
  6633.       }
  6634.  
  6635.       function setup_ytTaskEmitterBehavior_TaskMgr374(taskMgr) {
  6636.  
  6637.         const tmProto = taskMgr.constructor.prototype;
  6638.         if (tmProto && typeof tmProto.addJob === 'function' && tmProto.addJob.length === 3 && typeof tmProto.cancelJob === 'function' && tmProto.cancelJob.length === 1) {
  6639.  
  6640.           if (!tmProto.addJob714) {
  6641.  
  6642.             tmProto.addJob714 = tmProto.addJob;
  6643.  
  6644.             tmProto.addJob = function (a, b, c) {
  6645.               const jobId = this.addJob714(a, b, c);
  6646.               if (jobId > 0) {
  6647.                 // const ez = wk3.get(this);
  6648.                 // const dz = ez ? ez.data?.updatedMetadataEndpoint?.updatedMetadataEndpoint : null;
  6649.                 // aje3.push({mtx, jobId, a,b,c, element: this, dz, data: (ez?.data || null) })
  6650.  
  6651.                 this.__lastJobId863__ = jobId;
  6652.               }
  6653.               return jobId;
  6654.             }
  6655.  
  6656.           }
  6657.  
  6658.           if (!tmProto.cancelJob714) {
  6659.  
  6660.             tmProto.cancelJob714 = tmProto.cancelJob;
  6661.  
  6662.             tmProto.cancelJob = function (a) {
  6663.               const res = this.cancelJob714(a);
  6664.               // if (a > 0) {
  6665.               //   for (const e of aje3) {
  6666.               //     if (e.jobId === a) e.cancelled = true;
  6667.               //   }
  6668.               // }
  6669.               return res;
  6670.             }
  6671.  
  6672.           }
  6673.  
  6674.         }
  6675.       }
  6676.  
  6677.  
  6678.       const FIX_avoid_incorrect_video_meta_bool = FIX_avoid_incorrect_video_meta && isPrepareCachedV && check_for_set_key_order;
  6679.  
  6680.  
  6681.       FIX_avoid_incorrect_video_meta_bool && whenCEDefined('ytd-video-primary-info-renderer').then(() => {
  6682.         let dummy;
  6683.         let cProto;
  6684.         // let mc = 4;
  6685.         // dummy = await observablePromise(() => {
  6686.         //   const r = document.querySelector('ytd-video-primary-info-renderer');
  6687.         //   if (!r) return;
  6688.         //   let cProto = insp(r).constructor.prototype;
  6689.         //   if (cProto.fetchUpdatedMetadata) return r;
  6690.         //   if (--mc < 0) return -1;
  6691.         //   return null;
  6692.         // }).obtain();
  6693.         dummy = document.createElement('ytd-video-primary-info-renderer');
  6694.         if (!(dummy instanceof Element)) return;
  6695.         // console.log(5022, dummy)
  6696.         cProto = insp(dummy).constructor.prototype;
  6697.  
  6698.         cProto.__getEmittorTaskMgr859__ = function () {
  6699.           let taskMgr_ = null;
  6700.           try {
  6701.             taskMgr_ = (this.ytTaskEmitterBehavior || 0).getTaskManager() || null;
  6702.           } catch (e) { }
  6703.           return taskMgr_;
  6704.         }
  6705.         if (typeof cProto.fetchUpdatedMetadata === 'function' && cProto.fetchUpdatedMetadata.length === 1 && !cProto.fetchUpdatedMetadata717) {
  6706.           // console.log(1234, cProto, cProto.is)
  6707.           cProto.fetchUpdatedMetadata717 = cProto.fetchUpdatedMetadata;
  6708.  
  6709.           let c_;
  6710.           cProto.fetchUpdatedMetadata718 = function (a) {
  6711.             // delay or immediate call the actual fetchUpdatedMetadata
  6712.  
  6713.             let doImmediately = false;
  6714.             if (a && typeof a === 'string' && mjtRecordedPrevKey && mjtRecordedPrevKey === mpKey22 && a === mpKey22 && (!pageSetupVideoId || pageSetupVideoId !== mpUrl22)) {
  6715.  
  6716.               if (!pageSetupVideoId && videoPlayingY.videoId === mpUrl22) doImmediately = true;
  6717.  
  6718.             } else if (typeof a !== 'string' || mbDelayBelowNCalls > 3 || !mpKey22 || (mpKey22 === a && mpKey22 !== mjtLockPreviousKey) || (mjtLockPreviousKey && mjtLockPreviousKey !== a)) {
  6719.  
  6720.               doImmediately = true;
  6721.  
  6722.             }
  6723.  
  6724.             if (mbCId322) {
  6725.               clearTimeout(mbCId322);
  6726.               mbCId322 = 0;
  6727.             }
  6728.  
  6729.             if (doImmediately) return this.fetchUpdatedMetadata717(a);
  6730.  
  6731.             let delay = mjtLockPreviousKey === a ? 8000 : 800;
  6732.  
  6733.             mbCId322 = setTimeout(() => {
  6734.               this.fetchUpdatedMetadata717(a);
  6735.             }, delay);
  6736.  
  6737.             console.log('[yt-js-engine-tamer]', '5190 delayed fetchUpdatedMetadata', delay);
  6738.  
  6739.           }
  6740.  
  6741.           cProto.fetchUpdatedMetadata = function (a) {
  6742.  
  6743.             if (!pageSetupState) {
  6744.               if (c_) clearTimeout(c_);
  6745.               c_ = setTimeout(() => {
  6746.                 this.fetchUpdatedMetadata718(a);
  6747.               }, 300);
  6748.               return;
  6749.             }
  6750.  
  6751.             // pageSetupState == 0
  6752.  
  6753.             try {
  6754.  
  6755.               mbDelayBelowNCalls++;
  6756.  
  6757.               if (arguments.length > 1 || !(a === undefined || (typeof a === 'string' && a))) {
  6758.                 console.warn("CAUTION: fetchUpdatedMetadata coding might have to be updated.");
  6759.               }
  6760.  
  6761.               // console.log('fum377', a)
  6762.               if (typeof a === 'string' && mfyContinuationIgnored.has(a)) {
  6763.                 console.log('[yt-js-engine-tamer]', '5040 skip fetchUpdatedMetadata', a);
  6764.                 return;
  6765.               }
  6766.  
  6767.               if (!a && (this.data || 0).updatedMetadataEndpoint) {
  6768.                 if (mjtRecordedPrevKey && mjtLockPreviousKey !== mjtRecordedPrevKey) {
  6769.                   mjtLockPreviousKey = mjtRecordedPrevKey;
  6770.                   LOG_FETCHMETA_UPDATE && continuationLog(mjtLockPreviousKey, '5150 Lock Key', mjtLockPreviousKey);
  6771.                 }
  6772.                 // mjtNextMainKey = true;
  6773.                 mtzlastAllowedContinuation = '';
  6774.                 mtzCount = 0;
  6775.                 // allowNoDelay322 = false;
  6776.                 // fetch new metadata, cancel all previous continuations
  6777.                 copyPreviousContiuationToIgnored374(true);
  6778.               } else if (typeof a === 'string') {
  6779.                 const videoPlayingId = videoPlayingY.videoId;
  6780.  
  6781.                 // if(mjtNextMainKey === true) mjtNextMainKey = a;
  6782.  
  6783.                 let update21 = !!pageSetupVideoId;
  6784.                 if (mpKey22 === a && mpUrl22 === videoPlayingId && mpUrl22 && videoPlayingId && (!pageSetupVideoId || pageSetupVideoId === videoPlayingId)) {
  6785.                   update21 = true;
  6786.                 } else if (mpKey22 === a && mpUrl22 !== pageSetupVideoId) {
  6787.                   LOG_FETCHMETA_UPDATE && continuationLog(mpKey22, '5060 mpUrl22 mismatched', mpKey22, mpUrl22, pageSetupVideoId || '(null)', videoPlayingId || '(null)');
  6788.                   return;
  6789.                 }
  6790.                 if (update21) {
  6791.                   mpKey21 = a;
  6792.                   mpUrl21 = pageSetupVideoId || videoPlayingId;
  6793.                 }
  6794.  
  6795.                 if (!mfvContinuationRecorded.has(a)) mfvContinuationRecorded.add(a);
  6796.               }
  6797.               LOG_FETCHMETA_UPDATE && continuationLog(a, '5180 fetchUpdatedMetadata\t', a, pageSetupVideoId || '(null)', videoPlayingY.videoId || '(null)');
  6798.               // if (!pageSetupVideoId && typeof a === 'string' && a.length > 40) return; // ignore incorrect continuation
  6799.               // if(a === mjtNextMainKey) allowNoDelay322 = false;
  6800.               return this.fetchUpdatedMetadata718(a);
  6801.  
  6802.             } catch (e) {
  6803.               console.log('Code Error in fetchUpdatedMetadata', e);
  6804.             }
  6805.             return this.fetchUpdatedMetadata717(a)
  6806.           }
  6807.         }
  6808.  
  6809.  
  6810.         if (typeof cProto.scheduleInitialUpdatedMetadataRequest === 'function' && cProto.scheduleInitialUpdatedMetadataRequest.length === 0 && !cProto.scheduleInitialUpdatedMetadataRequest717) {
  6811.           // console.log(1234, cProto, cProto.is)
  6812.           cProto.scheduleInitialUpdatedMetadataRequest717 = cProto.scheduleInitialUpdatedMetadataRequest;
  6813.           let mJob = null;
  6814.  
  6815.           cProto.scheduleInitialUpdatedMetadataRequest = function () {
  6816.  
  6817.             try {
  6818.  
  6819.               if (arguments.length > 0) {
  6820.                 console.warn("CAUTION: scheduleInitialUpdatedMetadataRequest coding might have to be updated.");
  6821.               }
  6822.               // mfy = mfv;
  6823.  
  6824.               // mjtNextMainKey = '';
  6825.               mtzlastAllowedContinuation = '';
  6826.               mtzCount = 0;
  6827.               if (mbCId322) {
  6828.                 clearTimeout(mbCId322);
  6829.                 mbCId322 = 0;
  6830.               }
  6831.               mbDelayBelowNCalls = 0;
  6832.               // allowNoDelay322 = false;
  6833.               copyPreviousContiuationToIgnored374(true);
  6834.  
  6835.               const taskMgr = this.__getEmittorTaskMgr859__();
  6836.               if (FIX_avoid_incorrect_video_meta_emitterBehavior && taskMgr && !taskMgr.addJob714 && taskMgr.addJob && taskMgr.cancelJob) setup_ytTaskEmitterBehavior_TaskMgr374(taskMgr);
  6837.               if (FIX_avoid_incorrect_video_meta_emitterBehavior && taskMgr && !taskMgr.addJob714) {
  6838.                 console.log('[yt-js-engine-tamer]', 'scheduleInitialUpdatedMetadataRequest error 507');
  6839.               }
  6840.  
  6841.               // prevent depulicated schedule job by clearing previous JobId
  6842.               if (taskMgr && typeof taskMgr.addLowPriorityJob === 'function' && taskMgr.addLowPriorityJob.length === 2 && typeof taskMgr.cancelJob === 'function' && taskMgr.cancelJob.length === 1) {
  6843.  
  6844.                 let res;
  6845.  
  6846.                 if (mJob) {
  6847.                   const job = mJob;
  6848.                   mJob = null;
  6849.                   console.log('cancelJob', job)
  6850.                   taskMgr.cancelJob(job); // clear previous [Interval Meta Update] job
  6851.                   // p.cancelJob(a,b);
  6852.                 }
  6853.  
  6854.                 // const updatedMetadataEndpoint = this.data?.updatedMetadataEndpoint?.updatedMetadataEndpoint
  6855.  
  6856.                 let pza = taskMgr.__lastJobId863__;
  6857.                 try { res = this.scheduleInitialUpdatedMetadataRequest717(); } catch (e) { }
  6858.                 let pzb = taskMgr.__lastJobId863__
  6859.                 if (pza !== pzb) {
  6860.                   mJob = pzb; // set [Interval Meta Update] jobId
  6861.                 }
  6862.  
  6863.                 // if (updatedMetadataEndpoint && updatedMetadataEndpoint.videoId) {
  6864.                 //   mtxVideoId = updatedMetadataEndpoint.videoId || ''; // set the current target VideoId
  6865.                 // } else {
  6866.                 //   mtxVideoId = ''; // sometimes updatedMetadataEndpoint is not ready
  6867.                 // }
  6868.  
  6869.                 return res;
  6870.  
  6871.               } else {
  6872.                 console.log('[yt-js-engine-tamer]', 'scheduleInitialUpdatedMetadataRequest error 601');
  6873.               }
  6874.  
  6875.             } catch (e) {
  6876.               console.log('Code Error in scheduleInitialUpdatedMetadataRequest', e);
  6877.             }
  6878.  
  6879.  
  6880.             return this.scheduleInitialUpdatedMetadataRequest717();
  6881.           }
  6882.         }
  6883.  
  6884.  
  6885.       });
  6886.  
  6887.       FIX_avoid_incorrect_video_meta_bool && promiseForYtActionCalled.then((ytAppDom) => {
  6888.         let dummy;
  6889.         let cProto;
  6890.         dummy = ytAppDom;
  6891.         if (!(dummy instanceof Element)) return;
  6892.         cProto = insp(dummy).constructor.prototype;
  6893.         if (typeof cProto.sendServiceAjax_ === 'function' && cProto.sendServiceAjax_.length === 4 && !cProto.sendServiceAjax717_) {
  6894.           // console.log(1234, cProto, cProto.is);
  6895.           // cProto.handleServiceRequest717_ = cProto.handleServiceRequest_;
  6896.           // cProto.handleServiceRequest_ = function (a, b, c, d) {
  6897.           //   console.log(123401, arguments);
  6898.           //   return this.handleServiceRequest717_(a, b, c, d);
  6899.           // }
  6900.  
  6901.           // cProto.handleServiceRequest717_ = cProto.handleServiceRequest_;
  6902.  
  6903.           // cProto.handleServiceRequest_ = function(a,b,c,d){
  6904.           //   console.log(59901, a?.is, b?.updatedMetadataEndpoint?.videoId, c?.continuation)
  6905.           //   if(a?.is === 'ytd-video-primary-info-renderer' && b?.updatedMetadataEndpoint?.videoId && c?.continuation && typeof c?.continuation ==='string'){
  6906.           //     console.log('mfv', c.continuation);
  6907.           //     mfv.add( c.continuation);
  6908.           //   }
  6909.           //   return this.handleServiceRequest717_(a,b,c,d);
  6910.           // }
  6911.  
  6912.           function extraArguments322(a, b, c) {
  6913.             let is = (a || 0).is;
  6914.             let videoId = ((b || 0).updatedMetadataEndpoint || 0).videoId;
  6915.             let continuation = (c || 0).continuation;
  6916.             if (typeof is !== 'string') is = null;
  6917.             if (typeof videoId !== 'string') videoId = null;
  6918.             if (typeof continuation !== 'string') continuation = null;
  6919.             return { is, videoId, continuation };
  6920.           }
  6921.  
  6922.           cProto.sendServiceAjax717_ = cProto.sendServiceAjax_;
  6923.           cProto.sendServiceAjax_ = function (a, b, c, d) {
  6924.  
  6925.             // console.log(8001)
  6926.             try {
  6927.  
  6928.               const { is, videoId, continuation } = extraArguments322(a, b, c);
  6929.  
  6930.               if ((videoId || continuation) && (is !== 'ytd-video-primary-info-renderer')) {
  6931.                 console.warn("CAUTION: sendServiceAjax_ coding might have to be updated.");
  6932.               }
  6933.  
  6934.               if (pageSetupVideoId && videoId && continuation) {
  6935.                 if (mpKey21 && mpUrl21 && mpKey21 === continuation && mpUrl21 !== pageSetupVideoId) {
  6936.                   mfyContinuationIgnored.removeAdd(continuation);
  6937.                   mfvContinuationRecorded.delete(continuation);
  6938.                   return;
  6939.                 }
  6940.               }
  6941.  
  6942.               if (mjtLockPreviousKey && mjtLockPreviousKey !== continuation && continuation) {
  6943.                 copyPreviousContiuationToIgnored374(false);
  6944.                 mfyContinuationIgnored.delete(continuation);
  6945.                 mfvContinuationRecorded.removeAdd(continuation);
  6946.                 mfyContinuationIgnored.removeAdd(mjtLockPreviousKey);
  6947.                 mfvContinuationRecorded.delete(mjtLockPreviousKey);
  6948.                 mjtLockPreviousKey = '';
  6949.               }
  6950.               // if (mjtNextMainKey === continuation) {
  6951.               //   copyPreviousContiuationToIgnored(false);
  6952.               //   mfyContinuationIgnored.delete(continuation);
  6953.               //   mfvContinuationRecorded.add(continuation);
  6954.               // }
  6955.  
  6956.  
  6957.               if (mfyContinuationIgnored && continuation) {
  6958.                 if (mfyContinuationIgnored.has(continuation)) {
  6959.                   LOG_FETCHMETA_UPDATE && continuationLog(continuation, '5260 matched01', continuation)
  6960.                   return;
  6961.                 }
  6962.               }
  6963.  
  6964.               // console.log(59902, a?.is, b,c,d)
  6965.               // console.log(59903, a?.is, b?.updatedMetadataEndpoint?.videoId, c?.continuation)
  6966.               if (is === 'ytd-video-primary-info-renderer' && videoId && continuation && !mfvContinuationRecorded.has(continuation)) {
  6967.                 // console.log('mfv377', continuation);
  6968.                 mfvContinuationRecorded.add(continuation);
  6969.               }
  6970.  
  6971.               // if (videoId) {
  6972.               //   if (!pageSetupVideoId) return; // ignore page not ready
  6973.               //   // if (mtxVideoId && b.updatedMetadataEndpoint.videoId !== mtxVideoId) return; // ignore videoID not matched
  6974.               //   if (videoId !== pageSetupVideoId) {
  6975.               //     return;
  6976.               //   }
  6977.               // }
  6978.  
  6979.             } catch (e) {
  6980.               console.log('Coding Error in sendServiceAjax_', e)
  6981.             }
  6982.             // console.log(8002)
  6983.             // console.log(123402, arguments);
  6984.             // console.log(5162, 'a',a?.is,'b',b,'c',c,'d',d);
  6985.  
  6986.             // console.log(5211, b?.updatedMetadataEndpoint?.kdkw33);
  6987.             // if(b &&b.updatedMetadataEndpoint && !b.updatedMetadataEndpoint.kdkw33){
  6988.             //   b.updatedMetadataEndpoint = new Proxy(b.updatedMetadataEndpoint, {
  6989.             //     get(target, prop, receiver){
  6990.             //       console.log('xxs99', target.videoId, mtx)
  6991.             //       if(prop ==='kdkw33') return 1;
  6992.             //       console.log(3322, prop, target)
  6993.             //       if(prop === 'initialDelayMs') {
  6994.             //         throw new Error("ABCC");
  6995.             //       }
  6996.             //       return target[prop];
  6997.             //     },
  6998.             //     set(target, prop, value, receiver){
  6999.  
  7000.             //       if(prop ==='kdkw33') return true;
  7001.             //       target[prop]=value;
  7002.             //       return true;
  7003.             //     }
  7004.             //   });
  7005.             // }
  7006.             // console.log(5533, b?.updatedMetadataEndpoint?.kdkw33)
  7007.             return this.sendServiceAjax717_(a, b, c, d);
  7008.           }
  7009.         }
  7010.  
  7011.         function delayClearOtherKeys(lztContinuation) {
  7012.           // // schedule delayed removal if mfyContinuationIgnored is not empty
  7013.           // getRafPromise().then(() => {
  7014.           //   // assume the repeat continuation could be only for popstate which is triggered by user interaction
  7015.           //   // foreground page only
  7016.  
  7017.           // });
  7018.  
  7019.  
  7020.           if (lztContinuation !== mtzlastAllowedContinuation) return;
  7021.           if (lztContinuation !== mpKey21 || lztContinuation !== mpKey22) return;
  7022.           if (!mfyContinuationIgnored.size) return;
  7023.           if (mfyContinuationIgnored.size > 1) {
  7024.             LOG_FETCHMETA_UPDATE && continuationLog(lztContinuation, 'delayClearOtherKeys, current = ', lztContinuation);
  7025.           }
  7026.           mfyContinuationIgnored.forEach((value, key) => {
  7027.             if (key !== lztContinuation) {
  7028.               mfyContinuationIgnored.delete(key);
  7029.               LOG_FETCHMETA_UPDATE && continuationLog(key, 'previous continuation removed from ignored store', key);
  7030.             }
  7031.           });
  7032.  
  7033.         }
  7034.         if (typeof cProto.getCancellableNetworkPromise_ === 'function' && cProto.getCancellableNetworkPromise_.length === 5 && !cProto.getCancellableNetworkPromise717_) {
  7035.           cProto.getCancellableNetworkPromise717_ = cProto.getCancellableNetworkPromise_;
  7036.           cProto.getCancellableNetworkPromise_ = function (a, b, c, d, e) {
  7037.  
  7038.             // console.log(8003)
  7039.             try {
  7040.  
  7041.  
  7042.               const { is, videoId, continuation } = extraArguments322(b, c, d);
  7043.  
  7044.               if ((videoId || continuation) && (is !== 'ytd-video-primary-info-renderer')) {
  7045.                 console.warn("CAUTION: getCancellableNetworkPromise_ coding might have to be updated.");
  7046.               }
  7047.  
  7048.               if (pageSetupVideoId && videoId && continuation) {
  7049.                 if (mpKey21 && mpUrl21 && mpKey21 === continuation && mpUrl21 !== pageSetupVideoId) {
  7050.                   mfyContinuationIgnored.removeAdd(continuation);
  7051.                   mfvContinuationRecorded.delete(continuation);
  7052.                   return;
  7053.                 }
  7054.               }
  7055.  
  7056.               if (mjtLockPreviousKey && mjtLockPreviousKey !== continuation && continuation) {
  7057.                 copyPreviousContiuationToIgnored374(false);
  7058.                 mfyContinuationIgnored.delete(continuation);
  7059.                 mfvContinuationRecorded.removeAdd(continuation);
  7060.                 mfyContinuationIgnored.removeAdd(mjtLockPreviousKey);
  7061.                 mfvContinuationRecorded.delete(mjtLockPreviousKey);
  7062.                 mjtLockPreviousKey = '';
  7063.               }
  7064.  
  7065.               // if (mjtNextMainKey === continuation) {
  7066.               //   copyPreviousContiuationToIgnored(false);
  7067.               //   mfyContinuationIgnored.delete(continuation);
  7068.               //   mfvContinuationRecorded.add(continuation);
  7069.               // }
  7070.  
  7071.               const lztContinuation = continuation;
  7072.  
  7073.               if (mfyContinuationIgnored && lztContinuation && typeof lztContinuation === 'string') {
  7074.                 if (mfyContinuationIgnored.has(lztContinuation)) {
  7075.                   LOG_FETCHMETA_UPDATE && continuationLog(lztContinuation, '5360 matched02', lztContinuation)
  7076.                   return;
  7077.                 }
  7078.               }
  7079.  
  7080.               // if (videoId) {
  7081.               //   if (!pageSetupVideoId) return; // ignore page not ready
  7082.               //   // if (mtxVideoId && c.updatedMetadataEndpoint.videoId !== mtxVideoId) return; // ignore videoID not matched
  7083.               //   if (videoId !== pageSetupVideoId) {
  7084.               //     return;
  7085.               //   }
  7086.               // }
  7087.  
  7088.               if (typeof lztContinuation === 'string' && mtzlastAllowedContinuation !== lztContinuation) {
  7089.                 mtzlastAllowedContinuation = lztContinuation;
  7090.                 // console.log(70401, lztContinuation, mfyContinuationIgnored.size)
  7091.  
  7092.                 LOG_FETCHMETA_UPDATE && continuationLog(lztContinuation, '5382 Continuation sets to\t', lztContinuation, `C${mtzCount}.R${mfvContinuationRecorded.size}.I${mfyContinuationIgnored.size}`);
  7093.                 mjtRecordedPrevKey = lztContinuation;
  7094.                 if (mjtLockPreviousKey === lztContinuation) mjtLockPreviousKey = '';
  7095.                 // if (mfyContinuationIgnored.size > 0) {
  7096.                 //   delayClearOtherKeys(lztContinuation);
  7097.                 // }
  7098.                 mtzCount = 0;
  7099.                 // allowNoDelay322 = false;
  7100.               } else if (typeof lztContinuation === 'string' && mtzlastAllowedContinuation && mtzlastAllowedContinuation === lztContinuation) {
  7101.                 // repeated
  7102.                 if (mtzCount > 1e9) mtzCount = 1e4;
  7103.                 ++mtzCount;
  7104.                 LOG_FETCHMETA_UPDATE && continuationLog(lztContinuation, '5386 Same Continuation\t\t', lztContinuation, `C${mtzCount}.R${mfvContinuationRecorded.size}.I${mfyContinuationIgnored.size}`);
  7105.  
  7106.                 // if (mtzCount >= 3) allowNoDelay322 = true;
  7107.                 if (mtzCount >= 3 && mfyContinuationIgnored.size > 0) {
  7108.                   Promise.resolve(lztContinuation).then(delayClearOtherKeys).catch(console.warn);
  7109.                 }
  7110.                 if (mtzCount === 5) {
  7111.                   mfvContinuationRecorded.clear();
  7112.                   mfvContinuationRecorded.add(lztContinuation);
  7113.                 }
  7114.  
  7115.               }
  7116.  
  7117.               if (typeof lztContinuation === 'string' && lztContinuation && (pageSetupVideoId || videoPlayingY.videoId)) {
  7118.                 mpKey22 = lztContinuation;
  7119.                 mpUrl22 = pageSetupVideoId || videoPlayingY.videoId;
  7120.               }
  7121.  
  7122.               if (mbCId322) {
  7123.                 clearTimeout(mbCId322);
  7124.                 mbCId322 = 0;
  7125.               }
  7126.             } catch (e) {
  7127.               console.log('Coding Error in getCancellableNetworkPromise_', e)
  7128.             }
  7129.  
  7130.             // console.log(8004)
  7131.             // console.log(123403, arguments);
  7132.             // if(c.updatedMetadataEndpoint) console.log(123404, pageSetupVideoId, JSON.stringify(c.updatedMetadataEndpoint))
  7133.  
  7134.             // console.log(5163, a?.is,b,c,d,e);
  7135.             return this.getCancellableNetworkPromise717_(a, b, c, d, e);
  7136.           }
  7137.         }
  7138.       });
  7139.  
  7140.       // ==================================== FIX_avoid_incorrect_video_meta ====================================
  7141.  
  7142.  
  7143.       FIX_ytdExpander_childrenChanged && whenCEDefined('ytd-expander').then(() => {
  7144.  
  7145.         let dummy;
  7146.         let cProto;
  7147.  
  7148.         dummy = document.createElement('ytd-expander');
  7149.         cProto = insp(dummy).constructor.prototype;
  7150.  
  7151.         if (fnIntegrity(cProto.initChildrenObserver, '0.48.21') && fnIntegrity(cProto.childrenChanged, '0.40.22')) {
  7152.  
  7153.           cProto.initChildrenObserver14 = cProto.initChildrenObserver;
  7154.           cProto.childrenChanged14 = cProto.childrenChanged;
  7155.  
  7156.           cProto.initChildrenObserver = function () {
  7157.             var a = this;
  7158.             this.observer = new MutationObserver(function () {
  7159.               a.childrenChanged()
  7160.             }
  7161.             );
  7162.             this.observer.observe(this.content, {
  7163.               subtree: !0,
  7164.               childList: !0,
  7165.               attributes: !0,
  7166.               characterData: !0
  7167.             });
  7168.             this.childrenChanged()
  7169.           }
  7170.             ;
  7171.           cProto.childrenChanged = function () {
  7172.             if (this.alwaysToggleable) {
  7173.               this.canToggle = this.alwaysToggleable;
  7174.             } else if (!this.canToggleJobId) {
  7175.               this.canToggleJobId = 1;
  7176.               foregroundPromiseFn().then(() => {
  7177.                 this.canToggleJobId = 0;
  7178.                 this.calculateCanCollapse()
  7179.               })
  7180.             }
  7181.           }
  7182.  
  7183.           // console.log(cProto.initChildrenObserver)
  7184.           console.debug('ytd-expander-fix-childrenChanged');
  7185.  
  7186.         }
  7187.  
  7188.       });
  7189.  
  7190.  
  7191.       FIX_paper_ripple_animate && whenCEDefined('paper-ripple').then(() => {
  7192.  
  7193.         let dummy;
  7194.         let cProto;
  7195.         dummy = document.createElement('paper-ripple');
  7196.         cProto = insp(dummy).constructor.prototype;
  7197.  
  7198.         if (fnIntegrity(cProto.animate, '0.74.5')) {
  7199.  
  7200.  
  7201.           cProto.animate34 = cProto.animate;
  7202.           cProto.animate = function () {
  7203.             if (this._animating) {
  7204.               var a;
  7205.               const ripples = this.ripples;
  7206.               for (a = 0; a < ripples.length; ++a) {
  7207.                 var b = ripples[a];
  7208.                 b.draw();
  7209.                 this.$.background.style.opacity = b.outerOpacity;
  7210.                 b.isOpacityFullyDecayed && !b.isRestingAtMaxRadius && this.removeRipple(b)
  7211.               }
  7212.               if ((this.shouldKeepAnimating || 0) !== ripples.length) {
  7213.                 if (!this._boundAnimate38) this._boundAnimate38 = this.animate.bind(this);
  7214.                 foregroundPromiseFn().then(this._boundAnimate38);
  7215.               } else {
  7216.                 this.onAnimationComplete();
  7217.               }
  7218.             }
  7219.           }
  7220.  
  7221.           console.debug('FIX_paper_ripple_animate')
  7222.  
  7223.           // console.log(cProto.animate)
  7224.  
  7225.         }
  7226.  
  7227.       });
  7228.  
  7229.       if (FIX_doIdomRender) {
  7230.  
  7231.         const xsetTimeout = function (f, d) {
  7232.           if (xsetTimeout.m511 === 1 && !d) {
  7233.             xsetTimeout.m511 = 2;
  7234.             xsetTimeout.m568 = f;
  7235.           } else {
  7236.             return setTimeout.apply(window, arguments)
  7237.           }
  7238.  
  7239.         }
  7240.  
  7241.         /**
  7242.          * 
  7243.             IGb = function(a) {
  7244.                     var b, c = null == (b = a.requestAninmationFrameResolver) ? void 0 : b.promise;
  7245.                     c || (a.requestAninmationFrameResolver = new Vi,
  7246.                     c = a.requestAninmationFrameResolver.promise,
  7247.                     Da.requestAnimationFrame(function() {
  7248.                         var d;
  7249.                         null == (d = a.requestAninmationFrameResolver) || d.resolve();
  7250.                         a.requestAninmationFrameResolver = null
  7251.                     }));
  7252.                     return c
  7253.                 }
  7254.  
  7255.                 
  7256.          */
  7257.  
  7258.         const xrequestAnimationFrame = function (f) {
  7259.           const h = f + "";
  7260.           if (h.startsWith("function(){setTimeout(function(){") && h.endsWith("})}")) {
  7261.             let t = null;
  7262.             xsetTimeout.m511 = 1;
  7263.             f();
  7264.             if (xsetTimeout.m511 === 2) {
  7265.               t = xsetTimeout.m568;
  7266.               xsetTimeout.m568 = null;
  7267.             }
  7268.             xsetTimeout.m511 = 0;
  7269.             if (typeof t === 'function') {
  7270.               foregroundPromiseFn().then(t);
  7271.             }
  7272.           } else if (h.includes("requestAninmationFrameResolver")) {
  7273.             foregroundPromiseFn().then(f);
  7274.           } else {
  7275.             return requestAnimationFrame.apply(window, arguments);
  7276.           }
  7277.         }
  7278.  
  7279.         let busy = false;
  7280.         const doIdomRender = function () {
  7281.           if (busy) {
  7282.             return this.doIdomRender13.apply(this, arguments);
  7283.           }
  7284.           busy = true;
  7285.           const { requestAnimationFrame, setTimeout } = window;
  7286.           window.requestAnimationFrame = xrequestAnimationFrame;
  7287.           window.setTimeout = xsetTimeout;
  7288.           let r = this.doIdomRender13.apply(this, arguments);
  7289.           window.requestAnimationFrame = requestAnimationFrame;
  7290.           window.setTimeout = setTimeout;
  7291.           busy = false;
  7292.           return r;
  7293.         };
  7294.         for (const ytTag of ['ytd-lottie-player', 'yt-attributed-string', 'yt-image', 'yt-icon-shape', 'yt-button-shape', 'yt-button-view-model', 'yt-icon-badge-shape']) {
  7295.  
  7296.  
  7297.           whenCEDefined(ytTag).then(() => {
  7298.  
  7299.             let dummy;
  7300.             let cProto;
  7301.             dummy = document.createElement(ytTag);
  7302.             cProto = insp(dummy).constructor.prototype;
  7303.  
  7304.             cProto.doIdomRender13 = cProto.doIdomRender;
  7305.             cProto.doIdomRender = doIdomRender;
  7306.  
  7307.             if (cProto.doIdomRender13 === cProto.templatingFn) cProto.templatingFn = doIdomRender;
  7308.  
  7309.             console.debug('[yt-js-engine-tamer] FIX_doIdomRender', ytTag)
  7310.  
  7311.  
  7312.  
  7313.           });
  7314.  
  7315.         }
  7316.  
  7317.       }
  7318.  
  7319.  
  7320.  
  7321.     });
  7322.  
  7323.   });
  7324.  
  7325.  
  7326.  
  7327.  
  7328.   if (isMainWindow) {
  7329.  
  7330.     console.groupCollapsed(
  7331.       "%cYouTube JS Engine Tamer",
  7332.       "background-color: #EDE43B ; color: #000 ; font-weight: bold ; padding: 4px ;"
  7333.     );
  7334.  
  7335.  
  7336.  
  7337.     console.log("Script is loaded.");
  7338.     console.log("This script changes the core mechanisms of the YouTube JS engine.");
  7339.  
  7340.     console.log("This script is experimental and subject to further changes.");
  7341.  
  7342.     console.log("This might boost your YouTube performance.");
  7343.  
  7344.     console.log("CAUTION: This might break your YouTube.");
  7345.  
  7346.  
  7347.     if (prepareLogs.length >= 1) {
  7348.       console.log(" =========================================================================== ");
  7349.  
  7350.       for (const msg of prepareLogs) {
  7351.         console.log(msg)
  7352.       }
  7353.  
  7354.       console.log(" =========================================================================== ");
  7355.     }
  7356.  
  7357.     console.groupEnd();
  7358.  
  7359.   }
  7360.  
  7361.  
  7362.  
  7363. })();