☰

YouTube 超快聊天

YouTube直播聊天的终极性能提升

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

  1. // ==UserScript==
  2. // @name                YouTube Super Fast Chat
  3. // @version             0.11.0
  4. // @license             MIT
  5. // @name:ja             YouTube スーパーファーストチャット
  6. // @name:zh-TW          YouTube 超快聊天
  7. // @name:zh-CN          YouTube 超快聊天
  8. // @icon                https://github.com/cyfung1031/userscript-supports/raw/main/icons/super-fast-chat.png
  9. // @namespace           UserScript
  10. // @match               https://www.youtube.com/live_chat*
  11. // @author              CY Fung
  12. // @require             https://greasyfork.org/scripts/465819-api-for-customelements-in-youtube/code/API%20for%20CustomElements%20in%20YouTube.js?version=1215280
  13. // @run-at              document-start
  14. // @grant               none
  15. // @unwrap
  16. // @allFrames           true
  17. // @inject-into         page
  18. //
  19. // @description         Ultimate Performance Boost for YouTube Live Chats
  20. // @description:ja      YouTubeのライブチャットの究極のパフォーマンスブースト
  21. // @description:zh-TW   YouTube直播聊天的終極性能提升
  22. // @description:zh-CN   YouTube直播聊天的终极性能提升
  23. //
  24. // ==/UserScript==
  25.  
  26. ((__CONTEXT__) => {
  27.   'use strict';
  28.  
  29.   const ENABLE_REDUCED_MAXITEMS_FOR_FLUSH = true;
  30.   const MAX_ITEMS_FOR_TOTAL_DISPLAY = 90;
  31.   const MAX_ITEMS_FOR_FULL_FLUSH = 25;
  32.  
  33.   const ENABLE_NO_SMOOTH_TRANSFORM = true;
  34.   const USE_OPTIMIZED_ON_SCROLL_ITEMS = true;
  35.   const USE_WILL_CHANGE_CONTROLLER = false;
  36.   const ENABLE_FULL_RENDER_REQUIRED_PREFERRED = true;
  37.   const ENABLE_OVERFLOW_ANCHOR_PREFERRED = true;
  38.  
  39.   const FIX_SHOW_MORE_BUTTON_LOCATION = true;
  40.   const FIX_INPUT_PANEL_OVERFLOW_ISSUE = true;
  41.   const FIX_INPUT_PANEL_BORDER_ISSUE = true;
  42.   const SET_CONTAIN_FOR_CHATROOM = true;
  43.  
  44.   const FORCE_CONTENT_VISIBILITY_UNSET = true;
  45.   const FORCE_WILL_CHANGE_UNSET = true;
  46.  
  47.   const ENABLE_RAF_HACK_TICKERS = true; // when there is a ticker
  48.   const ENABLE_RAF_HACK_DOCKED_MESSAGE = true; // TBC
  49.   const ENABLE_RAF_HACK_INPUT_RENDERER = true; // TBC
  50.   const ENABLE_RAF_HACK_EMOJI_PICKER = true; // when change the page of emoji picker
  51.  
  52.   function dr(s) {
  53.     // reserved for future use
  54.     return s;
  55.     // return window.deWeakJS ? window.deWeakJS(s) : s;
  56.   }
  57.  
  58.   // necessity of cssText3_smooth_transform_position to be checked.
  59.   const cssText3_smooth_transform_position = ENABLE_NO_SMOOTH_TRANSFORM ? `
  60.  
  61.     #item-offset.style-scope.yt-live-chat-item-list-renderer > #items.style-scope.yt-live-chat-item-list-renderer {
  62.         position: static !important;
  63.     }
  64.  
  65.   `: '';
  66.  
  67.   // fallback if dummy style fn fails
  68.   const cssText4_smooth_transform_forced_props = ENABLE_NO_SMOOTH_TRANSFORM ? `
  69.  
  70.     /* optional */
  71.     #item-offset.style-scope.yt-live-chat-item-list-renderer {
  72.         height: auto !important;
  73.         min-height: unset !important;
  74.     }
  75.  
  76.     #items.style-scope.yt-live-chat-item-list-renderer {
  77.         transform: translateY(0px) !important;
  78.     }
  79.  
  80.     /* optional */
  81.  
  82.   `: '';
  83.  
  84.   const cssText5 = SET_CONTAIN_FOR_CHATROOM ? `
  85.  
  86.     /* ------------------------------------------------------------------------------------------------------------- */
  87.  
  88.     yt-live-chat-author-chip #chat-badges.yt-live-chat-author-chip, yt-live-chat-author-chip #chat-badges.yt-live-chat-author-chip yt-live-chat-author-badge-renderer, yt-live-chat-author-chip #chat-badges.yt-live-chat-author-chip yt-live-chat-author-badge-renderer #image, yt-live-chat-author-chip #chat-badges.yt-live-chat-author-chip yt-live-chat-author-badge-renderer #image img {
  89.         contain: layout style;
  90.     }
  91.  
  92.     #items.style-scope.yt-live-chat-item-list-renderer {
  93.         contain: layout paint style;
  94.     }
  95.  
  96.     #item-offset.style-scope.yt-live-chat-item-list-renderer {
  97.         contain: style;
  98.     }
  99.  
  100.     #item-scroller.style-scope.yt-live-chat-item-list-renderer {
  101.         contain: size style;
  102.     }
  103.  
  104.     #contents.style-scope.yt-live-chat-item-list-renderer, #chat.style-scope.yt-live-chat-renderer, img.style-scope.yt-img-shadow[width][height] {
  105.         contain: size layout paint style;
  106.     }
  107.  
  108.     .style-scope.yt-live-chat-ticker-renderer[role="button"][aria-label], .style-scope.yt-live-chat-ticker-renderer[role="button"][aria-label] > #container {
  109.         contain: layout paint style;
  110.     }
  111.  
  112.     yt-live-chat-text-message-renderer.style-scope.yt-live-chat-item-list-renderer, yt-live-chat-membership-item-renderer.style-scope.yt-live-chat-item-list-renderer, yt-live-chat-paid-message-renderer.style-scope.yt-live-chat-item-list-renderer, yt-live-chat-banner-manager.style-scope.yt-live-chat-item-list-renderer {
  113.         contain: layout style;
  114.     }
  115.  
  116.     tp-yt-paper-tooltip[style*="inset"][role="tooltip"] {
  117.         contain: layout paint style;
  118.     }
  119.  
  120.     /* ------------------------------------------------------------------------------------------------------------- */
  121.  
  122.   ` : '';
  123.  
  124.   const cssText6b_show_more_button = FIX_SHOW_MORE_BUTTON_LOCATION ? `
  125.  
  126.     yt-live-chat-renderer[has-action-panel-renderer] #show-more.yt-live-chat-item-list-renderer{
  127.         top: 4px;
  128.         transition-property: top;
  129.         bottom: unset;
  130.     }
  131.  
  132.     yt-live-chat-renderer[has-action-panel-renderer] #show-more.yt-live-chat-item-list-renderer[disabled]{
  133.         top: -42px;
  134.     }
  135.  
  136.   `: '';
  137.  
  138.   const cssText6c_input_panel_overflow = FIX_INPUT_PANEL_OVERFLOW_ISSUE ? `
  139.  
  140.     #input-panel #picker-buttons yt-live-chat-icon-toggle-button-renderer#product-picker {
  141.         contain: layout style;
  142.     }
  143.  
  144.     #chat.yt-live-chat-renderer ~ #panel-pages.yt-live-chat-renderer {
  145.         overflow: visible;
  146.     }
  147.  
  148.   `: '';
  149.  
  150.   const cssText6d_input_panel_border = FIX_INPUT_PANEL_BORDER_ISSUE ? `
  151.  
  152.     html #panel-pages.yt-live-chat-renderer > #input-panel.yt-live-chat-renderer:not(:empty) {
  153.         --yt-live-chat-action-panel-top-border: none;
  154.     }
  155.  
  156.     html #panel-pages.yt-live-chat-renderer > #input-panel.yt-live-chat-renderer.iron-selected > *:first-child {
  157.         border-top: 1px solid var(--yt-live-chat-panel-pages-border-color);
  158.     }
  159.  
  160.     html #panel-pages.yt-live-chat-renderer {
  161.         border-top: 0;
  162.         border-bottom: 0;
  163.     }
  164.  
  165.   `: '';
  166.  
  167.   const cssText7b_content_visibility_unset = FORCE_CONTENT_VISIBILITY_UNSET ? `
  168.  
  169.     img,
  170.     yt-img-shadow[height][width],
  171.     yt-img-shadow {
  172.         content-visibility: visible !important;
  173.     }
  174.  
  175.   `  : '';
  176.  
  177.   const cssText7c_will_change_unset = FORCE_WILL_CHANGE_UNSET ? `
  178.  
  179.     /* remove YouTube constant will-change */
  180.     /* constant value will slow down the performance; default auto */
  181.  
  182.     /* www-player.css */
  183.     html .ytp-contextmenu,
  184.     html .ytp-settings-menu {
  185.         will-change: unset;
  186.     }
  187.  
  188.     /* frequently matched elements */
  189.     html .fill.yt-interaction,
  190.     html .stroke.yt-interaction,
  191.     html .yt-spec-touch-feedback-shape__fill,
  192.     html .yt-spec-touch-feedback-shape__stroke {
  193.         will-change: unset;
  194.     }
  195.  
  196.     /* live_chat_polymer.js */
  197.     /*
  198.     html .toggle-button.tp-yt-paper-toggle-button,
  199.     html #primaryProgress.tp-yt-paper-progress,
  200.     html #secondaryProgress.tp-yt-paper-progress,
  201.     html #onRadio.tp-yt-paper-radio-button,
  202.     html .fill.yt-interaction,
  203.     html .stroke.yt-interaction,
  204.     html .yt-spec-touch-feedback-shape__fill,
  205.     html .yt-spec-touch-feedback-shape__stroke {
  206.         will-change: unset;
  207.     }
  208.     */
  209.  
  210.     /* desktop_polymer_enable_wil_icons.js */
  211.     /* html .fill.yt-interaction,
  212.     html .stroke.yt-interaction, */
  213.     html tp-yt-app-header::before,
  214.     html tp-yt-iron-list,
  215.     html #items.tp-yt-iron-list > *,
  216.     html #onRadio.tp-yt-paper-radio-button,
  217.     html .toggle-button.tp-yt-paper-toggle-button,
  218.     html ytd-thumbnail-overlay-toggle-button-renderer[use-expandable-tooltip] #label.ytd-thumbnail-overlay-toggle-button-renderer,
  219.     html #items.ytd-post-multi-image-renderer,
  220.     html #items.ytd-horizontal-card-list-renderer,
  221.     html #items.yt-horizontal-list-renderer,
  222.     html #left-arrow.yt-horizontal-list-renderer,
  223.     html #right-arrow.yt-horizontal-list-renderer,
  224.     html #items.ytd-video-description-infocards-section-renderer,
  225.     html #items.ytd-video-description-music-section-renderer,
  226.     html #chips.ytd-feed-filter-chip-bar-renderer,
  227.     html #chips.yt-chip-cloud-renderer,
  228.     html #items.ytd-merch-shelf-renderer,
  229.     html #items.ytd-product-details-image-carousel-renderer,
  230.     html ytd-video-preview,
  231.     html #player-container.ytd-video-preview,
  232.     html #primaryProgress.tp-yt-paper-progress,
  233.     html #secondaryProgress.tp-yt-paper-progress,
  234.     html ytd-miniplayer[enabled] /* ,
  235.     html .yt-spec-touch-feedback-shape__fill,
  236.     html .yt-spec-touch-feedback-shape__stroke */ {
  237.         will-change: unset;
  238.     }
  239.  
  240.     /* other */
  241.     .ytp-videowall-still-info-content[class],
  242.     .ytp-suggestion-image[class] {
  243.         will-change: unset !important;
  244.     }
  245.  
  246.   ` : '';
  247.  
  248.  
  249.   function addCssElement() {
  250.     let s = document.createElement('style');
  251.     s.id = 'ewRvC';
  252.     return s;
  253.   }
  254.  
  255.   const addCss = () => document.head.appendChild(dr(addCssElement())).textContent = `
  256.  
  257.   @supports (contain: layout paint style) {
  258.  
  259.     ${cssText5}
  260.  
  261.   }
  262.  
  263.   @supports (color: var(--general)) {
  264.  
  265.     html {
  266.         --yt-live-chat-item-list-renderer-padding: 0px 0px;
  267.     }
  268.  
  269.     ${cssText3_smooth_transform_position}
  270.  
  271.     ${cssText7c_will_change_unset}
  272.  
  273.     ${cssText7b_content_visibility_unset}
  274.  
  275.     yt-live-chat-item-list-renderer:not([allow-scroll]) #item-scroller.yt-live-chat-item-list-renderer {
  276.         overflow-y: scroll;
  277.         padding-right: 0;
  278.     }
  279.  
  280.     ${cssText4_smooth_transform_forced_props}
  281.  
  282.     yt-icon[icon="down_arrow"] > *, yt-icon-button#show-more > * {
  283.         pointer-events: none !important;
  284.     }
  285.  
  286.     #continuations, #continuations * {
  287.         contain: strict;
  288.         position: fixed;
  289.         top: 2px;
  290.         height: 1px;
  291.         width: 2px;
  292.         height: 1px;
  293.         visibility: collapse;
  294.     }
  295.  
  296.     ${cssText6b_show_more_button}
  297.  
  298.     ${cssText6d_input_panel_border}
  299.  
  300.     ${cssText6c_input_panel_overflow}
  301.  
  302.   }
  303.  
  304.  
  305.   @supports (overflow-anchor: auto) {
  306.  
  307.     .no-anchor * {
  308.         overflow-anchor: none;
  309.     }
  310.     .no-anchor > item-anchor {
  311.         overflow-anchor: auto;
  312.     }
  313.  
  314.     item-anchor {
  315.  
  316.         height:1px;
  317.         width: 100%;
  318.         transform: scaleY(0.00001);
  319.         transform-origin:0 0;
  320.         contain: strict;
  321.         opacity:0;
  322.         display:flex;
  323.         position:relative;
  324.         flex-shrink:0;
  325.         flex-grow:0;
  326.         margin-bottom:0;
  327.         overflow:hidden;
  328.         box-sizing:border-box;
  329.         visibility: visible;
  330.         content-visibility: visible;
  331.         contain-intrinsic-size: auto 1px;
  332.         pointer-events:none !important;
  333.  
  334.     }
  335.  
  336.     #item-scroller.style-scope.yt-live-chat-item-list-renderer[class] {
  337.         overflow-anchor: initial !important; /* whenever ENABLE_OVERFLOW_ANCHOR or not */
  338.     }
  339.  
  340.     html item-anchor {
  341.  
  342.         height: 1px;
  343.         width: 1px;
  344.         top: auto;
  345.         left: auto;
  346.         right: auto;
  347.         bottom: auto;
  348.         transform: translateY(-1px);
  349.         position: absolute;
  350.         z-index: -1;
  351.  
  352.     }
  353.  
  354.   }
  355.  
  356.   @supports (color: var(--pre-rendering)) {
  357.  
  358.     @keyframes dontRenderAnimation {
  359.         0% {
  360.             background-position-x: 3px;
  361.         }
  362.         100% {
  363.             background-position-x: 4px;
  364.         }
  365.     }
  366.  
  367.     /*html[dont-render-enabled] */ .dont-render{
  368.  
  369.         visibility: collapse !important;
  370.         transform: scale(0.01) !important;
  371.         transform: scale(0.00001) !important;
  372.         transform: scale(0.0000001) !important;
  373.         transform-origin: 0 0 !important;
  374.         z-index:-1 !important;
  375.         contain: strict !important;
  376.         box-sizing: border-box !important;
  377.  
  378.         height: 1px !important;
  379.         height: 0.1px !important;
  380.         height: 0.01px !important;
  381.         height: 0.0001px !important;
  382.         height: 0.000001px !important;
  383.  
  384.         animation: dontRenderAnimation 1ms linear 80ms 1 normal forwards !important;
  385.  
  386.     }
  387.  
  388.   }
  389.  
  390.   `;
  391.  
  392.  
  393.   const { IntersectionObserver } = __CONTEXT__;
  394.  
  395.   /** @type {globalThis.PromiseConstructor} */
  396.   const Promise = (async () => { })().constructor; // YouTube hacks Promise in WaterFox Classic and "Promise.resolve(0)" nevers resolve.
  397.  
  398.   if (!IntersectionObserver) return console.error("Your browser does not support IntersectionObserver.\nPlease upgrade to the latest version.")
  399.  
  400.   const assertor = (f) => f() || console.assert(false, f + "");
  401.  
  402.   const fnIntegrity = (f, d) => {
  403.     if (!f || typeof f !== 'function') {
  404.       console.warn('f is not a function', f);
  405.       return;
  406.     }
  407.     let p = f + "", s = 0, j = -1, w = 0;
  408.     for (let i = 0, l = p.length; i < l; i++) {
  409.       const t = p[i];
  410.       if (((t >= 'a' && t <= 'z') || (t >= 'A' && t <= 'Z'))) {
  411.         if (j < i - 1) w++;
  412.         j = i;
  413.       } else {
  414.         s++;
  415.       }
  416.     }
  417.     let itz = `${f.length}.${s}.${w}`;
  418.     if (!d) {
  419.       console.log(itz);
  420.       return null;
  421.     } else {
  422.       return itz === d;
  423.     }
  424.   }
  425.  
  426.  
  427.   let ENABLE_FULL_RENDER_REQUIRED_CAPABLE = false;
  428.   const isContainSupport = CSS.supports('contain', 'layout paint style');
  429.   if (!isContainSupport) {
  430.     console.warn("Your browser does not support css property 'contain'.\nPlease upgrade to the latest version.".trim());
  431.   } else {
  432.  
  433.     ENABLE_FULL_RENDER_REQUIRED_CAPABLE = true; // mainly for Chromium-based browsers
  434.  
  435.   }
  436.  
  437.  
  438.  
  439.   let ENABLE_OVERFLOW_ANCHOR_CAPABLE = false;
  440.   const isOverflowAnchorSupport = CSS.supports('overflow-anchor', 'auto');
  441.   if (!isOverflowAnchorSupport) {
  442.     console.warn("Your browser does not support css property 'overflow-anchor'.\nPlease upgrade to the latest version.".trim());
  443.   } else {
  444.  
  445.     ENABLE_OVERFLOW_ANCHOR_CAPABLE = true; // mainly for Chromium-based browsers
  446.  
  447.   }
  448.  
  449.  
  450.   const ENABLE_OVERFLOW_ANCHOR = ENABLE_OVERFLOW_ANCHOR_PREFERRED && ENABLE_OVERFLOW_ANCHOR_CAPABLE && ENABLE_NO_SMOOTH_TRANSFORM;
  451.  
  452.   const NOT_FIREFOX = !CSS.supports('-moz-appearance', 'none'); // 1. Firefox does not have the flicking issue; 2. Firefox's OVERFLOW_ANCHOR does not work very well as chromium.
  453.  
  454.   const ENABLE_FULL_RENDER_REQUIRED = ENABLE_FULL_RENDER_REQUIRED_PREFERRED && ENABLE_FULL_RENDER_REQUIRED_CAPABLE && ENABLE_OVERFLOW_ANCHOR && ENABLE_NO_SMOOTH_TRANSFORM && NOT_FIREFOX;
  455.  
  456.  
  457.  
  458.   const win = this instanceof Window ? this : window;
  459.  
  460.   // Create a unique key for the script and check if it is already running
  461.   const hkey_script = 'mchbwnoasqph';
  462.   if (win[hkey_script]) throw new Error('Duplicated Userscript Calling'); // avoid duplicated scripting
  463.   win[hkey_script] = true;
  464.  
  465.   const cleanContext = async (win) => {
  466.     const waitFn = requestAnimationFrame; // shall have been binded to window
  467.     try {
  468.       let mx = 16; // MAX TRIAL
  469.       const frameId = 'vanillajs-iframe-v1';
  470.       /** @type {HTMLIFrameElement | null} */
  471.       let frame = document.getElementById(frameId);
  472.       let removeIframeFn = null;
  473.       if (!frame) {
  474.         frame = document.createElement('iframe');
  475.         frame.id = 'vanillajs-iframe-v1';
  476.         frame.sandbox = 'allow-same-origin'; // script cannot be run inside iframe but API can be obtained from iframe
  477.         let n = document.createElement('noscript'); // wrap into NOSCRPIT to avoid reflow (layouting)
  478.         n.appendChild(frame);
  479.         while (!document.documentElement && mx-- > 0) await new Promise(waitFn); // requestAnimationFrame here could get modified by YouTube engine
  480.         const root = document.documentElement;
  481.         root.appendChild(n); // throw error if root is null due to exceeding MAX TRIAL
  482.         removeIframeFn = (setTimeout) => {
  483.           const removeIframeOnDocumentReady = (e) => {
  484.             e && win.removeEventListener("DOMContentLoaded", removeIframeOnDocumentReady, false);
  485.             win = null;
  486.             setTimeout(() => {
  487.               n.remove();
  488.               n = null;
  489.             }, 200);
  490.           }
  491.           if (document.readyState !== 'loading') {
  492.             removeIframeOnDocumentReady();
  493.           } else {
  494.             win.addEventListener("DOMContentLoaded", removeIframeOnDocumentReady, false);
  495.           }
  496.         }
  497.       }
  498.       while (!frame.contentWindow && mx-- > 0) await new Promise(waitFn);
  499.       const fc = frame.contentWindow;
  500.       if (!fc) throw "window is not found."; // throw error if root is null due to exceeding MAX TRIAL
  501.       const { requestAnimationFrame, setTimeout, cancelAnimationFrame } = fc;
  502.       const res = { requestAnimationFrame, setTimeout, cancelAnimationFrame };
  503.       for (let k in res) res[k] = res[k].bind(win); // necessary
  504.       if (removeIframeFn) Promise.resolve(res.setTimeout).then(removeIframeFn);
  505.       return res;
  506.     } catch (e) {
  507.       console.warn(e);
  508.       return null;
  509.     }
  510.   };
  511.  
  512.   cleanContext(win).then(__CONTEXT__ => {
  513.     if (!__CONTEXT__) return null;
  514.  
  515.  
  516.     const { requestAnimationFrame, setTimeout, cancelAnimationFrame } = __CONTEXT__;
  517.  
  518.  
  519.     class RAFHub {
  520.       constructor() {
  521.         /** @type {number} */
  522.         this.startAt = 8170;
  523.         /** @type {number} */
  524.         this.counter = 0;
  525.         /** @type {number} */
  526.         this.rid = 0;
  527.         /** @type {Map<number, FrameRequestCallback>} */
  528.         this.funcs = new Map();
  529.         const funcs = this.funcs;
  530.         /** @type {FrameRequestCallback} */
  531.         this.bCallback = this.mCallback.bind(this);
  532.         this.pClear = () => funcs.clear();
  533.       }
  534.       /** @param {DOMHighResTimeStamp} highResTime */
  535.       mCallback(highResTime) {
  536.         this.rid = 0;
  537.         Promise.resolve().then(this.pClear);
  538.         this.funcs.forEach(func => Promise.resolve(highResTime).then(func).catch(console.warn));
  539.       }
  540.       /** @param {FrameRequestCallback} f */
  541.       request(f) {
  542.         if (this.counter > 1e9) this.counter = 9;
  543.         let cid = this.startAt + (++this.counter);
  544.         this.funcs.set(cid, f);
  545.         if (this.rid === 0) this.rid = requestAnimationFrame(this.bCallback);
  546.         return cid;
  547.       }
  548.       /** @param {number} cid */
  549.       cancel(cid) {
  550.         cid = +cid;
  551.         if (cid > 0) {
  552.           if (cid <= this.startAt) {
  553.             return cancelAnimationFrame(cid);
  554.           }
  555.           if (this.rid > 0) {
  556.             this.funcs.delete(cid);
  557.             if (this.funcs.size === 0) {
  558.               cancelAnimationFrame(this.rid);
  559.               this.rid = 0;
  560.             }
  561.           }
  562.         }
  563.       }
  564.     }
  565.  
  566.  
  567.     ENABLE_FULL_RENDER_REQUIRED && (() => {
  568.  
  569.       document.addEventListener('animationstart', (evt) => {
  570.  
  571.         if (evt.animationName === 'dontRenderAnimation') {
  572.           evt.target.classList.remove('dont-render');
  573.           if (scrollChatFn) scrollChatFn();
  574.         }
  575.   
  576.       }, true);
  577.  
  578.       const f = (elm) => {
  579.         if (elm && elm.nodeType === 1) {
  580.           elm.classList.add('dont-render');
  581.         }
  582.       }
  583.  
  584.       Node.prototype.__appendChild931__ = function (a) {
  585.         a = dr(a);
  586.         if (this.id === 'items' && this.classList.contains('yt-live-chat-item-list-renderer')) {
  587.           if (a && a.nodeType === 1) f(a);
  588.           else if (a instanceof DocumentFragment) {
  589.             for (let n = a.firstChild; n; n = n.nextSibling) {
  590.               f(n);
  591.             }
  592.           }
  593.         }
  594.       }
  595.  
  596.       Node.prototype.__appendChild932__ = function () {
  597.         this.__appendChild931__.apply(this, arguments);
  598.         return Node.prototype.appendChild.apply(this, arguments);
  599.       }
  600.  
  601.  
  602.     })();
  603.  
  604.     // let delayedAppendParentWS = new WeakSet();
  605.     // let delayedAppendOperations = [];
  606.     // let commonAppendParentStackSet = new Set();
  607.  
  608.     // let firstVisibleItemDetected = false; // deprecated
  609.  
  610.     const sp7 = Symbol();
  611.  
  612.  
  613.     let dt0 = Date.now() - 2000;
  614.     const dateNow = () => Date.now() - dt0;
  615.     // let lastScroll = 0;
  616.     // let lastLShow = 0;
  617.     let lastWheel = 0;
  618.     let lastMouseDown = 0;
  619.     let lastMouseUp = 0;
  620.     let currentMouseDown = false;
  621.     let lastTouchDown = 0;
  622.     let lastTouchUp = 0;
  623.     let currentTouchDown = false;
  624.     let lastUserInteraction = 0;
  625.  
  626.     let scrollChatFn = null;
  627.  
  628.     const proxyHelperFn = (dummy) => ({
  629.  
  630.       get(target, prop) {
  631.         return (prop in dummy) ? dummy[prop] : prop === sp7 ? target : target[prop];
  632.       },
  633.       set(target, prop, value) {
  634.         if (!(prop in dummy)) {
  635.           target[prop] = value;
  636.         }
  637.         return true;
  638.       },
  639.       has(target, prop) {
  640.         return (prop in target);
  641.       },
  642.       deleteProperty(target, prop) {
  643.         return true;
  644.       },
  645.       ownKeys(target) {
  646.         return Object.keys(target);
  647.       },
  648.       defineProperty(target, key, descriptor) {
  649.         return Object.defineProperty(target, key, descriptor);
  650.       },
  651.       getOwnPropertyDescriptor(target, key) {
  652.         return Object.getOwnPropertyDescriptor(target, key);
  653.       },
  654.  
  655.     });
  656.  
  657.     const tickerContainerSetAttribute = function (attrName, attrValue) { // ensure '14.30000001%'.toFixed(1)
  658.  
  659.       let yd = (this.__dataHost || (this.inst || 0).__dataHost).__data;
  660.  
  661.       if (arguments.length === 2 && attrName === 'style' && yd && attrValue) {
  662.  
  663.         // let v = yd.containerStyle.privateDoNotAccessOrElseSafeStyleWrappedValue_;
  664.         let v = `${attrValue}`;
  665.         // conside a ticker is 101px width
  666.         // 1% = 1.01px
  667.         // 0.2% = 0.202px
  668.  
  669.  
  670.         const ratio1 = (yd.ratio * 100);
  671.         if (ratio1 > -1) { // avoid NaN
  672.  
  673.           // countdownDurationMs
  674.           // 600000 - 0.2%    <1% = 6s>  <0.2% = 1.2s>
  675.           // 300000 - 0.5%    <1% = 3s>  <0.5% = 1.5s>
  676.           // 150000 - 1%    <1% = 1.5s>
  677.           // 75000 - 2%    <1% =0.75s > <2% = 1.5s>
  678.           // 30000 - 5%    <1% =0.3s > <5% = 1.5s>
  679.  
  680.           // 99px * 5% = 4.95px
  681.  
  682.           // 15000 - 10%    <1% =0.15s > <10% = 1.5s>
  683.  
  684.  
  685.  
  686.  
  687.           // 1% Duration
  688.  
  689.           let ratio2 = ratio1;
  690.  
  691.           const ydd = yd.data;
  692.           const d1 = ydd.durationSec;
  693.           const d2 = ydd.fullDurationSec;
  694.  
  695.           if (d1 === d2 && d1 > 1) {
  696.  
  697.             if (d1 > 400) ratio2 = Math.round(ratio2 * 5) / 5; // 0.2%
  698.             else if (d1 > 200) ratio2 = Math.round(ratio2 * 2) / 2; // 0.5%
  699.             else if (d1 > 100) ratio2 = Math.round(ratio2 * 1) / 1; // 1%
  700.             else if (d1 > 50) ratio2 = Math.round(ratio2 * 0.5) / 0.5; // 2%
  701.             else if (d1 > 25) ratio2 = Math.round(ratio2 * 0.2) / 0.2; // 5% (max => 99px * 5% = 4.95px)
  702.             else ratio2 = Math.round(ratio2 * 0.2) / 0.2;
  703.  
  704.           } else {
  705.             ratio2 = Math.round(ratio2 * 5) / 5; // 0.2% (min)
  706.           }
  707.  
  708.           // ratio2 = Math.round(ratio2 * 5) / 5;
  709.           ratio2 = ratio2.toFixed(1);
  710.           v = v.replace(`${ratio1}%`, `${ratio2}%`).replace(`${ratio1}%`, `${ratio2}%`);
  711.  
  712.           if (yd.__style_last__ === v) return;
  713.           yd.__style_last__ = v;
  714.           // do not consider any delay here.
  715.           // it shall be inside the looping for all properties changes. all the css background ops are in the same microtask.
  716.  
  717.         }
  718.  
  719.         HTMLElement.prototype.setAttribute.call(dr(this), attrName, v);
  720.  
  721.  
  722.       } else {
  723.         HTMLElement.prototype.setAttribute.apply(dr(this), arguments);
  724.       }
  725.  
  726.     };
  727.  
  728.     const fxOperator = (proto, propertyName) => {
  729.       let propertyDescriptorGetter = null;
  730.       try {
  731.         propertyDescriptorGetter = Object.getOwnPropertyDescriptor(proto, propertyName).get;
  732.       } catch (e) { }
  733.       return typeof propertyDescriptorGetter === 'function' ? (e) => {
  734.         try {
  735.  
  736.           return propertyDescriptorGetter.call(dr(e));
  737.         } catch (e) { }
  738.         return e[propertyName];
  739.       } : (e) => e[propertyName];
  740.     };
  741.  
  742.     const nodeParent = fxOperator(Node.prototype, 'parentNode');
  743.     // const nFirstElem = fxOperator(HTMLElement.prototype, 'firstElementChild');
  744.     const nPrevElem = fxOperator(HTMLElement.prototype, 'previousElementSibling');
  745.     const nNextElem = fxOperator(HTMLElement.prototype, 'nextElementSibling');
  746.     const nLastElem = fxOperator(HTMLElement.prototype, 'lastElementChild');
  747.  
  748.  
  749.     /* globals WeakRef:false */
  750.  
  751.     /** @type {(o: Object | null) => WeakRef | null} */
  752.     const mWeakRef = typeof WeakRef === 'function' ? (o => o ? new WeakRef(o) : null) : (o => o || null); // typeof InvalidVar == 'undefined'
  753.  
  754.     /** @type {(wr: Object | null) => Object | null} */
  755.     const kRef = (wr => (wr && wr.deref) ? wr.deref() : wr);
  756.  
  757.     const watchUserCSS = () => {
  758.  
  759.       // if (!CSS.supports('contain-intrinsic-size', 'auto var(--wsr94)')) return;
  760.  
  761.       const getElemFromWR = (nr) => {
  762.         const n = kRef(nr);
  763.         if (n && n.isConnected) return n;
  764.         return null;
  765.       }
  766.  
  767.       const clearContentVisibilitySizing = () => {
  768.         Promise.resolve().then(() => {
  769.  
  770.           let btnShowMoreWR = mWeakRef(document.querySelector('#show-more[disabled]'));
  771.  
  772.           let lastVisibleItemWR = null;
  773.           for (const elm of document.querySelectorAll('[wSr93]')) {
  774.             if (elm.getAttribute('wSr93') === 'visible') lastVisibleItemWR = mWeakRef(elm);
  775.             elm.setAttribute('wSr93', '');
  776.             // custom CSS property --wsr94 not working when attribute wSr93 removed
  777.           }
  778.           requestAnimationFrame(() => {
  779.             const btnShowMore = getElemFromWR(btnShowMoreWR); btnShowMoreWR = null;
  780.             if (btnShowMore) btnShowMore.click();
  781.             else {
  782.               // would not work if switch it frequently
  783.               const lastVisibleItem = getElemFromWR(lastVisibleItemWR); lastVisibleItemWR = null;
  784.               if (lastVisibleItem) {
  785.  
  786.                 Promise.resolve()
  787.                   .then(() => lastVisibleItem.scrollIntoView())
  788.                   .then(() => lastVisibleItem.scrollIntoView(false))
  789.                   .then(() => lastVisibleItem.scrollIntoView({ behavior: "instant", block: "end", inline: "nearest" }))
  790.                   .catch(e => { }) // break the chain when method not callable
  791.  
  792.               }
  793.             }
  794.           });
  795.  
  796.         });
  797.  
  798.       }
  799.  
  800.       const mutObserver = new MutationObserver((mutations) => {
  801.         for (const mutation of mutations) {
  802.           if ((mutation.addedNodes || 0).length >= 1) {
  803.             for (const addedNode of mutation.addedNodes) {
  804.               if (addedNode.nodeName === 'STYLE') {
  805.                 clearContentVisibilitySizing();
  806.                 return;
  807.               }
  808.             }
  809.           }
  810.           if ((mutation.removedNodes || 0).length >= 1) {
  811.             for (const removedNode of mutation.removedNodes) {
  812.               if (removedNode.nodeName === 'STYLE') {
  813.                 clearContentVisibilitySizing();
  814.                 return;
  815.               }
  816.             }
  817.           }
  818.         }
  819.       });
  820.  
  821.       mutObserver.observe(document.documentElement, {
  822.         childList: true,
  823.         subtree: false
  824.       });
  825.       mutObserver.observe(document.head, {
  826.         childList: true,
  827.         subtree: false
  828.       });
  829.       mutObserver.observe(document.body, {
  830.         childList: true,
  831.         subtree: false
  832.       });
  833.  
  834.     }
  835.  
  836.     const setupStyle = (m1, m2) => {
  837.       if (!ENABLE_NO_SMOOTH_TRANSFORM) return;
  838.  
  839.       const dummy1v = {
  840.         transform: '',
  841.         height: '',
  842.         minHeight: '',
  843.         paddingBottom: '',
  844.         paddingTop: ''
  845.       };
  846.  
  847.       const dummyStyleFn = (k) => (function () { const style = this[sp7]; return style[k](...arguments); });
  848.       for (const k of ['toString', 'getPropertyPriority', 'getPropertyValue', 'item', 'removeProperty', 'setProperty']) {
  849.         dummy1v[k] = dummyStyleFn(k);
  850.       }
  851.  
  852.       const dummy1p = proxyHelperFn(dummy1v);
  853.       const sp1v = new Proxy(m1.style, dummy1p);
  854.       const sp2v = new Proxy(m2.style, dummy1p);
  855.       Object.defineProperty(m1, 'style', { get() { return sp1v }, set() { }, enumerable: true, configurable: true });
  856.       Object.defineProperty(m2, 'style', { get() { return sp2v }, set() { }, enumerable: true, configurable: true });
  857.       m1.removeAttribute("style");
  858.       m2.removeAttribute("style");
  859.  
  860.     }
  861.  
  862.  
  863.     class WillChangeController {
  864.       constructor(itemScroller, willChangeValue) {
  865.         this.element = itemScroller;
  866.         this.counter = 0;
  867.         this.active = false;
  868.         this.willChangeValue = willChangeValue;
  869.       }
  870.  
  871.       beforeOper() {
  872.         if (!this.active) {
  873.           this.active = true;
  874.           this.element.style.willChange = this.willChangeValue;
  875.         }
  876.         this.counter++;
  877.       }
  878.  
  879.       afterOper() {
  880.         const c = this.counter;
  881.         requestAnimationFrame(() => {
  882.           if (c === this.counter) {
  883.             this.active = false;
  884.             this.element.style.willChange = '';
  885.           }
  886.         });
  887.       }
  888.  
  889.       release() {
  890.         const element = this.element;
  891.         this.element = null;
  892.         this.counter = 1e16;
  893.         this.active = false;
  894.         try {
  895.           element.style.willChange = '';
  896.         } catch (e) { }
  897.       }
  898.  
  899.     }
  900.  
  901.  
  902.     const rafHub = (ENABLE_RAF_HACK_TICKERS || ENABLE_RAF_HACK_DOCKED_MESSAGE || ENABLE_RAF_HACK_INPUT_RENDERER || ENABLE_RAF_HACK_EMOJI_PICKER) ? new RAFHub() : null;
  903.  
  904.  
  905.  
  906.     const { lcRendererElm, visObserver } = (() => {
  907.  
  908.  
  909.  
  910.       let lcRendererWR = null;
  911.  
  912.       const lcRendererElm = () => {
  913.         let lcRenderer = kRef(lcRendererWR);
  914.         if (!lcRenderer || !lcRenderer.isConnected) {
  915.           lcRenderer = document.querySelector('yt-live-chat-item-list-renderer.yt-live-chat-renderer');
  916.           lcRendererWR = lcRenderer ? mWeakRef(lcRenderer) : null;
  917.         }
  918.         return lcRenderer;
  919.       };
  920.  
  921.  
  922.       let hasFirstShowMore = false;
  923.  
  924.       const visObserverFn = (entry) => {
  925.  
  926.         const target = entry.target;
  927.         if (!target) return;
  928.         // if(target.classList.contains('dont-render')) return;
  929.         let isVisible = entry.isIntersecting === true && entry.intersectionRatio > 0.5;
  930.         // const h = entry.boundingClientRect.height;
  931.         /*
  932.         if (h < 16) { // wrong: 8 (padding/margin); standard: 32; test: 16 or 20
  933.             // e.g. under fullscreen. the element created but not rendered.
  934.             target.setAttribute('wSr93', '');
  935.             return;
  936.         }
  937.         */
  938.         if (isVisible) {
  939.           // target.style.setProperty('--wsr94', h + 'px');
  940.           target.setAttribute('wSr93', 'visible');
  941.           if (nNextElem(target) === null) {
  942.  
  943.             // firstVisibleItemDetected = true;
  944.             /*
  945.               if (dateNow() - lastScroll < 80) {
  946.                   lastLShow = 0;
  947.                   lastScroll = 0;
  948.                   Promise.resolve().then(clickShowMore);
  949.               } else {
  950.                   lastLShow = dateNow();
  951.               }
  952.               */
  953.             // lastLShow = dateNow();
  954.           } else if (!hasFirstShowMore) { // should more than one item being visible
  955.             // implement inside visObserver to ensure there is sufficient delay
  956.             hasFirstShowMore = true;
  957.             requestAnimationFrame(() => {
  958.               // foreground page
  959.               // page visibly ready -> load the latest comments at initial loading
  960.               const lcRenderer = lcRendererElm();
  961.               if (lcRenderer) {
  962.                 (lcRenderer.inst || lcRenderer).scrollToBottom_();
  963.               }
  964.             });
  965.           }
  966.         }
  967.         else if (target.getAttribute('wSr93') === 'visible') { // ignore target.getAttribute('wSr93') === '' to avoid wrong sizing
  968.  
  969.           // target.style.setProperty('--wsr94', h + 'px');
  970.           target.setAttribute('wSr93', 'hidden');
  971.         } // note: might consider 0 < entry.intersectionRatio < 0.5 and target.getAttribute('wSr93') === '' <new last item>
  972.  
  973.       }
  974.  
  975.  
  976.  
  977.       const visObserver = new IntersectionObserver((entries) => {
  978.  
  979.         for (const entry of entries) {
  980.  
  981.           Promise.resolve(entry).then(visObserverFn);
  982.  
  983.         }
  984.  
  985.       }, {
  986.         // root: HTMLElement.prototype.closest.call(m2, '#item-scroller.yt-live-chat-item-list-renderer'), // nullable
  987.         rootMargin: "0px",
  988.         threshold: [0.05, 0.95],
  989.       });
  990.  
  991.  
  992.       return { lcRendererElm, visObserver }
  993.  
  994.  
  995.     })();
  996.  
  997.     const { setupMutObserver } = (() => {
  998.  
  999.       const mutFn = (items) => {
  1000.         for (let node = nLastElem(items); node !== null; node = nPrevElem(node)) {
  1001.           if (node.hasAttribute('wSr93')) break;
  1002.           node.setAttribute('wSr93', '');
  1003.           visObserver.observe(node);
  1004.         }
  1005.       }
  1006.  
  1007.       const mutObserver = new MutationObserver((mutations) => {
  1008.         const items = (mutations[0] || 0).target;
  1009.         if (!items) return;
  1010.         mutFn(items);
  1011.       });
  1012.  
  1013.       const setupMutObserver = (m2) => {
  1014.         scrollChatFn = null;
  1015.         mutObserver.disconnect();
  1016.         mutObserver.takeRecords();
  1017.         if (m2) {
  1018.           if (typeof m2.__appendChild932__ === 'function') {
  1019.             if (typeof m2.appendChild === 'function') m2.appendChild = m2.__appendChild932__;
  1020.             if (typeof m2.__shady_native_appendChild === 'function') m2.__shady_native_appendChild = m2.__appendChild932__;
  1021.           }
  1022.           mutObserver.observe(m2, {
  1023.             childList: true,
  1024.             subtree: false
  1025.           });
  1026.           mutFn(m2);
  1027.  
  1028.  
  1029.           if (ENABLE_OVERFLOW_ANCHOR) {
  1030.  
  1031.             let items = m2;
  1032.             let addedAnchor = false;
  1033.             if (items) {
  1034.               if (items.nextElementSibling === null) {
  1035.                 items.classList.add('no-anchor');
  1036.                 addedAnchor = true;
  1037.                 items.parentNode.appendChild(dr(document.createElement('item-anchor')));
  1038.               }
  1039.             }
  1040.  
  1041.  
  1042.  
  1043.             if (addedAnchor) {
  1044.               nodeParent(m2).classList.add('no-anchor'); // required
  1045.             }
  1046.  
  1047.           }
  1048.  
  1049.           // let div = document.createElement('div');
  1050.           // div.id = 'qwcc';
  1051.           // HTMLElement.prototype.appendChild.call(document.querySelector('yt-live-chat-item-list-renderer'), div )
  1052.           // bufferRegion =div;
  1053.  
  1054.           // buffObserver.takeRecords();
  1055.           // buffObserver.disconnect();
  1056.           // buffObserver.observe(div,  {
  1057.           //     childList: true,
  1058.           //     subtree: false
  1059.           // })
  1060.  
  1061.  
  1062.  
  1063.         }
  1064.       }
  1065.  
  1066.       return { setupMutObserver };
  1067.  
  1068.  
  1069.  
  1070.     })();
  1071.  
  1072.     const setupEvents = () => {
  1073.  
  1074.  
  1075.       let scrollCount = 0;
  1076.  
  1077.       const passiveCapture = typeof IntersectionObserver === 'function' ? { capture: true, passive: true } : true;
  1078.  
  1079.  
  1080.       const delayFlushActiveItemsAfterUserActionK_ = () => {
  1081.  
  1082.         const lcRenderer = lcRendererElm();
  1083.         if (lcRenderer) {
  1084.           const cnt = (lcRenderer.inst || lcRenderer);
  1085.           if (!cnt.hasUserJustInteracted11_) return;
  1086.           if (cnt.atBottom && cnt.allowScroll && cnt.activeItems_.length >= 1 && cnt.hasUserJustInteracted11_()) {
  1087.             cnt.delayFlushActiveItemsAfterUserAction11_ && cnt.delayFlushActiveItemsAfterUserAction11_();
  1088.           }
  1089.         }
  1090.  
  1091.       }
  1092.  
  1093.       document.addEventListener('scroll', (evt) => {
  1094.         if (!evt || !evt.isTrusted) return;
  1095.         // lastScroll = dateNow();
  1096.         if (++scrollCount > 1e9) scrollCount = 9;
  1097.       }, passiveCapture); // support contain => support passive
  1098.  
  1099.       let lastScrollCount = -1;
  1100.       document.addEventListener('wheel', (evt) => {
  1101.         if (!evt || !evt.isTrusted) return;
  1102.         if (lastScrollCount === scrollCount) return;
  1103.         lastScrollCount = scrollCount;
  1104.         lastWheel = dateNow();
  1105.         delayFlushActiveItemsAfterUserActionK_ && delayFlushActiveItemsAfterUserActionK_();
  1106.       }, passiveCapture); // support contain => support passive
  1107.  
  1108.       document.addEventListener('mousedown', (evt) => {
  1109.         if (!evt || !evt.isTrusted) return;
  1110.         if (((evt || 0).target || 0).id !== 'item-scroller') return;
  1111.         lastMouseDown = dateNow();
  1112.         currentMouseDown = true;
  1113.         lastUserInteraction = lastMouseDown;
  1114.       }, passiveCapture);
  1115.  
  1116.       document.addEventListener('pointerdown', (evt) => {
  1117.         if (!evt || !evt.isTrusted) return;
  1118.         if (((evt || 0).target || 0).id !== 'item-scroller') return;
  1119.         lastMouseDown = dateNow();
  1120.         currentMouseDown = true;
  1121.         lastUserInteraction = lastMouseDown;
  1122.       }, passiveCapture);
  1123.  
  1124.       document.addEventListener('click', (evt) => {
  1125.         if (!evt || !evt.isTrusted) return;
  1126.         if (((evt || 0).target || 0).id !== 'item-scroller') return;
  1127.         lastMouseDown = lastMouseUp = dateNow();
  1128.         currentMouseDown = false;
  1129.         lastUserInteraction = lastMouseDown;
  1130.         delayFlushActiveItemsAfterUserActionK_ && delayFlushActiveItemsAfterUserActionK_();
  1131.       }, passiveCapture);
  1132.  
  1133.       document.addEventListener('tap', (evt) => {
  1134.         if (!evt || !evt.isTrusted) return;
  1135.         if (((evt || 0).target || 0).id !== 'item-scroller') return;
  1136.         lastMouseDown = lastMouseUp = dateNow();
  1137.         currentMouseDown = false;
  1138.         lastUserInteraction = lastMouseDown;
  1139.         delayFlushActiveItemsAfterUserActionK_ && delayFlushActiveItemsAfterUserActionK_();
  1140.       }, passiveCapture);
  1141.  
  1142.  
  1143.       document.addEventListener('mouseup', (evt) => {
  1144.         if (!evt || !evt.isTrusted) return;
  1145.         if (currentMouseDown) {
  1146.           lastMouseUp = dateNow();
  1147.           currentMouseDown = false;
  1148.           lastUserInteraction = lastMouseUp;
  1149.           delayFlushActiveItemsAfterUserActionK_ && delayFlushActiveItemsAfterUserActionK_();
  1150.         }
  1151.       }, passiveCapture);
  1152.  
  1153.  
  1154.       document.addEventListener('pointerup', (evt) => {
  1155.         if (!evt || !evt.isTrusted) return;
  1156.         if (currentMouseDown) {
  1157.           lastMouseUp = dateNow();
  1158.           currentMouseDown = false;
  1159.           lastUserInteraction = lastMouseUp;
  1160.           delayFlushActiveItemsAfterUserActionK_ && delayFlushActiveItemsAfterUserActionK_();
  1161.         }
  1162.       }, passiveCapture);
  1163.  
  1164.       document.addEventListener('touchstart', (evt) => {
  1165.         if (!evt || !evt.isTrusted) return;
  1166.         lastTouchDown = dateNow();
  1167.         currentTouchDown = true;
  1168.         lastUserInteraction = lastTouchDown;
  1169.       }, passiveCapture);
  1170.  
  1171.       document.addEventListener('touchmove', (evt) => {
  1172.         if (!evt || !evt.isTrusted) return;
  1173.         lastTouchDown = dateNow();
  1174.         currentTouchDown = true;
  1175.         lastUserInteraction = lastTouchDown;
  1176.       }, passiveCapture);
  1177.  
  1178.       document.addEventListener('touchend', (evt) => {
  1179.         if (!evt || !evt.isTrusted) return;
  1180.         if (currentTouchDown) {
  1181.           lastTouchUp = dateNow();
  1182.           currentTouchDown = false;
  1183.           lastUserInteraction = lastTouchUp;
  1184.           delayFlushActiveItemsAfterUserActionK_ && delayFlushActiveItemsAfterUserActionK_();
  1185.         }
  1186.       }, passiveCapture);
  1187.  
  1188.       document.addEventListener('touchcancel', (evt) => {
  1189.         if (!evt || !evt.isTrusted) return;
  1190.         if (currentTouchDown) {
  1191.           lastTouchUp = dateNow();
  1192.           currentTouchDown = false;
  1193.           lastUserInteraction = lastTouchUp;
  1194.           delayFlushActiveItemsAfterUserActionK_ && delayFlushActiveItemsAfterUserActionK_();
  1195.         }
  1196.       }, passiveCapture);
  1197.  
  1198.  
  1199.     }
  1200.  
  1201.  
  1202.  
  1203.     const getProto = (element) => {
  1204.       if (element) {
  1205.         const cnt = element.inst || element;
  1206.         return cnt.constructor.prototype || null;
  1207.       }
  1208.       return null;
  1209.     }
  1210.  
  1211.  
  1212.     customYtElements.onRegistryReady(() => {
  1213.  
  1214.  
  1215.  
  1216.  
  1217.       customElements.whenDefined('yt-live-chat-item-list-renderer').then(() => {
  1218.  
  1219.  
  1220.         const tag = "yt-live-chat-item-list-renderer"
  1221.         const dummy = document.createElement(tag);
  1222.  
  1223.  
  1224.         const cProto = getProto(dummy);
  1225.         if (!cProto || !cProto.attached) {
  1226.           console.warn(`proto.attached for ${tag} is unavailable.`);
  1227.           return;
  1228.         }
  1229.  
  1230.  
  1231.  
  1232.         console.groupCollapsed("YouTube Super Fast Check - yt-live-chat-item-list-renderer hacks");
  1233.  
  1234.         const mclp = cProto;
  1235.         try {
  1236.           assertor(() => typeof mclp.scrollToBottom_ === 'function');
  1237.           assertor(() => typeof mclp.flushActiveItems_ === 'function');
  1238.           assertor(() => typeof mclp.canScrollToBottom_ === 'function');
  1239.           assertor(() => typeof mclp.setAtBottom === 'function');
  1240.           assertor(() => typeof mclp.scrollToBottom66_ === 'undefined');
  1241.           assertor(() => typeof mclp.flushActiveItems66_ === 'undefined');
  1242.         } catch (e) { }
  1243.  
  1244.  
  1245.         try {
  1246.           assertor(() => typeof mclp.attached === 'function');
  1247.           assertor(() => typeof mclp.detached === 'function');
  1248.           assertor(() => typeof mclp.canScrollToBottom_ === 'function');
  1249.           assertor(() => typeof mclp.isSmoothScrollEnabled_ === 'function');
  1250.           assertor(() => typeof mclp.maybeResizeScrollContainer_ === 'function');
  1251.           assertor(() => typeof mclp.refreshOffsetContainerHeight_ === 'function');
  1252.           assertor(() => typeof mclp.smoothScroll_ === 'function');
  1253.           assertor(() => typeof mclp.resetSmoothScroll_ === 'function');
  1254.         } catch (e) { }
  1255.  
  1256.         mclp.__intermediate_delay__ = null;
  1257.  
  1258.         let mzk = 0;
  1259.         let myk = 0;
  1260.         let mlf = 0;
  1261.         let myw = 0;
  1262.         let mzt = 0;
  1263.         let zarr = null;
  1264.         let mlg = 0;
  1265.  
  1266.         if ((mclp.clearList || 0).length === 0) {
  1267.           assertor(() => fnIntegrity(mclp.clearList, '0.106.50'));
  1268.           mclp.clearList66 = mclp.clearList;
  1269.           mclp.clearList = function () {
  1270.             mzk++;
  1271.             myk++;
  1272.             mlf++;
  1273.             myw++;
  1274.             mzt++;
  1275.             mlg++;
  1276.             zarr = null;
  1277.             this.__intermediate_delay__ = null;
  1278.             this.clearList66();
  1279.           };
  1280.           console.log("clearList", "OK");
  1281.         } else {
  1282.           console.log("clearList", "NG");
  1283.         }
  1284.  
  1285.  
  1286.         let onListRendererAttachedDone = false;
  1287.  
  1288.         function setList(itemOffset, items){
  1289.  
  1290.           const isFirstTime = onListRendererAttachedDone === false;
  1291.  
  1292.           if (isFirstTime) {
  1293.             onListRendererAttachedDone = true;
  1294.             Promise.resolve().then(watchUserCSS);
  1295.             addCss();
  1296.             setupEvents();
  1297.           }
  1298.  
  1299.           setupStyle(itemOffset, items);
  1300.  
  1301.           setupMutObserver(items);
  1302.         }
  1303.  
  1304.         mclp.attached419 = async function () {
  1305.  
  1306.           let maxTrial = 16;
  1307.           while (!this.$ || !this.$['item-scroller'] || !this.$['item-offset'] || !this.$['items']) {
  1308.             if (--maxTrial < 0) return;
  1309.             await new Promise(requestAnimationFrame);
  1310.           }
  1311.  
  1312.  
  1313.           if (!this.$) {
  1314.             console.warn("!this.$");
  1315.             return;
  1316.           }
  1317.           if (!this.$) return;
  1318.           /** @type {HTMLElement | null} */
  1319.           const itemScroller = this.$['item-scroller'];
  1320.           /** @type {HTMLElement | null} */
  1321.           const itemOffset = this.$['item-offset'];
  1322.           /** @type {HTMLElement | null} */
  1323.           const items = this.$['items'];
  1324.  
  1325.           if (!itemScroller || !itemOffset || !items) {
  1326.             console.warn("items.parentNode !== itemOffset");
  1327.             return;
  1328.           }
  1329.  
  1330.           if (nodeParent(items) !== itemOffset) {
  1331.  
  1332.             console.warn("items.parentNode !== itemOffset");
  1333.             return;
  1334.           }
  1335.  
  1336.  
  1337.           if (items.id !== 'items' || itemOffset.id !== "item-offset") {
  1338.  
  1339.             console.warn("id incorrect");
  1340.             return;
  1341.           }
  1342.  
  1343.           const isTargetItems = HTMLElement.prototype.matches.call(items, '#item-offset.style-scope.yt-live-chat-item-list-renderer > #items.style-scope.yt-live-chat-item-list-renderer')
  1344.  
  1345.           if(!isTargetItems){
  1346.             console.warn("!isTargetItems");
  1347.             return;
  1348.           }
  1349.  
  1350.           setList(itemOffset, items);
  1351.  
  1352.         }
  1353.  
  1354.         mclp.attached331 = mclp.attached;
  1355.         mclp.attached = function () {
  1356.           this.attached419 && this.attached419();
  1357.           return this.attached331();
  1358.         }
  1359.  
  1360.         mclp.detached331 = mclp.detached;
  1361.  
  1362.         mclp.detached = function () {
  1363.           setupMutObserver();
  1364.           return this.detached331();
  1365.         }
  1366.  
  1367.         let t31_items = document.querySelector('#item-offset.style-scope.yt-live-chat-item-list-renderer > #items.style-scope.yt-live-chat-item-list-renderer');
  1368.         let t31_itemOffset = t31_items ? nodeParent(t31_items) : null;
  1369.  
  1370.         if (t31_items && t31_itemOffset) {
  1371.           setList(t31_itemOffset, t31_items);
  1372.         }
  1373.  
  1374.         if ((mclp.async || 0).length === 2 && (mclp.cancelAsync || 0).length === 1) {
  1375.  
  1376.           assertor(() => fnIntegrity(mclp.async, '2.24.15'));
  1377.           assertor(() => fnIntegrity(mclp.cancelAsync, '1.15.8'));
  1378.  
  1379.           /** @type {Map<number, any>} */
  1380.           const aMap = new Map();
  1381.           let count = 6150;
  1382.           mclp.async66 = mclp.async;
  1383.           mclp.async = function (e, f) {
  1384.             // ensure the previous operation is done
  1385.             // .async is usually after the time consuming functions like flushActiveItems_ and scrollToBottom_
  1386.             const hasF = arguments.length === 2;
  1387.             const stack = new Error().stack;
  1388.             const isFlushAsync = stack.indexOf('flushActiveItems_') >= 0;
  1389.             if (count > 1e9) count = 6159;
  1390.             const resId = ++count;
  1391.             aMap.set(resId, e);
  1392.             (this.__intermediate_delay__ || Promise.resolve()).then(rk => {
  1393.               const rp = aMap.get(resId);
  1394.               if (typeof rp !== 'function') {
  1395.                 return;
  1396.               }
  1397.               let cancelCall = false;
  1398.               if (isFlushAsync) {
  1399.                 if (rk < 0) {
  1400.                   cancelCall = true;
  1401.                 } else if (rk === 2 && arguments[0] === this.maybeScrollToBottom_) {
  1402.                   cancelCall = true;
  1403.                 }
  1404.               }
  1405.               if (cancelCall) {
  1406.                 aMap.delete(resId);
  1407.               } else {
  1408.                 const asyncEn = function () {
  1409.                   aMap.delete(resId);
  1410.                   return rp.apply(this, arguments);
  1411.                 };
  1412.                 aMap.set(resId, hasF ? this.async66(asyncEn, f) : this.async66(asyncEn));
  1413.               }
  1414.             });
  1415.  
  1416.             return resId;
  1417.           }
  1418.  
  1419.           mclp.cancelAsync66 = mclp.cancelAsync66;
  1420.           mclp.cancelAsync = function (resId) {
  1421.             if (resId <= 6150) {
  1422.               this.cancelAsync66(resId);
  1423.             } else if (aMap.has(resId)) {
  1424.               const rp = aMap.get(resId);
  1425.               aMap.delete(resId);
  1426.               if (typeof rp !== 'function') {
  1427.                 this.cancelAsync66(rp);
  1428.               }
  1429.             }
  1430.           }
  1431.  
  1432.           console.log("async", "OK");
  1433.         } else {
  1434.           console.log("async", "NG");
  1435.         }
  1436.  
  1437.  
  1438.  
  1439.         if ((mclp.showNewItems_ || 0).length === 0 && ENABLE_NO_SMOOTH_TRANSFORM) {
  1440.  
  1441.           assertor(() => fnIntegrity(mclp.showNewItems_, '0.170.79'));
  1442.           mclp.showNewItems66_ = mclp.showNewItems_;
  1443.  
  1444.           mclp.showNewItems77_ = async function () {
  1445.             if (myk > 1e9) myk = 9;
  1446.             let tid = ++myk;
  1447.  
  1448.             await new Promise(requestAnimationFrame);
  1449.  
  1450.             if (tid !== myk) {
  1451.               return;
  1452.             }
  1453.  
  1454.             const cnt = this;
  1455.  
  1456.             await Promise.resolve();
  1457.             cnt.showNewItems66_();
  1458.  
  1459.             await Promise.resolve();
  1460.  
  1461.           }
  1462.  
  1463.           mclp.showNewItems_ = function () {
  1464.  
  1465.             const cnt = this;
  1466.             cnt.__intermediate_delay__ = new Promise(resolve => {
  1467.               cnt.showNewItems77_().then(() => {
  1468.                 resolve();
  1469.               });
  1470.             });
  1471.           }
  1472.  
  1473.           console.log("showNewItems_", "OK");
  1474.         } else {
  1475.           console.log("showNewItems_", "NG");
  1476.         }
  1477.  
  1478.  
  1479.  
  1480.  
  1481.         if ((mclp.flushActiveItems_ || 0).length === 0) {
  1482.  
  1483.           assertor(() => fnIntegrity(mclp.flushActiveItems_, '0.137.81'));
  1484.  
  1485.           let contensWillChangeController = null;
  1486.  
  1487.           mclp.flushActiveItems66_ = mclp.flushActiveItems_;
  1488.  
  1489.           mclp.flushActiveItems77_ = async function () {
  1490.             try {
  1491.  
  1492.               const cnt = this;
  1493.               if (mlf > 1e9) mlf = 9;
  1494.               let tid = ++mlf;
  1495.               if (tid !== mlf || cnt.isAttached === false || (cnt.hostElement || cnt).isConnected === false) return;
  1496.               if (!cnt.activeItems_ || cnt.activeItems_.length === 0) return;
  1497.  
  1498.               // 4 times to maxItems to avoid frequent trimming.
  1499.               // 1 ... 10 ... 20 ... 30 ... 40 ... 50 ... 60 => 16 ... 20 ... 30 ..... 60 ... => 16
  1500.  
  1501.               this.activeItems_.length > this.data.maxItemsToDisplay * 4 && this.data.maxItemsToDisplay > 4 && this.activeItems_.splice(0, this.activeItems_.length - this.data.maxItemsToDisplay - 1);
  1502.               if (cnt.canScrollToBottom_()) {
  1503.                 let immd = cnt.__intermediate_delay__;
  1504.                 await new Promise(requestAnimationFrame);
  1505.                 if (tid !== mlf || cnt.isAttached === false || (cnt.hostElement || cnt).isConnected === false) return;
  1506.                 if (!cnt.activeItems_ || cnt.activeItems_.length === 0) return;
  1507.  
  1508.                 mlf++;
  1509.                 if (mlg > 1e9) mlg = 9;
  1510.                 ++mlg;
  1511.  
  1512.                 const oMaxItemsToDisplay = this.data.maxItemsToDisplay;
  1513.                 const reducedMaxItemsToDisplay = MAX_ITEMS_FOR_FULL_FLUSH;
  1514.                 let changeMaxItemsToDisplay = false;
  1515.                 if (ENABLE_REDUCED_MAXITEMS_FOR_FLUSH && this.activeItems_.length > this.data.maxItemsToDisplay) {
  1516.                   if (this.data.maxItemsToDisplay > reducedMaxItemsToDisplay) {
  1517.                     // as all the rendered chats are already "outdated"
  1518.                     // all old chats shall remove and reduced number of few chats will be rendered
  1519.                     // then restore to the original number
  1520.                     changeMaxItemsToDisplay = true;
  1521.                     this.data.maxItemsToDisplay = reducedMaxItemsToDisplay;
  1522.                   }
  1523.                   this.activeItems_.splice(0, this.activeItems_.length - this.data.maxItemsToDisplay);
  1524.                   //   console.log('changeMaxItemsToDisplay 01', this.data.maxItemsToDisplay, oMaxItemsToDisplay, reducedMaxItemsToDisplay)
  1525.                 }
  1526.  
  1527.                 // it is found that it will render all stacked chats after switching back from background
  1528.                 // to avoid lagging in popular livestream with massive chats, trim first before rendering.
  1529.                 // this.activeItems_.length > this.data.maxItemsToDisplay && this.activeItems_.splice(0, this.activeItems_.length - this.data.maxItemsToDisplay);
  1530.  
  1531.  
  1532.  
  1533.                 const items = (cnt.$ || 0).items;
  1534.  
  1535.                 if (USE_WILL_CHANGE_CONTROLLER) {
  1536.                   if (contensWillChangeController && contensWillChangeController.element !== items) {
  1537.                     contensWillChangeController.release();
  1538.                     contensWillChangeController = null;
  1539.                   }
  1540.                   if (!contensWillChangeController) contensWillChangeController = new WillChangeController(items, 'contents');
  1541.                 }
  1542.                 const wcController = contensWillChangeController;
  1543.                 cnt.__intermediate_delay__ = Promise.all([cnt.__intermediate_delay__ || null, immd || null]);
  1544.                 wcController && wcController.beforeOper();
  1545.                 await Promise.resolve();
  1546.                 const len1 = cnt.activeItems_.length;
  1547.                 cnt.flushActiveItems66_();
  1548.                 const len2 = cnt.activeItems_.length;
  1549.                 let bAsync = len1 !== len2;
  1550.                 await Promise.resolve();
  1551.                 if (wcController) {
  1552.                   if (bAsync) {
  1553.                     cnt.async(() => {
  1554.                       wcController.afterOper();
  1555.                     });
  1556.                   } else {
  1557.                     wcController.afterOper();
  1558.                   }
  1559.                 }
  1560.                 if (changeMaxItemsToDisplay) {
  1561.                   if (this.data.maxItemsToDisplay === reducedMaxItemsToDisplay) {
  1562.                     this.data.maxItemsToDisplay = oMaxItemsToDisplay;
  1563.                     //   console.log('changeMaxItemsToDisplay 02', this.data.maxItemsToDisplay, oMaxItemsToDisplay, reducedMaxItemsToDisplay)
  1564.                   }
  1565.                 }
  1566.  
  1567.  
  1568.                 if (!ENABLE_NO_SMOOTH_TRANSFORM) {
  1569.  
  1570.  
  1571.                   const ff = () => {
  1572.  
  1573.                     if (cnt.isAttached === false || (cnt.hostElement || cnt).isConnected === false) return;
  1574.                     //   if (tid !== mlf || cnt.isAttached === false || (cnt.hostElement || cnt).isConnected === false) return;
  1575.                     if (!cnt.atBottom && cnt.allowScroll && cnt.hasUserJustInteracted11_ && !cnt.hasUserJustInteracted11_()) {
  1576.                       cnt.scrollToBottom_();
  1577.  
  1578.                       Promise.resolve().then(() => {
  1579.  
  1580.                         if (cnt.isAttached === false || (cnt.hostElement || cnt).isConnected === false) return;
  1581.                         if (!cnt.canScrollToBottom_()) cnt.scrollToBottom_();
  1582.                       });
  1583.  
  1584.  
  1585.                     }
  1586.                   }
  1587.  
  1588.                   ff();
  1589.  
  1590.  
  1591.                   Promise.resolve().then(ff);
  1592.  
  1593.                   // requestAnimationFrame(ff);
  1594.                 } else if (true) { // it might not be sticky to bottom when there is a full refresh.
  1595.  
  1596.                   const knt = cnt;
  1597.                   if (!scrollChatFn) {
  1598.                     const cnt = knt;
  1599.                     const f = () => {
  1600.                       const itemScroller = cnt.itemScroller;
  1601.                       if (!itemScroller || itemScroller.isConnected === false || cnt.isAttached === false) return;
  1602.                       if (!cnt.atBottom) {
  1603.                         cnt.scrollToBottom_();
  1604.                       } else if (itemScroller.scrollTop === 0) { // not yet interacted by user; cannot stick to bottom
  1605.                         itemScroller.scrollTop = itemScroller.scrollHeight;
  1606.                       }
  1607.                     };
  1608.                     scrollChatFn = () => Promise.resolve().then(f).then(f);
  1609.                   }
  1610.  
  1611.                   if (!ENABLE_FULL_RENDER_REQUIRED) scrollChatFn();
  1612.                 }
  1613.  
  1614.  
  1615.                 return 1;
  1616.               } else {
  1617.                 // cnt.flushActiveItems66_();
  1618.                 // this.activeItems_.length > this.data.maxItemsToDisplay && this.activeItems_.splice(0, this.activeItems_.length - this.data.maxItemsToDisplay);
  1619.                 return 2;
  1620.               }
  1621.             } catch (e) {
  1622.               console.warn(e);
  1623.             }
  1624.           }
  1625.  
  1626.           mclp.flushActiveItems_ = function () {
  1627.             const cnt = this;
  1628.  
  1629.             if (arguments.length !== 0 || !cnt.activeItems_ || !cnt.canScrollToBottom_) return cnt.flushActiveItems66_.apply(this, arguments);
  1630.  
  1631.             if (cnt.activeItems_.length === 0) {
  1632.               cnt.__intermediate_delay__ = null;
  1633.               return;
  1634.             }
  1635.  
  1636.             const cntData = ((cnt || 0).data || 0);
  1637.             if (cntData.maxItemsToDisplay > MAX_ITEMS_FOR_TOTAL_DISPLAY) cntData.maxItemsToDisplay = MAX_ITEMS_FOR_TOTAL_DISPLAY;
  1638.  
  1639.             // ignore previous __intermediate_delay__ and create a new one
  1640.             cnt.__intermediate_delay__ = new Promise(resolve => {
  1641.               cnt.flushActiveItems77_().then(rt => {
  1642.                 if (rt === 1) resolve(1); // success, scroll to bottom
  1643.                 else if (rt === 2) resolve(2); // success, trim
  1644.                 else resolve(-1); // skip
  1645.               });
  1646.             });
  1647.  
  1648.           }
  1649.           console.log("flushActiveItems_", "OK");
  1650.         } else {
  1651.           console.log("flushActiveItems_", "NG");
  1652.         }
  1653.  
  1654.         mclp.delayFlushActiveItemsAfterUserAction11_ = async function () {
  1655.           try {
  1656.             if (mlg > 1e9) mlg = 9;
  1657.             const tid = ++mlg;
  1658.             const keepTrialCond = () => this.atBottom && this.allowScroll && (tid === mlg) && this.isAttached === true && this.activeItems_.length >= 1 && (this.hostElement || 0).isConnected === true;
  1659.             const runCond = () => this.canScrollToBottom_();
  1660.             if (!keepTrialCond()) return;
  1661.             if (runCond()) return this.flushActiveItems_() | 1; // avoid return promise
  1662.             await new Promise(r => setTimeout(r, 80));
  1663.             if (!keepTrialCond()) return;
  1664.             if (runCond()) return this.flushActiveItems_() | 1;
  1665.             await new Promise(requestAnimationFrame);
  1666.             if (runCond()) return this.flushActiveItems_() | 1;
  1667.           } catch (e) {
  1668.             console.warn(e);
  1669.           }
  1670.         }
  1671.  
  1672.         if ((mclp.atBottomChanged_ || 0).length === 1) {
  1673.           // note: if the scrolling is too frequent, the show more visibility might get wrong.
  1674.           assertor(() => fnIntegrity(mclp.atBottomChanged_, '1.75.39'));
  1675.  
  1676.           const querySelector = HTMLElement.prototype.querySelector;
  1677.           const U = (element) => ({
  1678.             querySelector: (selector) => querySelector.call(element, selector)
  1679.           });
  1680.  
  1681.           let qid = 0;
  1682.           mclp.atBottomChanged_ = function (a) {
  1683.             let tid = ++qid;
  1684.             var b = this;
  1685.             a ? this.hideShowMoreAsync_ || (this.hideShowMoreAsync_ = this.async(function () {
  1686.               if (tid !== qid) return;
  1687.               U(b.hostElement).querySelector("#show-more").style.visibility = "hidden"
  1688.             }, 200)) : (this.hideShowMoreAsync_ && this.cancelAsync(this.hideShowMoreAsync_),
  1689.               this.hideShowMoreAsync_ = null,
  1690.               U(this.hostElement).querySelector("#show-more").style.visibility = "visible")
  1691.           }
  1692.  
  1693.           console.log("atBottomChanged_", "OK");
  1694.         } else {
  1695.           console.log("atBottomChanged_", "NG");
  1696.         }
  1697.  
  1698.         if ((mclp.onScrollItems_ || 0).length === 1) {
  1699.  
  1700.           assertor(() => fnIntegrity(mclp.onScrollItems_, '1.17.9'));
  1701.           mclp.onScrollItems66_ = mclp.onScrollItems_;
  1702.           mclp.onScrollItems77_ = async function (evt) {
  1703.             if (myw > 1e9) myw = 9;
  1704.             let tid = ++myw;
  1705.  
  1706.             await new Promise(requestAnimationFrame);
  1707.  
  1708.             if (tid !== myw) {
  1709.               return;
  1710.             }
  1711.  
  1712.             const cnt = this;
  1713.  
  1714.             await Promise.resolve();
  1715.             if (USE_OPTIMIZED_ON_SCROLL_ITEMS) {
  1716.               await Promise.resolve().then(() => {
  1717.                 this.ytRendererBehavior.onScroll(evt);
  1718.               }).then(() => {
  1719.                 if (this.canScrollToBottom_()) {
  1720.                   const hasUserJustInteracted = this.hasUserJustInteracted11_ ? this.hasUserJustInteracted11_() : true;
  1721.                   if (hasUserJustInteracted) {
  1722.                     // only when there is an user action
  1723.                     this.setAtBottom();
  1724.                     return 1;
  1725.                   }
  1726.                 } else {
  1727.                   // no message inserting
  1728.                   this.setAtBottom();
  1729.                   return 1;
  1730.                 }
  1731.               }).then((r) => {
  1732.  
  1733.                 if (this.activeItems_.length) {
  1734.  
  1735.                   if (this.canScrollToBottom_()) {
  1736.                     this.flushActiveItems_();
  1737.                     return 1 && r;
  1738.                   } else if (this.atBottom && this.allowScroll && (this.hasUserJustInteracted11_ && this.hasUserJustInteracted11_())) {
  1739.                     // delayed due to user action
  1740.                     this.delayFlushActiveItemsAfterUserAction11_ && this.delayFlushActiveItemsAfterUserAction11_();
  1741.                     return 0;
  1742.                   }
  1743.                 }
  1744.               }).then((r) => {
  1745.                 if (r) {
  1746.                   // ensure setAtBottom is correctly set
  1747.                   this.setAtBottom();
  1748.                 }
  1749.               });
  1750.             } else {
  1751.               cnt.onScrollItems66_(evt);
  1752.             }
  1753.  
  1754.             await Promise.resolve();
  1755.  
  1756.           }
  1757.  
  1758.           mclp.onScrollItems_ = function (evt) {
  1759.  
  1760.             const cnt = this;
  1761.             cnt.__intermediate_delay__ = new Promise(resolve => {
  1762.               cnt.onScrollItems77_(evt).then(() => {
  1763.                 resolve();
  1764.               });
  1765.             });
  1766.           }
  1767.           console.log("onScrollItems_", "OK");
  1768.         } else {
  1769.           console.log("onScrollItems_", "NG");
  1770.         }
  1771.  
  1772.         if ((mclp.handleLiveChatActions_ || 0).length === 1) {
  1773.  
  1774.           assertor(() => fnIntegrity(mclp.handleLiveChatActions_, '1.31.17'));
  1775.           mclp.handleLiveChatActions66_ = mclp.handleLiveChatActions_;
  1776.  
  1777.           mclp.handleLiveChatActions77_ = async function (arr) {
  1778.             if (typeof (arr || 0).length !== 'number') {
  1779.               this.handleLiveChatActions66_(arr);
  1780.               return;
  1781.             }
  1782.             if (mzt > 1e9) mzt = 9;
  1783.             let tid = ++mzt;
  1784.  
  1785.             if (zarr === null) zarr = arr;
  1786.             else Array.prototype.push.apply(zarr, arr);
  1787.             arr = null;
  1788.  
  1789.             await new Promise(requestAnimationFrame);
  1790.  
  1791.             if (tid !== mzt || zarr === null) {
  1792.               return;
  1793.             }
  1794.  
  1795.             const carr = zarr;
  1796.             zarr = null;
  1797.  
  1798.             await Promise.resolve();
  1799.             this.handleLiveChatActions66_(carr);
  1800.             await Promise.resolve();
  1801.  
  1802.           }
  1803.  
  1804.           mclp.handleLiveChatActions_ = function (arr) {
  1805.  
  1806.             const cnt = this;
  1807.             cnt.__intermediate_delay__ = new Promise(resolve => {
  1808.               cnt.handleLiveChatActions77_(arr).then(() => {
  1809.                 resolve();
  1810.               });
  1811.             });
  1812.           }
  1813.           console.log("handleLiveChatActions_", "OK");
  1814.         } else {
  1815.           console.log("handleLiveChatActions_", "NG");
  1816.         }
  1817.  
  1818.         mclp.hasUserJustInteracted11_ = () => {
  1819.           const t = dateNow();
  1820.           return (t - lastWheel < 80) || currentMouseDown || currentTouchDown || (t - lastUserInteraction < 80);
  1821.         }
  1822.  
  1823.         if ((mclp.canScrollToBottom_ || 0).length === 0) {
  1824.  
  1825.           assertor(() => fnIntegrity(mclp.canScrollToBottom_, '0.9.5'));
  1826.  
  1827.           mclp.canScrollToBottom_ = function () {
  1828.             return this.atBottom && this.allowScroll && !this.hasUserJustInteracted11_();
  1829.           }
  1830.  
  1831.           console.log("canScrollToBottom_", "OK");
  1832.         } else {
  1833.           console.log("canScrollToBottom_", "NG");
  1834.         }
  1835.  
  1836.         if (ENABLE_NO_SMOOTH_TRANSFORM) {
  1837.  
  1838.           mclp.isSmoothScrollEnabled_ = function () {
  1839.             return false;
  1840.           }
  1841.  
  1842.           mclp.maybeResizeScrollContainer_ = function () {
  1843.             //
  1844.           }
  1845.  
  1846.           mclp.refreshOffsetContainerHeight_ = function () {
  1847.             //
  1848.           }
  1849.  
  1850.           mclp.smoothScroll_ = function () {
  1851.             //
  1852.           }
  1853.  
  1854.           mclp.resetSmoothScroll_ = function () {
  1855.             //
  1856.           }
  1857.           console.log("ENABLE_NO_SMOOTH_TRANSFORM", "OK");
  1858.         } else {
  1859.           console.log("ENABLE_NO_SMOOTH_TRANSFORM", "NG");
  1860.         }
  1861.  
  1862.         console.groupEnd();
  1863.  
  1864.       });
  1865.  
  1866.  
  1867.  
  1868.  
  1869.  
  1870.  
  1871.       const fp = (renderer) => {
  1872.         const cnt = renderer.inst || renderer;
  1873.         assertor(() => typeof (cnt || 0).is === 'string');
  1874.         assertor(() => ((cnt || 0).hostElement || 0).nodeType === 1);
  1875.         const container = (cnt.$ || 0).container;
  1876.         if (container) {
  1877.           assertor(() => (container || 0).nodeType === 1);
  1878.           assertor(() => typeof container.setAttribute === 'function');
  1879.           container.setAttribute = tickerContainerSetAttribute;
  1880.         } else {
  1881.           console.warn(`"container" does not exist in ${cnt.is}`);
  1882.         }
  1883.       };
  1884.  
  1885.       const tags = ["yt-live-chat-ticker-paid-message-item-renderer", "yt-live-chat-ticker-paid-sticker-item-renderer",
  1886.         "yt-live-chat-ticker-renderer", "yt-live-chat-ticker-sponsor-item-renderer"];
  1887.  
  1888.  
  1889.       Promise.all(tags.map(tag => customElements.whenDefined(tag))).then(() => {
  1890.  
  1891.         console.groupCollapsed("YouTube Super Fast Check - yt-live-chat-ticker-... hacks");
  1892.         console.log("[Begin]");
  1893.  
  1894.         for (const tag of tags) {
  1895.           const dummy = document.createElement(tag);
  1896.  
  1897.           const cProto = getProto(dummy);
  1898.           if (!cProto || !cProto.attached) {
  1899.             console.warn(`proto.attached for ${tag} is unavailable.`);
  1900.             continue;
  1901.           }
  1902.  
  1903.           cProto.attached77 = cProto.attached;
  1904.  
  1905.           cProto.attached = function () {
  1906.             fp(this.hostElement || this);
  1907.             return this.attached77();
  1908.           }
  1909.  
  1910.           for (const elm of document.getElementsByTagName(tag)) {
  1911.             fp(elm);
  1912.           }
  1913.  
  1914.           if (ENABLE_RAF_HACK_TICKERS && rafHub !== null) {
  1915.  
  1916.             // cancelable - this.rafId < isAnimationPausedChanged >
  1917.  
  1918.             let doHack = false;
  1919.  
  1920.             if (typeof cProto.startCountdown === 'function' && typeof cProto.updateTimeout === 'function' && typeof cProto.isAnimationPausedChanged === 'function') {
  1921.  
  1922.               console.log('startCountdown', typeof cProto.startCountdown)
  1923.               console.log('updateTimeout', typeof cProto.updateTimeout)
  1924.               console.log('isAnimationPausedChanged', typeof cProto.isAnimationPausedChanged)
  1925.  
  1926.               doHack = fnIntegrity(cProto.startCountdown, '2.66.37') && fnIntegrity(cProto.updateTimeout, '1.76.45') && fnIntegrity(cProto.isAnimationPausedChanged, '2.56.30')
  1927.  
  1928.             }
  1929.             if (doHack) {
  1930.  
  1931.               cProto.startCountdown = function (a, b) {
  1932.                 // console.log('cProto.startCountdown', tag) // yt-live-chat-ticker-sponsor-item-renderer
  1933.                 if (!this.boundUpdateTimeout37_) this.boundUpdateTimeout37_ = this.updateTimeout.bind(this);
  1934.                 b = void 0 === b ? 0 : b;
  1935.                 void 0 !== a && (this.countdownMs = 1E3 * a,
  1936.                   this.countdownDurationMs = b ? 1E3 * b : this.countdownMs,
  1937.                   this.ratio = 1,
  1938.                   this.lastCountdownTimeMs || this.isAnimationPaused || (this.lastCountdownTimeMs = performance.now(),
  1939.                     this.rafId = rafHub.request(this.boundUpdateTimeout37_)))
  1940.               };
  1941.  
  1942.               cProto.updateTimeout = function (a) {
  1943.                 // console.log('cProto.updateTimeout', tag) // yt-live-chat-ticker-sponsor-item-renderer
  1944.                 if (!this.boundUpdateTimeout37_) this.boundUpdateTimeout37_ = this.updateTimeout.bind(this);
  1945.                 this.countdownMs = Math.max(0, this.countdownMs - (a - (this.lastCountdownTimeMs || 0)));
  1946.                 this.ratio = this.countdownMs / this.countdownDurationMs;
  1947.                 this.isAttached && this.countdownMs ? (this.lastCountdownTimeMs = a,
  1948.                   this.rafId = rafHub.request(this.boundUpdateTimeout37_)) : (this.lastCountdownTimeMs = null,
  1949.                     this.isAttached && ("auto" === this.hostElement.style.width && this.setContainerWidth(),
  1950.                       this.slideDown()))
  1951.               };
  1952.  
  1953.               cProto.isAnimationPausedChanged = function (a, b) {
  1954.                 if (!this.boundUpdateTimeout37_) this.boundUpdateTimeout37_ = this.updateTimeout.bind(this);
  1955.                 a ? rafHub.cancel(this.rafId) : !a && b && (a = this.lastCountdownTimeMs || 0,
  1956.                   this.detlaSincePausedSecs && (a = (this.lastCountdownTimeMs || 0) + 1E3 * this.detlaSincePausedSecs,
  1957.                     this.detlaSincePausedSecs = 0),
  1958.                   this.boundUpdateTimeout37_(a),
  1959.                   this.lastCountdownTimeMs = window.performance.now())
  1960.               };
  1961.  
  1962.               console.log('RAF_HACK_TICKERS', tag, "OK")
  1963.             } else {
  1964.  
  1965.               console.log('RAF_HACK_TICKERS', tag, "NG")
  1966.             }
  1967.  
  1968.           }
  1969.  
  1970.         }
  1971.         console.log("[End]");
  1972.         console.groupEnd();
  1973.  
  1974.  
  1975.       })
  1976.  
  1977.  
  1978.  
  1979.       if (ENABLE_RAF_HACK_INPUT_RENDERER && rafHub !== null) {
  1980.  
  1981.  
  1982.         customElements.whenDefined("yt-live-chat-message-input-renderer").then(() => {
  1983.  
  1984.  
  1985.           console.groupCollapsed("YouTube Super Fast Check - yt-live-chat-message-input-renderer hacks");
  1986.           console.log("[Begin]");
  1987.           (() => {
  1988.  
  1989.             const tag = "yt-live-chat-message-input-renderer"
  1990.             const dummy = document.createElement(tag);
  1991.  
  1992.             const cProto = getProto(dummy);
  1993.             if (!cProto || !cProto.attached) {
  1994.               console.warn(`proto.attached for ${tag} is unavailable.`);
  1995.               return;
  1996.             }
  1997.  
  1998.             let doHack = false;
  1999.             if (typeof cProto.handleTimeout === 'function' && typeof cProto.updateTimeout === 'function') {
  2000.  
  2001.               // not cancellable
  2002.               console.log('handleTimeout', typeof cProto.handleTimeout)
  2003.               console.log('updateTimeout', typeof cProto.updateTimeout)
  2004.  
  2005.               doHack = fnIntegrity(cProto.handleTimeout, '1.27.16') && fnIntegrity(cProto.updateTimeout, '1.50.33');
  2006.  
  2007.             }
  2008.  
  2009.             if (doHack) {
  2010.  
  2011.               cProto.handleTimeout = function (a) {
  2012.                 console.log('cProto.handleTimeout', tag)
  2013.                 if (!this.boundUpdateTimeout38_) this.boundUpdateTimeout38_ = this.updateTimeout.bind(this);
  2014.                 this.timeoutDurationMs = this.timeoutMs = a;
  2015.                 this.countdownRatio = 1;
  2016.                 0 === this.lastTimeoutTimeMs && rafHub.request(this.boundUpdateTimeout38_)
  2017.               };
  2018.               cProto.updateTimeout = function (a) {
  2019.                 console.log('cProto.updateTimeout', tag)
  2020.                 if (!this.boundUpdateTimeout38_) this.boundUpdateTimeout38_ = this.updateTimeout.bind(this);
  2021.                 this.lastTimeoutTimeMs && (this.timeoutMs = Math.max(0, this.timeoutMs - (a - this.lastTimeoutTimeMs)),
  2022.                   this.countdownRatio = this.timeoutMs / this.timeoutDurationMs);
  2023.                 this.isAttached && this.timeoutMs ? (this.lastTimeoutTimeMs = a,
  2024.                   rafHub.request(this.boundUpdateTimeout38_)) : this.lastTimeoutTimeMs = 0
  2025.               };
  2026.  
  2027.               console.log('RAF_HACK_INPUT_RENDERER', tag, "OK")
  2028.             } else {
  2029.  
  2030.               console.log('RAF_HACK_INPUT_RENDERER', tag, "NG")
  2031.             }
  2032.  
  2033.           })();
  2034.  
  2035.           console.log("[End]");
  2036.  
  2037.           console.groupEnd();
  2038.  
  2039.  
  2040.         })
  2041.  
  2042.  
  2043.  
  2044.       }
  2045.  
  2046.  
  2047.       if (ENABLE_RAF_HACK_EMOJI_PICKER && rafHub !== null) {
  2048.  
  2049.  
  2050.         customElements.whenDefined("yt-emoji-picker-renderer").then(() => {
  2051.  
  2052.           console.groupCollapsed("YouTube Super Fast Check - yt-emoji-picker-renderer hacks");
  2053.           console.log("[Begin]");
  2054.           (() => {
  2055.  
  2056.             const tag = "yt-emoji-picker-renderer"
  2057.             const dummy = document.createElement(tag);
  2058.  
  2059.             const cProto = getProto(dummy);
  2060.             if (!cProto || !cProto.attached) {
  2061.               console.warn(`proto.attached for ${tag} is unavailable.`);
  2062.               return;
  2063.             }
  2064.  
  2065.             let doHack = false;
  2066.             if (typeof cProto.animateScroll_ === 'function') {
  2067.  
  2068.               // not cancellable
  2069.               console.log('animateScroll_', typeof cProto.animateScroll_)
  2070.  
  2071.               doHack = fnIntegrity(cProto.animateScroll_, '1.102.49')
  2072.  
  2073.             }
  2074.  
  2075.             if (doHack) {
  2076.  
  2077.               const querySelector = HTMLElement.prototype.querySelector;
  2078.               const U = (element) => ({
  2079.                 querySelector: (selector) => querySelector.call(element, selector)
  2080.               });
  2081.  
  2082.               cProto.animateScroll_ = function (a) {
  2083.                 // console.log('cProto.animateScroll_', tag) // yt-emoji-picker-renderer
  2084.                 if (!this.boundAnimateScroll39_) this.boundAnimateScroll39_ = this.animateScroll_.bind(this);
  2085.                 this.lastAnimationTime_ || (this.lastAnimationTime_ = a);
  2086.                 a -= this.lastAnimationTime_;
  2087.                 200 > a ? (U(this.hostElement).querySelector("#categories").scrollTop = this.animationStart_ + (this.animationEnd_ - this.animationStart_) * a / 200,
  2088.                   rafHub.request(this.boundAnimateScroll39_)) : (null != this.animationEnd_ && (U(this.hostElement).querySelector("#categories").scrollTop = this.animationEnd_),
  2089.                     this.animationEnd_ = this.animationStart_ = null,
  2090.                     this.lastAnimationTime_ = 0);
  2091.                 this.updateButtons_()
  2092.               }
  2093.  
  2094.               console.log('ENABLE_RAF_HACK_EMOJI_PICKER', tag, "OK")
  2095.             } else {
  2096.  
  2097.               console.log('ENABLE_RAF_HACK_EMOJI_PICKER', tag, "NG")
  2098.             }
  2099.  
  2100.           })();
  2101.  
  2102.           console.log("[End]");
  2103.  
  2104.           console.groupEnd();
  2105.         });
  2106.       }
  2107.  
  2108.  
  2109.  
  2110.  
  2111.       if (ENABLE_RAF_HACK_DOCKED_MESSAGE && rafHub !== null) {
  2112.  
  2113.  
  2114.         customElements.whenDefined("yt-live-chat-docked-message").then(() => {
  2115.  
  2116.           console.groupCollapsed("YouTube Super Fast Check - yt-live-chat-docked-message hacks");
  2117.           console.log("[Begin]");
  2118.           (() => {
  2119.  
  2120.             const tag = "yt-live-chat-docked-message"
  2121.             const dummy = document.createElement(tag);
  2122.  
  2123.             const cProto = getProto(dummy);
  2124.             if (!cProto || !cProto.attached) {
  2125.               console.warn(`proto.attached for ${tag} is unavailable.`);
  2126.               return;
  2127.             }
  2128.  
  2129.             let doHack = false;
  2130.             if (typeof cProto.detached === 'function' && typeof cProto.checkIntersections === 'function' && typeof cProto.onDockableMessagesChanged === 'function' && typeof cProto.boundCheckIntersections === 'undefined') {
  2131.  
  2132.               // cancelable - this.intersectRAF <detached>
  2133.               // yt-live-chat-docked-message
  2134.               // boundCheckIntersections <-> checkIntersections
  2135.               // onDockableMessagesChanged
  2136.               //  this.intersectRAF = window.requestAnimationFrame(this.boundCheckIntersections);
  2137.  
  2138.               console.log('detached', typeof cProto.detached)
  2139.               console.log('checkIntersections', typeof cProto.checkIntersections)
  2140.               console.log('onDockableMessagesChanged', typeof cProto.onDockableMessagesChanged)
  2141.  
  2142.               doHack = fnIntegrity(cProto.detached, '0.32.22') && fnIntegrity(cProto.checkIntersections, '0.128.85') && fnIntegrity(cProto.onDockableMessagesChanged, '0.20.11')
  2143.  
  2144.             }
  2145.  
  2146.             if (doHack) {
  2147.  
  2148.               cProto.checkIntersections = function () {
  2149.                 console.log('cProto.checkIntersections', tag)
  2150.                 if (this.dockableMessages.length) {
  2151.                   this.intersectRAF = rafHub.request(this.boundCheckIntersections);
  2152.                   var a = this.dockableMessages[0]
  2153.                     , b = this.hostElement.getBoundingClientRect();
  2154.                   a = a.getBoundingClientRect();
  2155.                   var c = a.top - b.top
  2156.                     , d = 8 >= c;
  2157.                   c = 8 >= c - this.hostElement.clientHeight;
  2158.                   if (d) {
  2159.                     for (var e; d;) {
  2160.                       e = this.dockableMessages.shift();
  2161.                       d = this.dockableMessages[0];
  2162.                       if (!d)
  2163.                         break;
  2164.                       d = d.getBoundingClientRect();
  2165.                       c = d.top - b.top;
  2166.                       var f = 8 >= c;
  2167.                       if (8 >= c - a.height)
  2168.                         if (f)
  2169.                           a = d;
  2170.                         else
  2171.                           return;
  2172.                       d = f
  2173.                     }
  2174.                     this.dock(e)
  2175.                   } else
  2176.                     c && this.dockedItem && this.clear()
  2177.                 } else
  2178.                   this.intersectRAF = 0
  2179.               }
  2180.  
  2181.               cProto.onDockableMessagesChanged = function () {
  2182.                 // console.log('cProto.onDockableMessagesChanged', tag) // yt-live-chat-docked-message 
  2183.                 this.dockableMessages.length && !this.intersectRAF && (this.intersectRAF = rafHub.request(this.boundCheckIntersections))
  2184.               }
  2185.  
  2186.               cProto.detached = function () {
  2187.                 this.intersectRAF && rafHub.cancel(this.intersectRAF)
  2188.               }
  2189.  
  2190.               console.log('ENABLE_RAF_HACK_DOCKED_MESSAGE', tag, "OK")
  2191.             } else {
  2192.  
  2193.               console.log('ENABLE_RAF_HACK_DOCKED_MESSAGE', tag, "NG")
  2194.             }
  2195.  
  2196.           })();
  2197.  
  2198.           console.log("[End]");
  2199.  
  2200.           console.groupEnd();
  2201.  
  2202.         });
  2203.  
  2204.       }
  2205.  
  2206.  
  2207.  
  2208.     });
  2209.  
  2210.  
  2211.  
  2212.  
  2213.  
  2214.   });
  2215.  
  2216. })({ IntersectionObserver });