☰

Restore YouTube Username from Handle to Custom

将 YouTube 用户名从 Handle 恢复为自定义名称

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

  1. /*
  2.  
  3. MIT License
  4.  
  5. Copyright 2023 CY Fung
  6.  
  7. Permission is hereby granted, free of charge, to any person obtaining a copy
  8. of this software and associated documentation files (the "Software"), to deal
  9. in the Software without restriction, including without limitation the rights
  10. to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11. copies of the Software, and to permit persons to whom the Software is
  12. furnished to do so, subject to the following conditions:
  13.  
  14. The above copyright notice and this permission notice shall be included in all
  15. copies or substantial portions of the Software.
  16.  
  17. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18. IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19. FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  20. AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21. LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22. OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23. SOFTWARE.
  24.  
  25. */
  26. // ==UserScript==
  27. // @name                Restore YouTube Username from Handle to Custom
  28. // @namespace           http://tampermonkey.net/
  29. // @version             0.7.0
  30. // @license             MIT License
  31.  
  32. // @author              CY Fung
  33. // @match               https://www.youtube.com/*
  34. // @match               https://m.youtube.com/*
  35. // @exclude             /^https?://\S+\.(txt|png|jpg|jpeg|gif|xml|svg|manifest|log|ini)[^\/]*$/
  36. // @icon                https://github.com/cyfung1031/userscript-supports/raw/main/icons/general-icon.png
  37. // @supportURL          https://github.com/cyfung1031/userscript-supports
  38. // @run-at              document-start
  39. // @grant               none
  40. // @unwrap
  41. // @allFrames           true
  42. // @inject-into         page
  43.  
  44. // @compatible          firefox 55
  45. // @compatible          chrome 61
  46. // @compatible          opera 48
  47. // @compatible          safari 11.1
  48. // @compatible          edge 16
  49.  
  50. // @description         To restore YouTube Username to the traditional custom name
  51. // @description:ja      YouTubeのユーザー名を伝統的なカスタム名に復元するために。
  52. // @description:zh-TW   將 YouTube 使用者名稱從 Handle 恢復為自訂名稱
  53. // @description:zh-CN   将 YouTube 用户名从 Handle 恢复为自定义名称
  54.  
  55. // @description:ko      YouTube 사용자 이름을 전통적인 사용자 지정 이름으로 복원합니다.
  56. // @description:ru      Восстановление имени пользователя YouTube с помощью обычного настраиваемого имени
  57. // @description:af      Herstel YouTube-gebruikersnaam vanaf Handvat na Aangepaste Naam
  58. // @description:az      YouTube İstifadəçi Adını Özəl Adından İstifadə Etmək
  59. // @description:id      Mengembalikan Nama Pengguna YouTube dari Handle ke Kustom
  60. // @description:ms      Pulihkan Nama Pengguna YouTube dari Handle ke Tersuai
  61. // @description:bs      Vrati YouTube korisničko ime sa ručke na prilagođeno ime
  62. // @description:ca      Restaurar el nom d'usuari de YouTube de la màniga al personalitzat
  63. // @description:cs      Obnovte uživatelské jméno YouTube z rukojeti na vlastní
  64. // @description:da      Gendan YouTube-brugernavn fra Håndtag til Brugerdefineret
  65. // @description:de      Stellt den YouTube-Benutzernamen von Handle auf Benutzerdefiniert wieder her
  66. // @description:et      Taasta YouTube'i kasutajanimi käepidemelt kohandatud nimeks
  67. // @description:es      Restaurar el nombre de usuario de YouTube de la manija al personalizado
  68. // @description:eu      Berrezarri YouTube Erabiltzaile-izena Manipulatik Pertsonalizatuera
  69. // @description:fr      Restaurer le nom d'utilisateur YouTube de la poignée au nom personnalisé
  70. // @description:gl      Restaura o nome de usuario de YouTube da manexa ao personalizado
  71. // @description:hr      Vrati YouTube korisničko ime s ručke na prilagođeno ime
  72. // @description:zu      Hlanganisa Igama Lokusebenza lwe-YouTube kusuka kwi-Handle kuze kube kusebenza kakhulu
  73. // @description:is      Endurheimtu YouTube Notandanafn frá Handfangi til Sérsniðins
  74. // @description:it      Ripristina il nome utente di YouTube da Handle a Personalizzato
  75. // @description:sw      Rejesha Jina la Mtumiaji wa YouTube kutoka kwa Kishughulikia hadi Desturi
  76. // @description:lv      Atjaunot YouTube lietotāja vārdu no roktura uz pielāgotu
  77. // @description:lt      Atkurti „YouTube“ naudotojo vardą iš rankenos į tinkamą
  78. // @description:hu      Visszaállítja a YouTube felhasználónevet a fogantyútól a testreszabottra
  79. // @description:nl      Herstel YouTube-gebruikersnaam van Handle naar Aangepaste naam
  80. // @description:uz      YouTube foydalanuvchining nomini Hurda dan Shaxsiylashtirilgan nomga qaytarish
  81. // @description:pl      Przywróć nazwę użytkownika YouTube z uchwytu na niestandardową
  82. // @description:pt      Restaurar o nome de usuário do YouTube de Handle para Personalizado
  83. // @description:pt-BR   Restaurar o nome de usuário do YouTube de Handle para Personalizado
  84. // @description:ro      Restaurați Numele de Utilizator YouTube de la Mâner la Personalizat
  85. // @description:sq      Rikthe emrin e përdoruesit të YouTube nga Maja në Personalizuar
  86. // @description:sk      Obnovte používateľské meno YouTube z rukoväte na vlastné
  87. // @description:sl      Obnovite uporabniško ime YouTube iz ročaja v prilagojeno ime
  88. // @description:sr      Вратите YouTube корисничко име са ручке на прилагођено име
  89. // @description:fi      Palauta YouTube-käyttäjänimi kahvasta räätälöityyn nimeen
  90. // @description:sv      Återställ YouTube-användarnamnet från handtaget till anpassat namn
  91. // @description:vi      Khôi phục Tên người dùng YouTube từ Tay cầm thành Tùy chỉnh
  92. // @description:tr      Özel İsme Kullanıcı Adını İade Etme
  93. // @description:be      Вярнуць імя карыстальніка YouTube з ручкі на наладжваецца
  94. // @description:bg      Възстановяване на потребителско име на YouTube от дръжка до персонализирано име
  95. // @description:ky      YouTube колдонуучунун атты боюнча атын тамашалау
  96. // @description:kk      YouTube пайдаланушының атын Handle танымасынан Жеке атауға қайта түсіру
  97. // @description:mk      Врати го името на YouTube корисникот од држачот во прилагодено име
  98. // @description:mn      YouTube хэрэглэгчийн нэрийг хүчирхийлэгчидээс Байгууллагад нь солих
  99. // @description:uk      Відновлення імені користувача YouTube з ручки на налаштоване ім'я
  100. // @description:el      Επαναφορά Ονόματος Χρήστη YouTube από τη Λαβή σε Προσαρμοσμένο
  101. // @description:hy      Վերականգնել YouTube-ի Օգտագործողի Անունը Ձեռքից Հատուցվածությանով
  102. // @description:ur      ہینڈل سے یوٹیوب یوزر نیم کو کسٹم میں بحال کریں
  103. // @description:ar      استعادة اسم مستخدم YouTube من المقبض إلى مخصص
  104. // @description:fa      بازیابی نام کاربری یوتیوب از دستگیره به سفارشی
  105. // @description:ne      ह्यान्डलबाट यूट्युब प्रयोगकर्तानाम अनुकूलमा उपयोग गर्नुहोस्
  106. // @description:mr      हॅंडलमधून यूट्यूब वापरकर्तानाव अनुकूलित करा
  107. // @description:hi      हैंडल से यूट्यूब यूजरनेम को कस्टम में बदलें
  108. // @description:as      কাস্টম হতে হ্যান্ডেল পৰা ইউটিউব ব্যৱহাৰকাৰী নাম পুনৰ্স্থাপন কৰক
  109. // @description:bn      হ্যান্ডেল থেকে কাস্টম করে ইউটিউব ব্যবহারকারীর নাম পুনরুদ্ধার করুন
  110. // @description:pa      ਯੂਟਿਊਬ ਯੂਜਰਨਾਂ ਦਾ ਨਾਂ ਹੈਂਡਲ ਤੋਂ ਕਸਟਮ ਵਿੱਚ ਮੁੜ ਲਾਓ
  111. // @description:gu      હેન્ડલથી કસ્ટમમાંથી YouTube વપરાશકર્તાનું નામ પુનર્સ્થાપિત કરો
  112. // @description:or      କଷ୍ଟମରେ ହେନ୍ଡେଲରୁ YouTube ବ୍ୟବହାରକାରୀଙ୍କ ନାମ ପୁନର୍ପ୍ରାପ୍ତ କରନ୍ତୁ
  113. // @description:ta      ஹேண்டில் இருந்து கஸ்டம் ஆக்கும் யூடியூப் பயனர்பெயரை மீட்டமைக்கவும்
  114. // @description:te      హాండును నుంచి YouTube వాడుకరి పేరును కస్టమ్‌కు పునరుద్ధరించండి
  115. // @description:kn      ಹ್ಯಾಂಡಲ್‌ನಿಂದ YouTube ಬಳಕೆದಾರ ಹೆಸರನ್ನು ಅನುಕೂಲಿತ ಮಾಡಿ
  116. // @description:ml      ഹാന്റിൽ നിന്ന് കസ്റ്റം ആക്കാംമെന്ന് യുട്യൂബ് ഉപയോക്തൃനാമം മറ്റുള്ളവരെ മാറ്റുക
  117. // @description:si      හැන්ඩල් සහිතව YouTube භාවිතයේ පරිශීලක නාමය ස්වයං කරයි
  118. // @description:th      กู้คืนชื่อผู้ใช้ YouTube จากแฮนดิลไปเป็นชื่อที่กำหนดเอง
  119. // @description:lo      ເຮັດຊະນິດຊື່ຜູ້ໃຊ້ YouTube ຈາກ Handle ຈົດໄວ້ເປັນຊື່ປັດຈຸບັນ
  120. // @description:my      Handle မှ YouTube အသုံးပြုသူအမည်ကို စတင်ပြန်စစ်ဆေးပါ
  121. // @description:ka      YouTube მომხმარებლის სახელის აღდგენა ხანდლიდან მორგებულ სახელში
  122. // @description:am      ስለ YouTube የተጠቃሚ ስም ማስቀመጫዎቹን ከ Handle ወደ Custom ውስጥ እንደሚመጣ ይረዳሉ
  123. // @description:km      កំណត់ YouTube ពាក្យឈ្មោះពី Handle ទៅជាឈ្មោះផ្ទាល់ខ្លួន
  124.  
  125. // ==/UserScript==
  126.  
  127. /* jshint esversion:8 */
  128.  
  129.  
  130. /**
  131.     @typedef DisplayNameResultObject
  132.     @type {Object}
  133.     @property {string} title
  134.     @property {string?} externalId
  135.     @property {string[]} ownerUrls
  136.     @property {string} channelUrl
  137.     @property {string} vanityChannelUrl
  138.     @property {boolean|undefined} verified123
  139.  
  140. */
  141.  
  142. /**
  143.     @typedef ChannelIdToHandleResult
  144.     @type {Object}
  145.     @property {string} handleText
  146.     @property {boolean} justPossible
  147.  */
  148.  
  149. (function (__CONTEXT__) {
  150.     'use strict';
  151.  
  152.     const USE_RSS_FETCHER = true;
  153.     const USE_TIMEOUT_SIGNAL = false;
  154.     const USE_CHANNEL_META = true;
  155.     const CHANGE_FOR_SHORTS_CHANNEL_NAME = false;
  156.  
  157.     const { Promise, fetch, JSON, Request, AbortController, setTimeout, clearTimeout } = __CONTEXT__; // YouTube hacks Promise in WaterFox Classic and "Promise.resolve(0)" nevers resolve.
  158.  
  159.     const timeoutSignal = AbortController && USE_TIMEOUT_SIGNAL ? (timeout) => {
  160.         let controller = new AbortController();
  161.         const r = controller.signal;
  162.         let cid = setTimeout(() => {
  163.             if (cid >= 1) {
  164.                 cid = 0;
  165.                 controller && controller.abort();
  166.                 controller = null;
  167.             }
  168.         }, timeout);
  169.         r.clearTimeout = () => {
  170.             if (cid >= 1) {
  171.                 clearTimeout(cid);
  172.                 cid = 0;
  173.             }
  174.         }
  175.         return r;
  176.     } : () => { };
  177.  
  178.     const fxOperator = (proto, propertyName) => {
  179.         let propertyDescriptorGetter = null;
  180.         try {
  181.             propertyDescriptorGetter = Object.getOwnPropertyDescriptor(proto, propertyName).get;
  182.             // https://github.com/cyfung1031/userscript-supports/issues/9
  183.             // .parentNode becomes DocumentFragment
  184.             /**
  185.              *
  186.              * Issue Description: YtCustomElements - Custom DOM Operations overrided in FireFox
  187.              *
  188.              * e.g. ytd-comment-renderer#comment > div#body
  189.              *
  190.              * ${div#body}.parentNode = DocumentFragment <Node.parentNode>
  191.              * ${ytd-comment-renderer#comment}.firstElementChild <Element.firstElementChild>
  192.              *
  193.              * Cofirmed Affected: parentNode, firstChild, firstElementChild, lastChild, lastElementChild, querySelector, & querySelectorAll
  194.              *
  195.              * Alternative way: ytCustomElement.$.xxxxxxx
  196.              *
  197.              */
  198.         } catch (e) { }
  199.         return typeof propertyDescriptorGetter === 'function' ? (e) => propertyDescriptorGetter.call(e) : (e) => e[propertyName];
  200.     };
  201.  
  202.     const fxAPI = (proto, propertyName) => {
  203.         const methodFunc = proto[propertyName];
  204.         return typeof methodFunc === 'function' ? (e, ...args) => methodFunc.apply(e, args) : (e, ...args) => e[propertyName](...args);
  205.     };
  206.  
  207.     /** @type { (node: Node)=>Node | null } */
  208.     const nodeParent = fxOperator(Node.prototype, 'parentNode');
  209.     /** @type { (node: Node)=>Node | null } */
  210.     const nodeFirstChild = fxOperator(Node.prototype, 'firstChild');
  211.     /** @type { (node: Node)=>Node | null } */
  212.     const nodeNextSibling = fxOperator(Node.prototype, 'nextSibling');
  213.  
  214.     /** @type { (node: ParentNode, selector: string)=>Element | null } */
  215.     const elementQS = fxAPI(Element.prototype, 'querySelector');
  216.     /** @type { (node: ParentNode, selector: string)=>Element[] } */
  217.     const elementQSA = fxAPI(Element.prototype, 'querySelectorAll');
  218.  
  219.     /*
  220.  
  221.  
  222.     init
  223.  
  224.         initialdata
  225.         state-progress
  226.         state-responsereceived
  227.         player-autonav-pause
  228.         state-change
  229.         state-navigateend
  230.         player-initialized
  231.         renderer-module-load-start
  232.         video-data-change
  233.         player-state-change
  234.         updateui
  235.         renderer-module-load-end -> channel owner DOM available
  236.         player-autonav-pause
  237.         updateui
  238.         renderer-module-load-start
  239.         updateui
  240.         renderer-module-load-end
  241.  
  242.  
  243.         playing
  244.  
  245.         h5player.video-progress
  246.         h5player.video-progress
  247.         h5player.video-progress
  248.         h5player.video-progress
  249.         ...
  250.  
  251.  
  252.  
  253.  
  254.     navigate new video
  255.  
  256.         state-navigatestart
  257.         state-change => channel owener DOM vanished
  258.         state-progress
  259.         ...
  260.         h5player.player-state-change
  261.         h5player.video-data-change
  262.         h5player.player-state-change
  263.         h5player.muted-autoplay-change
  264.         h5player.volume-change
  265.         h5player.video-data-change
  266.         h5player.volume-change
  267.         ...
  268.  
  269.         state-progress
  270.         ...
  271.  
  272.         state-progress => channel owner DOM appear [just before state-responsereceived]
  273.         state-responsereceived
  274.  
  275.         video-data-change
  276.         state-change
  277.         state-navigateend
  278.  
  279.  
  280.  
  281.  
  282.     UX interaction
  283.  
  284.         user-activity
  285.         player-autonav-pause
  286.  
  287.  
  288.  
  289.  
  290.  
  291.     EventTarget.prototype.uhfsE = EventTarget.prototype.dispatchEvent
  292.  
  293.     EventTarget.prototype.dispatchEvent = function (ev) {
  294.         if (ev instanceof Event) {
  295.             if (ev.type === 'video-progress') { } else {
  296.                 console.log(ev.type, this, ev.target)
  297.                 if (ev.target === null) {
  298.                     console.log(ev.type, (document.querySelector('ytm-app') || 0).data)
  299.                     console.log(ev.type, (document.querySelector('ytm-slim-owner-renderer') || 0).textContent)
  300.                 }
  301.             }
  302.         }
  303.         return this.uhfsE.apply(this, arguments);
  304.     }
  305.  
  306.  
  307.  
  308. */
  309.  
  310.     const isMobile = location.hostname === 'm.youtube.com';
  311.  
  312.     const cfg = {};
  313.     class Mutex {
  314.  
  315.         constructor() {
  316.             this.p = Promise.resolve()
  317.         }
  318.  
  319.         /**
  320.          *  @param {(lockResolve: () => void)} f
  321.          */
  322.         lockWith(f) {
  323.             this.p = this.p.then(() => new Promise(f).catch(console.warn))
  324.         }
  325.  
  326.     }
  327.  
  328.     class OrderedMutex extends Mutex {
  329.         constructor() {
  330.             super();
  331.             this.nextIndex = 0;
  332.             this.arr = [];
  333.             this.lockFunc = resolve => {
  334.                 if (this.arr.length >= 1) {
  335.                     let f = this.arr[0];
  336.                     if (typeof f === 'function') {
  337.                         this.arr.shift();
  338.                         if (this.nextIndex > 0) this.nextIndex--;
  339.                         f(resolve);
  340.                         return;
  341.                     } else {
  342.                         // reset if unknown error
  343.                         this.arr.length = 0;
  344.                         this.nextIndex = 0;
  345.                     }
  346.                 }
  347.                 resolve();
  348.             };
  349.         }
  350.         /**
  351.          *  @param {(lockResolve: () => void)} f
  352.          */
  353.         add(f) {
  354.             if (this.nextIndex === this.arr.length) {
  355.                 this.arr.push(f); this.nextIndex++;
  356.             } else {
  357.                 this.arr.splice(this.nextIndex++, 0, f);
  358.             }
  359.             this.lockWith(this.lockFunc);
  360.         }
  361.     }
  362.     // usage: run network request one by one
  363.     const mutex = new OrderedMutex();
  364.  
  365.     /**
  366.    * @typedef { AsyncValue<T> | T} AsyncOrResolvedValue<T>
  367.    * @template T
  368.    */
  369.  
  370.     //
  371.     /**
  372.      * usage: cache the network result per web application instance.
  373.      *  @type {Map<string, AsyncOrResolvedValue<DisplayNameResultObject>>} */
  374.     const displayNameResStore = new Map();
  375.  
  376.     /**
  377.      * usage: mapping the .dataChanged() to the wrapped function - only few entries as most are {ytd-comment-renderer}.dataChanged().
  378.      *  @type {WeakMap<Function, Function>} */
  379.     const dataChangedFuncStore = new WeakMap();
  380.  
  381.     /**
  382.      * usage: for \@Mention inside comments in YouTube Mobile that without hyperlinks for channelId.
  383.      *  @type {Map<string, AsyncOrResolvedValue<string>>} */
  384.     const handleToChannelId = new Map();
  385.  
  386.     /**
  387.      * usage: in RSS fetching, no handle text will be obtained from the response. inject the handle into the response.
  388.      * @type {Map<string, ChannelIdToHandleResult>} */
  389.     const channelIdToHandle = new Map();
  390.  
  391.  
  392.     /**
  393.      * AsyncValue
  394.      * @class
  395.      * @template T
  396.      */
  397.     class AsyncValue {
  398.         constructor() {
  399.             /** @type {T | null} */
  400.             this.__value__ = null;
  401.             /** @type {((value: any)=>void) | null} */
  402.             this.__resolve__ = null;
  403.             this.__promise__ = new Promise(resolve => {
  404.                 this.__resolve__ = resolve;
  405.             });
  406.         }
  407.         /**
  408.          *
  409.          * @param {T} value
  410.          */
  411.         setValue(value) {
  412.             const promise = this.__promise__;
  413.             if (promise === null) throw 'Value has already been set.';
  414.             this.__value__ = value;
  415.             this.__promise__ = null;
  416.             this.__resolve__ ? this.__resolve__() : Promise.resolve().then(() => this.__resolve__());
  417.         }
  418.         /**
  419.          *
  420.          * @returns {Promise<T>}
  421.          */
  422.         async getValue() {
  423.             const promise = this.__promise__;
  424.             if (promise === null) return this.__value__;
  425.             await promise; // promise become null
  426.             this.__promise__ = null; // just in case
  427.             this.__resolve__ = null;
  428.             return this.__value__;
  429.         }
  430.     }
  431.  
  432.     /**
  433.      *
  434.      * @param {DisplayNameResultObject} resultInfo
  435.      * @param {string} channelId
  436.      */
  437.     const cacheHandleToChannel = (resultInfo, channelId) => {
  438.  
  439.         const { vanityChannelUrl, ownerUrls } = resultInfo;
  440.  
  441.         let handleText = urlToHandle(vanityChannelUrl || '');
  442.  
  443.         if (handleText) {
  444.             // match = true;
  445.         } else if ((ownerUrls || 0).length >= 1) {
  446.             for (const ownerUrl of ownerUrls) {
  447.                 handleText = urlToHandle(ownerUrl || '');
  448.  
  449.                 if (handleText) {
  450.                     //  match = true;
  451.                     break;
  452.                 }
  453.             }
  454.         }
  455.         if (handleText) {
  456.  
  457.             const asyncValue = handleToChannelId.get(handleText); // nothing if no pending promise
  458.             if (asyncValue instanceof AsyncValue) {
  459.                 asyncValue.setValue(channelId);
  460.             }
  461.             handleToChannelId.set(handleText, channelId);
  462.         }
  463.  
  464.  
  465.     }
  466.  
  467.     /**
  468.      *
  469.      * @param {string} channelId
  470.      * @param {Function} onDownloaded
  471.      * @param {Function} onResulted
  472.      * @param {Function} onError
  473.      */
  474.     const fetcherBrowseAPI = (channelId, onDownloaded, onResulted, onError) => {
  475.  
  476.         let signal = timeoutSignal(4000);
  477.  
  478.         fetch(new Request(`/youtubei/v1/browse?key=${cfg.INNERTUBE_API_KEY}&prettyPrint=false`, {
  479.             "method": "POST",
  480.             "mode": "same-origin",
  481.             "credentials": "omit",
  482.  
  483.             referrerPolicy: "no-referrer",
  484.             cache: "default", // no effect on POST request
  485.             // cache: "force-cache",
  486.             redirect: "error", // there shall be no redirection in this API request
  487.             integrity: "",
  488.             keepalive: false,
  489.             signal,
  490.  
  491.             "headers": {
  492.                 "Content-Type": "application/json", // content type of the body data in POST request
  493.                 "Accept-Encoding": "gzip, deflate, br", // YouTube Response - br
  494.                 // X-Youtube-Bootstrap-Logged-In: false,
  495.                 // X-Youtube-Client-Name: 1, // INNERTUBE_CONTEXT_CLIENT_NAME
  496.                 // X-Youtube-Client-Version: "2.20230622.06.00" // INNERTUBE_CONTEXT_CLIENT_VERSION
  497.  
  498.                 "Accept": "application/json",
  499.             },
  500.             "body": JSON.stringify({
  501.                 "context": {
  502.                     "client": {
  503.                         "visitorData": "Cgs0aVg0VjFWM0U0USi0jvOkBg%3D%3D", // [optional] fake visitorData to avoid dynamic visitorData generated in response
  504.                         "clientName": "MWEB", // "WEB", "MWEB"
  505.                         "clientVersion": `${cfg.INNERTUBE_CLIENT_VERSION || '2.20230614.01.00'}`, // same as WEB version
  506.                         "originalUrl": `https://m.youtube.com/channel/${channelId}`,
  507.                         "playerType": "UNIPLAYER",
  508.                         "platform": "MOBILE", // "DESKTOP", "MOBILE", "TABLET"
  509.                         "clientFormFactor": "SMALL_FORM_FACTOR", // "LARGE_FORM_FACTOR", "SMALL_FORM_FACTOR"
  510.                         "acceptHeader": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
  511.                         "mainAppWebInfo": {
  512.                             "graftUrl": `/channel/${channelId}`,
  513.                             "webDisplayMode": "WEB_DISPLAY_MODE_BROWSER",
  514.                             "isWebNativeShareAvailable": true
  515.                         }
  516.                     },
  517.                     "user": {
  518.                         "lockedSafetyMode": false
  519.                     },
  520.                     "request": {
  521.                         "useSsl": true,
  522.                         "internalExperimentFlags": [],
  523.                         "consistencyTokenJars": []
  524.                     }
  525.                 },
  526.                 "browseId": `${channelId}`
  527.             })
  528.         })).then(res => {
  529.             signal && signal.clearTimeout && signal.clearTimeout();
  530.             signal = null;
  531.             onDownloaded();
  532.             onDownloaded = null;
  533.             return res.json();
  534.         }).then(resJson => {
  535.             let resultInfo = ((resJson || 0).metadata || 0).channelMetadataRenderer;
  536.             onResulted(resultInfo);
  537.             onResulted = null;
  538.         }).catch(onError);
  539.  
  540.     };
  541.  
  542.     /**
  543.      *
  544.      * @param {string} channelId
  545.      * @param {Function} onDownloaded
  546.      * @param {Function} onResulted
  547.      * @param {Function} onError
  548.      */
  549.     const fetcherRSS = location.origin !== 'https://www.youtube.com' ? null : (channelId, onDownloaded, onResulted, onError) => {
  550.  
  551.         let signal = timeoutSignal(4000);
  552.         fetch(`https://www.youtube.com/feeds/videos.xml?channel_id=${channelId}`, {
  553.             // YouTube RSS Response - public, max-age=900
  554.  
  555.             "method": "GET",
  556.             "mode": "same-origin",
  557.             "credentials": "omit",
  558.  
  559.             referrerPolicy: "no-referrer",
  560.             cache: "default",
  561.             // cache: "no-cache",
  562.             redirect: "error", // there shall be no redirection in this API request
  563.             integrity: "",
  564.             keepalive: false,
  565.             signal,
  566.  
  567.             "headers": {
  568.                 "Cache-Control": "public, max-age=900, stale-while-revalidate=1800",
  569.                 // refer "Cache-Control Use Case Examples" in https://www.koyeb.com/blog/using-cache-control-and-cdns-to-improve-performance-and-reduce-latency
  570.                 // seems YouTube RSS Feeds server insists its own Cache-Control.
  571.  
  572.                 // "Content-Type": "text/xml; charset=UTF-8",
  573.                 "Accept-Encoding": "gzip, deflate, br", // YouTube Response - gzip
  574.                 // X-Youtube-Bootstrap-Logged-In: false,
  575.                 // X-Youtube-Client-Name: 1, // INNERTUBE_CONTEXT_CLIENT_NAME
  576.                 // X-Youtube-Client-Version: "2.20230622.06.00" // INNERTUBE_CONTEXT_CLIENT_VERSION
  577.  
  578.                 "Accept": "text/xml",
  579.             }
  580.         }).then(res => {
  581.             signal && signal.clearTimeout && signal.clearTimeout();
  582.             signal = null;
  583.             onDownloaded();
  584.             onDownloaded = null;
  585.             return res.text();
  586.         }).then(resText => {
  587.             let eIdx = resText.indexOf('<entry>');
  588.             let mText = (eIdx > 0) ? `${resText.substring(0, eIdx).trim()}</feed>` : resText;
  589.  
  590.             // simple: https://www.youtube.com/feeds/videos.xml?channel_id=UC-MUu72gixoYlhV5_mWa36g
  591.             // standard: https://www.youtube.com/feeds/videos.xml?channel_id=UCGSfK5HeiIhuFfXoKE47TzA
  592.             // long: https://www.youtube.com/feeds/videos.xml?channel_id=UC8cSGjKxDuh2mWG1hDOTdBg
  593.             // special: http://www.youtube.com/feeds/videos.xml?channel_id=UCmZ2-GUxmdWFKfXA5IN0x-w
  594.  
  595.  
  596.             let name, uri, mt;
  597.  
  598.             // ===============================================================
  599.  
  600.             /* removed in 2023.06.30 */
  601.  
  602.  
  603.             // ===============================================================
  604.  
  605.  
  606.             const wIdx1 = mText.indexOf('<author>');
  607.             const wIdx2 = wIdx1 > 0 ? mText.indexOf('</author>', wIdx1 + 8) : -1;
  608.  
  609.             if (wIdx1 > 0 && wIdx2 > 0) {
  610.                 let qText = mText.substring(wIdx1, wIdx2 + '</author>'.length);
  611.                 const template = document.createElement('template');
  612.                 template.innerHTML = qText;
  613.                 /** @type {HTMLElement | null} */
  614.                 let authorChild = ((template.content || 0).firstElementChild || 0).firstElementChild;
  615.                 for (; authorChild !== null; authorChild = authorChild.nextElementSibling) {
  616.                     const nodeName = authorChild.nodeName;
  617.                     if (nodeName === 'NAME') name = authorChild.textContent;
  618.                     else if (nodeName === 'URI') {
  619.                         uri = authorChild.textContent;
  620.                         mt = obtainChannelId(uri);
  621.                     }
  622.                 }
  623.                 template.innerHTML = '';
  624.             }
  625.  
  626.             if (!name && !uri) {
  627.  
  628.                 // fallback
  629.  
  630.                 const parser = new DOMParser();
  631.                 const xmlDoc = parser.parseFromString(mText, "text/xml");
  632.  
  633.                 // const author = xmlDoc.querySelector("author");
  634.  
  635.                 // https://extendsclass.com/xpath-tester.html
  636.  
  637.                 const authorChilds = xmlDoc.evaluate("//*[name()='author']/*", xmlDoc, null, XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
  638.  
  639.                 let authorChild;
  640.                 while ((authorChild = authorChilds.iterateNext()) !== null) {
  641.                     if (authorChild.nodeName === 'name') name = authorChild.textContent;
  642.                     else if (authorChild.nodeName === 'uri') {
  643.                         uri = authorChild.textContent;
  644.                         mt = obtainChannelId(uri)
  645.                     }
  646.                 }
  647.  
  648.                 try {
  649.                     xmlDoc.firstChild.remove();
  650.                 } catch (e) { }
  651.  
  652.             }
  653.  
  654.  
  655.  
  656.  
  657.             let res = null;
  658.  
  659.             if (name && uri && mt && mt === channelId) {
  660.  
  661.  
  662.                 let object = channelIdToHandle.get(mt);
  663.  
  664.                 if (object) {
  665.  
  666.                     if (object.handleText === name) channelIdToHandle.delete(mt);
  667.                     else {
  668.                         object.justPossible = false; // ignore @handle checking
  669.  
  670.                         res = {
  671.                             "title": name,
  672.                             "externalId": mt,
  673.                             "ownerUrls": [
  674.                                 `http://www.youtube.com/${object.handleText}`
  675.                             ],
  676.                             "channelUrl": uri,
  677.                             "vanityChannelUrl": `http://www.youtube.com/${object.handleText}`
  678.                         };
  679.  
  680.                     }
  681.                 }
  682.             }
  683.  
  684.             onResulted(res);
  685.             onResulted = null;
  686.  
  687.             // let resultInfo = ((res || 0).metadata || 0).channelMetadataRenderer;
  688.             // onResulted(resultInfo);
  689.         }).catch(onError);
  690.  
  691.  
  692.  
  693.     }
  694.  
  695.     /**
  696.      *
  697.      * @param {string} channelId
  698.      */
  699.     function stackNewRequest(channelId) {
  700.  
  701.         mutex.add(lockResolve => {
  702.  
  703.             let bResult = displayNameResStore.get(channelId);
  704.             if (!(bResult instanceof AsyncValue)) {
  705.                 // resolved or removed
  706.                 lockResolve(); lockResolve = null;
  707.                 return;
  708.             }
  709.  
  710.             let setResult = (result) => {
  711.                 setResult = null;
  712.                 if (!result) {
  713.                     bResult.fetchingState = 0;
  714.                     bResult.setValue(null);
  715.                     displayNameResStore.delete(channelId); // create another network response in the next request
  716.                 } else {
  717.                     bResult.fetchingState = 4;
  718.                     bResult.setValue(result);
  719.                     displayNameResStore.set(channelId, result); // update store result to resolved value
  720.                 }
  721.                 bResult = null;
  722.             }
  723.  
  724.             if (bResult.fetchingState >= 2) { // fetchingState == 3 or 4
  725.                 // request is already done. no need to stack any request
  726.                 lockResolve(); lockResolve = null;
  727.                 return;
  728.             }
  729.  
  730.             if (!document.querySelector(`[jkrgy="${channelId}"]`)) {
  731.                 // element has already been removed
  732.                 lockResolve(); lockResolve = null;
  733.                 setResult(null);
  734.                 return;
  735.             }
  736.  
  737.             //INNERTUBE_API_KEY = ytcfg.data_.INNERTUBE_API_KEY
  738.  
  739.             bResult.fetchingState = 2;
  740.  
  741.  
  742.             // note: when setResult(null), the fetch will be requested again if the same username appears. (multiple occurrences)
  743.             // consider the network problem might be fixed in the 2nd attempt, the name will be changed in the 2nd attempt but ignore 1st attempt.
  744.             const fetcher = USE_RSS_FETCHER && fetcherRSS && channelIdToHandle.has(channelId) ? fetcherRSS : fetcherBrowseAPI;
  745.             fetcher(channelId, () => {
  746.                 bResult.fetchingState = 3;
  747.                 lockResolve();
  748.                 lockResolve = null;
  749.             }, resultInfo => {
  750.  
  751.                 if (!resultInfo) {
  752.                     // invalid json format
  753.                     setResult(null);
  754.                     return;
  755.                 }
  756.  
  757.                 cacheHandleToChannel(resultInfo, channelId);
  758.  
  759.                 const { title, externalId, ownerUrls, channelUrl, vanityChannelUrl } = resultInfo;
  760.  
  761.                 const displayNameRes = { title, externalId, ownerUrls, channelUrl, vanityChannelUrl, verified123: false };
  762.  
  763.                 setResult(displayNameRes);
  764.             }, e => {
  765.                 lockResolve && lockResolve();
  766.                 lockResolve = null;
  767.                 console.warn(e);
  768.                 setResult && setResult(null);
  769.             });
  770.  
  771.         });
  772.  
  773.     }
  774.  
  775.     /**
  776.      *
  777.      * @param {string} url Example: _www\.youtube\.com/\@yr__kd_
  778.      * @returns Example: _\@yr__kd_
  779.      */
  780.     function urlToHandle(url) {
  781.  
  782.         if (typeof url !== 'string') return '';
  783.         let i = url.indexOf('.youtube.com/');
  784.         if (i >= 1) url = url.substring(i + '.youtube.com/'.length);
  785.         else if (url.charAt(0) === '/') url = url.substring(1);
  786.         return isDisplayAsHandle(url) ? url : '';
  787.  
  788.     }
  789.  
  790.     /**
  791.      *
  792.      * @param {string} channelId Example: UC0gmRdmpDWJ4dt7DAeRaawA
  793.      * @returns {Promise<DisplayNameResultObject | null>}
  794.      */
  795.     async function getDisplayName(channelId) {
  796.  
  797.         let cache = displayNameResStore.get(channelId);
  798.         let isStackNewRequest = false;
  799.  
  800.         /** @type {AsyncValue<DisplayNameResultObject> | null | undefined} */
  801.         let aResult;
  802.  
  803.         if (cache instanceof AsyncValue) {
  804.             aResult = cache;
  805.             if (aResult.fetchingState >= 2) {
  806.                 // aResult.fetchingState
  807.                 // 2: network fetch started
  808.                 // 3: network fetch ended
  809.                 // isStackNewRequest = false;
  810.             } else {
  811.                 // 0: invalid before
  812.                 // 1: scheduled but not yet fetch
  813.                 isStackNewRequest = true;
  814.             }
  815.         } else if (cache) {
  816.             // resolved result
  817.             return cache;
  818.         } else {
  819.             // else no cached value found
  820.             /** @type {AsyncValue<DisplayNameResultObject>} */
  821.             aResult = new AsyncValue();
  822.             displayNameResStore.set(channelId, aResult);
  823.             isStackNewRequest = true;
  824.         }
  825.  
  826.         if (isStackNewRequest) {
  827.             aResult.fetchingState = 1;
  828.             stackNewRequest(channelId);
  829.         }
  830.         return await aResult.getValue();
  831.     }
  832.  
  833.  
  834.     /**
  835.      *
  836.      * @param {string} href Example: https\:\/\/www\.youtube\.com/channel/UC0gmRdmpDWJ4dt7DAeRaawA
  837.      * @returns
  838.      */
  839.     const obtainChannelId = (href) => {
  840.         let m = /\/channel\/(UC[-_a-zA-Z0-9+=.]+)/.exec(`/${href}`);
  841.         // let m = /\/channel\/([^/?#\s]+)/.exec(`/${href}`);
  842.         return !m ? '' : (m[1] || '');
  843.     };
  844.  
  845.  
  846.     /**
  847.      *
  848.      * @param {Element} ytElm
  849.      */
  850.     const resetWhenDataChanged = (ytElm) => {
  851.         if (ytElm instanceof Element) {
  852.             const anchors = elementQSA(ytElm, 'a[id][href*="channel/"][jkrgy]');
  853.             if ((anchors || 0).length >= 1 && (ytElm.data || 0).jkrgx !== 1) {
  854.                 for (const anchor of anchors) {
  855.                     anchor.removeAttribute('jkrgy');
  856.                 }
  857.             }
  858.         }
  859.     }
  860.  
  861.     /**
  862.      *
  863.      * @param {Function} dataChanged original dataChanged function
  864.      * @returns new dataChanged function
  865.      */
  866.     const dataChangeFuncProducer = (dataChanged) => {
  867.         /** @this HTMLElement */
  868.         return function () {
  869.             resetWhenDataChanged(this);
  870.             return dataChanged.apply(this, arguments);
  871.         }
  872.     };
  873.  
  874.     /**
  875.      *
  876.      * @param {HTMLAnchorElement} anchor Example: https\:\/\/www\.youtube\.com/channel/UCRmLncxsQFcOOC8OhzUIfxQ/videos
  877.      * @param {string} channelHref Example: /channel/UCRmLncxsQFcOOC8OhzUIfxQ
  878.      * @param {string} channelId Example: UCRmLncxsQFcOOC8OhzUIfxQ
  879.      * @returns
  880.      */
  881.     const anchorIntegrityCheck = (anchor, channelHref, channelId) => {
  882.  
  883.         let currentHref = anchor.getAttribute('href');
  884.         if (currentHref === channelHref) return true; // /channel/UCRmLncxsQFcOOC8OhzUIfxQ // /channel/UCRmLncxsQFcOOC8OhzUIfxQ
  885.  
  886.         return (currentHref + '/').indexOf(channelHref + '/') >= 0;
  887.  
  888.     };
  889.  
  890.     /**
  891.      *
  892.      * @param {string} currentDisplayed
  893.      * @param {DisplayNameResultObject} fetchResult
  894.      * @returns
  895.      */
  896.     const verifyAndConvertHandle = (currentDisplayed, fetchResult) => {
  897.  
  898.         const { title, externalId, ownerUrls, channelUrl, vanityChannelUrl, verified123 } = fetchResult;
  899.  
  900.         const currentDisplayTrimmed = currentDisplayed.trim();
  901.         let match = false;
  902.         if (verified123) {
  903.             match = true;
  904.         } else if ((vanityChannelUrl || '').endsWith(`/${currentDisplayTrimmed}`)) {
  905.             match = true;
  906.         } else if ((ownerUrls || 0).length >= 1) {
  907.             for (const ownerUrl of ownerUrls) {
  908.                 if ((ownerUrl || '').endsWith(`/${currentDisplayTrimmed}`)) {
  909.                     match = true;
  910.                     break;
  911.                 }
  912.             }
  913.         }
  914.         if (match) {
  915.             return currentDisplayTrimmed;
  916.         }
  917.         return '';
  918.  
  919.     };
  920.  
  921.     /**
  922.      *
  923.      *
  924.  
  925.         ### [Handle naming guidelines](https://support.google.com/youtube/answer/11585688?hl=en&co=GENIE.Platform%3DAndroid)
  926.  
  927.         - Is between 3-30 characters
  928.         - Is made up of alphanumeric characters (A–Z, a–z, 0–9)
  929.         - Your handle can also include: underscores (_), hyphens (-), dots (.)
  930.         - Is not URL-like or phone number-like
  931.         - Is not already being used
  932.         - Follows YouTube's Community Guidelines
  933.  
  934.         ### Handle automatically generated by YouTube
  935.         - `@user-XXXX`
  936.         - without dot (.)
  937.      *
  938.      * @param {string} text
  939.      * @returns
  940.      */
  941.     const isDisplayAsHandle = (text) => {
  942.  
  943.         if (typeof text !== 'string') return false;
  944.         if (text.length < 4) return false;
  945.         if (text.indexOf('@') < 0) return false;
  946.         return /^\s*@[-_a-zA-Z0-9.]{3,30}\s*$/.test(text);
  947.  
  948.     };
  949.  
  950.     /**
  951.      *
  952.      * @param {Object[]} contentTexts
  953.      * @param {number} idx
  954.      * @returns
  955.      */
  956.     const contentTextProcess = (contentTexts, idx) => {
  957.         const contentText = contentTexts[idx];
  958.         const text = (contentText || 0).text;
  959.         const url = (((contentText.navigationEndpoint || 0).commandMetadata || 0).webCommandMetadata || 0).url;
  960.         if (typeof url === 'string' && typeof text === 'string') {
  961.  
  962.             if (!isDisplayAsHandle(text)) return null;
  963.             const channelId = obtainChannelId(url);
  964.  
  965.             return getDisplayName(channelId).then(fetchResult => {
  966.                 let resolveResult = null;
  967.                 if (fetchResult) {
  968.                     // note: if that user shown is not found in `a[id]`, the hyperlink would not change
  969.  
  970.                     const textTrimmed = verifyAndConvertHandle(text, fetchResult);
  971.                     if (textTrimmed) {
  972.                         resolveResult = (md) => {
  973.                             let runs = ((md || 0).contentText || 0).runs;
  974.                             if (!runs || !runs[idx]) return;
  975.                             if (runs[idx].text !== text) return;
  976.                             runs[idx].text = text.replace(textTrimmed, `@${fetchResult.title}`); // HyperLink always @SomeOne
  977.                             md.contentText = Object.assign({}, md.contentText);
  978.                         };
  979.                     }
  980.                 }
  981.                 return resolveResult; // function as a Promise
  982.             });
  983.         }
  984.  
  985.         return null;
  986.     };
  987.  
  988.     /**
  989.      *
  990.      * @param {ParentNode} parentNode
  991.      * @param {Function} callback
  992.      */
  993.     function findTextNodes(parentNode, callback) {
  994.         /**
  995.          *
  996.          * @param {Node} node
  997.          * @returns
  998.          */
  999.         function traverse(node) {
  1000.             if (node.nodeType === Node.TEXT_NODE) {
  1001.                 let r = callback(node);
  1002.                 if (r === true) return true;
  1003.             }
  1004.  
  1005.             let childNode = nodeFirstChild(node);
  1006.             while (childNode) {
  1007.                 let r = traverse(childNode);
  1008.                 if (r === true) return true;
  1009.                 childNode = nodeNextSibling(childNode);
  1010.             }
  1011.         }
  1012.  
  1013.         traverse(parentNode);
  1014.     }
  1015.  
  1016.     /**
  1017.      *
  1018.      * @param {ParentNode} parentNode
  1019.      * @param {Object[]} contentTexts
  1020.      * @param {number} aidx
  1021.      * @returns
  1022.      */
  1023.     const mobileContentHandleAsync = async (parentNode, contentTexts, aidx) => {
  1024.  
  1025.  
  1026.         let commentText = elementQS(parentNode, '.comment-text');
  1027.         if (!commentText) return;
  1028.         commentText = elementQS(commentText, '.yt-core-attributed-string') || commentText;
  1029.         let currentText = commentText.textContent;
  1030.         let textMatch = commentText.textContent === contentTexts.map(e => e.text).join('');
  1031.         if (!textMatch) return;
  1032.  
  1033.         const contentText = contentTexts[aidx];
  1034.  
  1035.         /** @type {string} */
  1036.         const handleText = contentText.text.trim();
  1037.         /** @type {string | null | undefined} */
  1038.         let channelId;
  1039.  
  1040.         let cache = handleToChannelId.get(handleText);
  1041.  
  1042.         if (typeof cache === 'string') {
  1043.             channelId = cache;
  1044.         } else if (cache instanceof AsyncValue) {
  1045.             channelId = await cache.getValue();
  1046.         } else {
  1047.             /** @type {AsyncValue<string>} */
  1048.             const asyncValue = new AsyncValue();
  1049.             handleToChannelId.set(handleText, asyncValue);
  1050.             channelId = await asyncValue.getValue();  // note: it could be never resolved
  1051.         }
  1052.  
  1053.         if (!channelId) return; // just in case
  1054.  
  1055.         if (commentText.isConnected !== true) return; // already removed
  1056.         if (commentText.textContent !== currentText) return; // already changed
  1057.  
  1058.         const fetchResult = await getDisplayName(channelId);
  1059.  
  1060.         if (fetchResult === null) return;
  1061.  
  1062.         const { title, externalId } = fetchResult;
  1063.         if (externalId !== channelId) return; // channel id must be the same
  1064.  
  1065.         let search = contentText.text;
  1066.         if (typeof search === 'string') {
  1067.  
  1068.             const searchTrimmed = search.trim();
  1069.             if (searchTrimmed === handleText) { // ensure integrity after getDisplayName
  1070.                 contentText.text = search.replace(searchTrimmed, "@" + title);
  1071.  
  1072.                 findTextNodes(commentText, (textnode) => {
  1073.                     if (textnode.nodeValue.indexOf(search) >= 0) {
  1074.                         textnode.nodeValue = textnode.nodeValue.replace(search, contentText.text);
  1075.                         return true;
  1076.                     }
  1077.                 });
  1078.             }
  1079.  
  1080.         }
  1081.  
  1082.     }
  1083.  
  1084.     /**
  1085.      * Process Checking when there is new (unprocessed) anchor DOM element with hyperlink of channel
  1086.      * @type { (anchor: HTMLElement, channelHref: string?, mt: string?) => Promise<void> }
  1087.      */
  1088.     const domCheckAsync = isMobile ? async (anchor, channelHref, mt) => {
  1089.  
  1090.         try {
  1091.             if (!channelHref || !mt) return;
  1092.             let parentNode = nodeParent(anchor);
  1093.             while (parentNode instanceof Node) {
  1094.                 if (parentNode.nodeName === 'YTM-COMMENT-RENDERER' || ('_commentData' in parentNode)) break;
  1095.                 parentNode = nodeParent(parentNode);
  1096.             }
  1097.             if (parentNode instanceof Node) { } else return;
  1098.  
  1099.             let displayTextDOM = elementQS(parentNode, '.comment-header .comment-title');
  1100.             if (!displayTextDOM) return;
  1101.             displayTextDOM = elementQS(displayTextDOM, '.yt-core-attributed-string') || displayTextDOM;
  1102.             let airaLabel = anchor.getAttribute('aria-label')
  1103.             const parentNodeData = parentNode.data;
  1104.             let runs = ((parentNodeData || 0).authorText || 0).runs;
  1105.  
  1106.             if (displayTextDOM && airaLabel && displayTextDOM.textContent.trim() === airaLabel.trim() && isDisplayAsHandle(airaLabel) && runs && (runs[0] || 0).text === airaLabel) {
  1107.  
  1108.                 if (!channelIdToHandle.has(mt)) {
  1109.                     channelIdToHandle.set(mt, {
  1110.                         handleText: airaLabel.trim(),
  1111.                         justPossible: true
  1112.                     })
  1113.                 }
  1114.  
  1115.                 const fetchResult = await getDisplayName(mt);
  1116.  
  1117.                 if (fetchResult === null) return;
  1118.  
  1119.                 const { title, externalId } = fetchResult;
  1120.  
  1121.                 if (externalId !== mt) return; // channel id must be the same
  1122.  
  1123.                 // anchor href might be changed by external
  1124.                 if (!anchorIntegrityCheck(anchor, channelHref, externalId)) return;
  1125.  
  1126.                 let found = false;
  1127.  
  1128.                 findTextNodes(displayTextDOM, (textnode) => {
  1129.                     if (textnode.nodeValue === airaLabel) {
  1130.                         textnode.nodeValue = title;
  1131.                         found = true;
  1132.                         return true;
  1133.                     }
  1134.                 });
  1135.  
  1136.                 if (!found) return;
  1137.                 anchor.setAttribute('aria-label', title);
  1138.                 runs[0].text = title;
  1139.  
  1140.  
  1141.                 const contentTexts = (parentNodeData.contentText || 0).runs;
  1142.                 if (contentTexts && contentTexts.length >= 2) {
  1143.                     for (let aidx = 0; aidx < contentTexts.length; aidx++) {
  1144.                         const contentText = contentTexts[aidx] || 0;
  1145.                         if (contentText.italics !== true) {
  1146.                             let isHandle = isDisplayAsHandle(contentText.text);
  1147.                             if (isHandle) {
  1148.                                 mobileContentHandleAsync(parentNode, contentTexts, aidx);
  1149.                             }
  1150.                         }
  1151.                     }
  1152.                 }
  1153.  
  1154.             }
  1155.         } catch (e) {
  1156.             console.warn(e);
  1157.         }
  1158.  
  1159.     } : async (anchor, channelHref, mt) => {
  1160.  
  1161.         try {
  1162.             if (!channelHref || !mt) return;
  1163.             let parentNode = nodeParent(anchor);
  1164.             while (parentNode instanceof Node) {
  1165.                 if (typeof parentNode.is === 'string' && typeof parentNode.dataChanged === 'function') break;
  1166.                 parentNode = nodeParent(parentNode);
  1167.             }
  1168.             if (parentNode instanceof Node) { } else return;
  1169.             const authorText = (parentNode.data || 0).authorText;
  1170.             const currentDisplayed = (authorText || 0).simpleText;
  1171.             if (typeof currentDisplayed !== 'string') return;
  1172.             if (!isDisplayAsHandle(currentDisplayed)) return;
  1173.  
  1174.             if (!channelIdToHandle.has(mt)) {
  1175.                 channelIdToHandle.set(mt, {
  1176.                     handleText: currentDisplayed.trim(),
  1177.                     justPossible: true
  1178.                 })
  1179.             }
  1180.  
  1181.             const oldDataChanged = parentNode.dataChanged;
  1182.             if (typeof oldDataChanged === 'function' && !oldDataChanged.jkrgx) {
  1183.                 let newDataChanged = dataChangedFuncStore.get(oldDataChanged);
  1184.                 if (!newDataChanged) {
  1185.                     newDataChanged = dataChangeFuncProducer(oldDataChanged);
  1186.                     newDataChanged.jkrgx = 1;
  1187.                     dataChangedFuncStore.set(oldDataChanged, newDataChanged);
  1188.                 }
  1189.                 parentNode.dataChanged = newDataChanged;
  1190.             }
  1191.  
  1192.             const fetchResult = await getDisplayName(mt);
  1193.  
  1194.             if (fetchResult === null) return;
  1195.  
  1196.             const { title, externalId } = fetchResult;
  1197.  
  1198.             if (externalId !== mt) return; // channel id must be the same
  1199.  
  1200.             // anchor href might be changed by external
  1201.             if (!anchorIntegrityCheck(anchor, channelHref, externalId)) return;
  1202.  
  1203.             const parentNodeData = parentNode.data;
  1204.             const funcPromises = [];
  1205.  
  1206.             if (parentNode.isAttached === true && parentNode.isConnected === true && typeof parentNodeData === 'object' && parentNodeData && parentNodeData.authorText === authorText) {
  1207.  
  1208.                 if (authorText.simpleText !== currentDisplayed) return;
  1209.                 const currentDisplayTrimmed = verifyAndConvertHandle(currentDisplayed, fetchResult);
  1210.                 const cSimpleText = ((parentNodeData.authorText || 0).simpleText || '');
  1211.                 if (currentDisplayTrimmed && currentDisplayed !== title && cSimpleText === currentDisplayed) {
  1212.  
  1213.                     // the inside hyperlinks will be only converted if its parent author name is handle
  1214.                     const contentTexts = (parentNodeData.contentText || 0).runs;
  1215.                     if (contentTexts && contentTexts.length >= 1) {
  1216.                         for (let aidx = 0; aidx < contentTexts.length; aidx++) {
  1217.                             const r = contentTextProcess(contentTexts, aidx);
  1218.                             if (r instanceof Promise) funcPromises.push(r);
  1219.                         }
  1220.                     }
  1221.  
  1222.                     const md = Object.assign({}, parentNodeData);
  1223.                     let setBadge = false;
  1224.                     if (((((md.authorCommentBadge || 0).authorCommentBadgeRenderer || 0).authorText || 0).simpleText || '').trim() === cSimpleText.trim()) {
  1225.                         setBadge = true;
  1226.                     }
  1227.                     // parentNode.data = Object.assign({}, { jkrgx: 1 });
  1228.                     md.authorText = Object.assign({}, md.authorText, { simpleText: currentDisplayed.replace(currentDisplayTrimmed, title) });
  1229.                     if (setBadge) {
  1230.                         md.authorCommentBadge = Object.assign({}, md.authorCommentBadge);
  1231.                         md.authorCommentBadge.authorCommentBadgeRenderer = Object.assign({}, md.authorCommentBadge.authorCommentBadgeRenderer);
  1232.                         md.authorCommentBadge.authorCommentBadgeRenderer.authorText = Object.assign({}, md.authorCommentBadge.authorCommentBadgeRenderer.authorText, { simpleText: title });
  1233.  
  1234.                     }
  1235.                     if (funcPromises.length >= 1) {
  1236.                         let funcs = await Promise.all(funcPromises);
  1237.  
  1238.                         for (const func of funcs) {
  1239.                             if (typeof func === 'function') {
  1240.                                 func(md);
  1241.                             }
  1242.                         }
  1243.                     }
  1244.                     parentNode.data = Object.assign({}, md, { jkrgx: 1 });
  1245.  
  1246.  
  1247.                 }
  1248.  
  1249.             }
  1250.         } catch (e) {
  1251.             console.warn(e);
  1252.         }
  1253.  
  1254.     }
  1255.  
  1256.     /**
  1257.      *
  1258.      * @param {string} url
  1259.      * @returns
  1260.      */
  1261.     const channelUrlUnify = (url) => {
  1262.  
  1263.         if (typeof url !== 'string') return url; // type unchanged
  1264.         let c0 = url.charAt(0);
  1265.         if (c0 === '/') return url;
  1266.         let i = url.indexOf('.youtube.com/');
  1267.         if (i >= 1) url = url.substring(i + '.youtube.com/'.length - 1);
  1268.         else if (url.charAt(0) !== '/') url = '/' + url;
  1269.         return url
  1270.  
  1271.     }
  1272.  
  1273.     const parentYtElement = (node, nodeName, maxN) => {
  1274.         for (let pDom = nodeParent(node); (pDom instanceof HTMLElement) && maxN-- > 0; pDom = nodeParent(pDom)) {
  1275.             if (pDom.nodeName === nodeName) {
  1276.                 return pDom;
  1277.             }
  1278.         }
  1279.         return null;
  1280.     }
  1281.  
  1282.     const checkShortsChannelName = (rchannelNameDOM) => {
  1283.         let browseId = '';
  1284.         const pDom = parentYtElement(rchannelNameDOM, 'YTD-REEL-PLAYER-HEADER-RENDERER', 18);
  1285.  
  1286.         if (pDom instanceof HTMLElement) {
  1287.             const runs = (((pDom.data || 0).channelTitleText || 0).runs || 0);
  1288.             if (runs.length === 1) {
  1289.                 const browserEndpoint = (((runs[0] || 0).navigationEndpoint || 0).browseEndpoint || 0);
  1290.                 browseId = (browserEndpoint.browseId || '');
  1291.                 const currentDisplayText = runs[0].text || ''
  1292.  
  1293.                 if (/^UC[-_a-zA-Z0-9+=.]+$/.test(browseId) && isDisplayAsHandle(currentDisplayText)) {
  1294.  
  1295.                     if (!channelIdToHandle.has(browseId)) {
  1296.                         channelIdToHandle.set(browseId, {
  1297.                             handleText: currentDisplayText.trim(),
  1298.                             justPossible: true
  1299.                         })
  1300.                     }
  1301.  
  1302.  
  1303.                     // let anchorNode = elementQS(rchannelNameDOM, `a[href="${browserEndpoint.canonicalBaseUrl}"]`);
  1304.                     // anchorNode && anchorNode.setAttribute('jkrgy', browseId); // for checking
  1305.                     // anchorNode && 
  1306.                     getDisplayName(browseId).then(fetchResult => {
  1307.  
  1308.                         if (fetchResult === null) return;
  1309.  
  1310.                         const { title, externalId } = fetchResult;
  1311.                         if (externalId !== browseId) return; // channel id must be the same
  1312.  
  1313.                         let hDom = pDom;
  1314.                         let hData = (hDom || 0).data || 0;
  1315.                         const runs = (((hData || 0).channelTitleText || 0).runs || 0);
  1316.                         if (runs && runs.length === 1 && (runs[0] || 0).text === currentDisplayText) {
  1317.  
  1318.                             let runs2 = [Object.assign({}, runs[0], { text: title })];
  1319.  
  1320.  
  1321.                             /*
  1322.                             runs.push({text: title, bold: true, "fontColor": "black",
  1323.  
  1324.                         size: "SIZE_DEFAULT",
  1325.                         style: "STYLE_TEXT",
  1326.                                       });
  1327.                             */
  1328.  
  1329.                             hDom.data = Object.assign({}, hDom.data, { channelTitleText: { runs: runs2 }, rSk0e: 1 });
  1330.  
  1331.                             byPassCheckStore.delete(rchannelNameDOM);
  1332.                         }
  1333.  
  1334.  
  1335.  
  1336.                     })
  1337.                 }
  1338.  
  1339.  
  1340.             }
  1341.         }
  1342.         return browseId
  1343.     }
  1344.  
  1345.     let firstDOMCheck = false;
  1346.     const firstDOMChecker = isMobile ? () => {
  1347.  
  1348.         const channelNameDOM = document.querySelector('ytm-slim-owner-renderer');
  1349.         const channelNameDOMData = (channelNameDOM || 0).data;
  1350.  
  1351.         if (channelNameDOMData) {
  1352.             let mainChannelUrl = null;
  1353.             let mainFormattedNameUrl = null;
  1354.             let mainChannelText = null;
  1355.             let mainFormattedNameText = null;
  1356.  
  1357.             try {
  1358.                 mainChannelUrl = channelUrlUnify(channelNameDOMData.channelUrl)
  1359.                 mainFormattedNameUrl = channelUrlUnify(channelNameDOMData.title.runs[0].navigationEndpoint.browseEndpoint.canonicalBaseUrl)
  1360.                 mainChannelText = channelNameDOMData.channelName
  1361.                 mainFormattedNameText = channelNameDOMData.title.runs[0].text
  1362.             } catch (e) { }
  1363.  
  1364.             if (mainChannelUrl === mainFormattedNameUrl && mainChannelText === mainFormattedNameText && typeof mainChannelUrl === 'string' && typeof mainChannelText === 'string') {
  1365.  
  1366.  
  1367.                 let channelId = obtainChannelId(mainChannelUrl);
  1368.                 if (channelId) {
  1369.                     if (mainChannelText.startsWith('@')) return;
  1370.                     if (mainChannelText.trim() !== mainChannelText) return;
  1371.  
  1372.                     displayNameResStore.set(channelId, {
  1373.                         channelUrl: `https://www.youtube.com/channel/${channelId}`,
  1374.                         externalId: `${channelId}`,
  1375.                         ownerUrls: [],
  1376.                         title: mainChannelText,
  1377.                         vanityChannelUrl: null,
  1378.                         verified123: true
  1379.                     });
  1380.                 }
  1381.  
  1382.  
  1383.             }
  1384.         }
  1385.  
  1386.     } : () => {
  1387.  
  1388.         const channelNameDOM = document.querySelector('ytd-channel-name.ytd-video-owner-renderer');
  1389.         const channelNameDOMData = (channelNameDOM || 0).__data;
  1390.         if (channelNameDOMData) {
  1391.             let mainChannelUrl = null;
  1392.             let mainFormattedNameUrl = null;
  1393.             let mainChannelText = null;
  1394.             let mainFormattedNameText = null;
  1395.  
  1396.             try {
  1397.                 mainChannelUrl = channelNameDOMData.channelName.runs[0].navigationEndpoint.browseEndpoint.canonicalBaseUrl
  1398.                 mainFormattedNameUrl = channelNameDOMData.formattedName.runs[0].navigationEndpoint.browseEndpoint.canonicalBaseUrl
  1399.                 mainChannelText = channelNameDOMData.channelName.runs[0].text
  1400.                 mainFormattedNameText = channelNameDOMData.formattedName.runs[0].text
  1401.             } catch (e) { }
  1402.  
  1403.             if (mainChannelUrl === mainFormattedNameUrl && mainChannelText === mainFormattedNameText && typeof mainChannelUrl === 'string' && typeof mainChannelText === 'string') {
  1404.  
  1405.                 let m = /^\/(@[-_a-zA-Z0-9.]{3,30})$/.test(mainChannelUrl);
  1406.  
  1407.                 if (m && m[1] && mainChannelText !== m[1]) {
  1408.  
  1409.                     let channelId = obtainChannelId(mainChannelUrl);
  1410.                     if (channelId) {
  1411.                         if (mainChannelText.startsWith('@')) return;
  1412.                         if (mainChannelText.trim() !== mainChannelText) return;
  1413.  
  1414.                         displayNameResStore.set(channelId, {
  1415.                             channelUrl: `https://www.youtube.com/channel/${channelId}`,
  1416.                             externalId: `${channelId}`,
  1417.                             ownerUrls: [],
  1418.                             title: mainChannelText,
  1419.                             vanityChannelUrl: null,
  1420.                             verified123: true
  1421.                         });
  1422.                     }
  1423.  
  1424.                 }
  1425.             }
  1426.         }
  1427.  
  1428.     };
  1429.  
  1430.     // let newAnchorAdded = false;
  1431.     /*
  1432.  
  1433.     const intersectionobserver = new IntersectionObserver((entries) => {
  1434.         let anchorAppear = false;
  1435.         for (const entry of entries) {
  1436.             if (entry.isIntersecting === true) {
  1437.                 anchorAppear = true;
  1438.                 break;
  1439.             }
  1440.         }
  1441.         if (anchorAppear && newAnchorAdded) {
  1442.             newAnchorAdded = false; // stacking will be only reset when one or more anchor added to DOM.
  1443.             mutex.nextIndex = 0; // higher pirority for new elements being shown
  1444.         }
  1445.     }, {
  1446.         rootMargin:"0px 0px 0px 0px",
  1447.         threshold:1
  1448.     })
  1449.     */
  1450.  
  1451.  
  1452.     /* globals WeakRef:false */
  1453.  
  1454.     /** @type {(o: Object | null) => WeakRef | null} */
  1455.     const mWeakRef = typeof WeakRef === 'function' ? (o => o ? new WeakRef(o) : null) : (o => o || null); // typeof InvalidVar == 'undefined'
  1456.  
  1457.     /** @type {(wr: Object | null) => Object | null} */
  1458.     const kRef = (wr => (wr && wr.deref) ? wr.deref() : wr);
  1459.  
  1460.     let doShortsChecking = false;
  1461.  
  1462.     let lastNewAnchorLastWR = null;
  1463.  
  1464.     let domCheckTimeStamp = 0;
  1465.  
  1466.     const mutexForDOMMutations = new Mutex();
  1467.  
  1468.     const byPassCheckStore = new WeakSet();
  1469.  
  1470.     const mutObserverForShortsChannelName = new MutationObserver((mutations) => {
  1471.         for (const mutation of mutations) {
  1472.             const target = mutation.target;
  1473.             if (!target) continue;
  1474.             const rchannelName = parentYtElement(target, 'YTD-CHANNEL-NAME', 18);
  1475.             if (!rchannelName) continue;
  1476.             if ((rchannelName.data || 0).rSk0e) continue;
  1477.             const channelId = rchannelName.getAttribute('jkrgy');
  1478.             if (channelId) {
  1479.                 if (byPassCheckStore.has(rchannelName)) continue;
  1480.                 const object = channelIdToHandle.get(channelId);
  1481.                 if (object && object.handleText && !object.justPossible) {
  1482.                     const textDom = ((rchannelName.$ || 0).text || 0);
  1483.                     if (textDom) {
  1484.                         let t = textDom.textContent.trim()
  1485.                         if (t === object.handleText || t === '') {
  1486.                             rchannelName.removeAttribute('jkrgy');
  1487.                         }
  1488.                     }
  1489.                 }
  1490.             }
  1491.         }
  1492.     })
  1493.  
  1494.     let domCheckScheduledForShorts = false;
  1495.     const domCheckSelectorForShorts = [
  1496.         'ytd-channel-name.ytd-reel-player-header-renderer:not([jkrgy]) a.yt-simple-endpoint[href]'
  1497.     ].join(', ');
  1498.     const domCheckerForShorts = () => {
  1499.  
  1500.         if (domCheckScheduledForShorts) return;
  1501.         if (document.querySelector(domCheckSelectorForShorts) === null) {
  1502.             return;
  1503.         }
  1504.         domCheckScheduledForShorts = true;
  1505.  
  1506.         mutexForDOMMutations.lockWith(lockResolve => {
  1507.  
  1508.  
  1509.             // setTimeout(()=>{ // delay due to data update is after [is-active] switching
  1510.  
  1511.  
  1512.             domCheckScheduledForShorts = false;
  1513.  
  1514.             const nodes = document.querySelectorAll(domCheckSelectorForShorts);
  1515.             if (nodes.length === 0) {
  1516.                 lockResolve();
  1517.                 return;
  1518.             }
  1519.  
  1520.             for (const node of nodes) {
  1521.  
  1522.                 const rchannelName = parentYtElement(node, 'YTD-CHANNEL-NAME', 18);
  1523.                 if (rchannelName) {
  1524.                     mutObserverForShortsChannelName.observe(rchannelName, {
  1525.                         childList: true,
  1526.                         subtree: true
  1527.                     });
  1528.                     let channelId = '';
  1529.                     byPassCheckStore.add(rchannelName);
  1530.                     channelId = checkShortsChannelName(rchannelName);
  1531.                     rchannelName.setAttribute('jkrgy', channelId || '');
  1532.                 }
  1533.  
  1534.             }
  1535.  
  1536.             lockResolve();
  1537.  
  1538.             // }, 80);
  1539.  
  1540.  
  1541.         })
  1542.  
  1543.     }
  1544.  
  1545.     let domCheckScheduled = false;
  1546.     const domCheckSelector = isMobile ? 'a[aria-label^="@"][href*="channel/"]:not([jkrgy])' : 'a[id][href*="channel/"]:not([jkrgy])';
  1547.     const domChecker = () => {
  1548.  
  1549.         doShortsChecking && domCheckerForShorts();
  1550.  
  1551.         if (domCheckScheduled) return;
  1552.         if (document.querySelector(domCheckSelector) === null) {
  1553.             return;
  1554.         }
  1555.         domCheckScheduled = true;
  1556.  
  1557.         mutexForDOMMutations.lockWith(lockResolve => {
  1558.             domCheckScheduled = false;
  1559.  
  1560.             const newAnchors = document.querySelectorAll(domCheckSelector);
  1561.             if (newAnchors.length === 0) {
  1562.                 lockResolve();
  1563.                 return;
  1564.             }
  1565.  
  1566.             const cNewAnchorFirst = newAnchors[0]; // non-null
  1567.             const cNewAnchorLast = newAnchors[newAnchors.length - 1]; // non-null
  1568.             /** @type {HTMLElement | null} */
  1569.             const lastNewAnchorLast = kRef(lastNewAnchorLastWR); // HTMLElement | null
  1570.             lastNewAnchorLastWR = mWeakRef(cNewAnchorLast);
  1571.  
  1572.             const ltDOMCheck = domCheckTimeStamp;
  1573.             const ctDOMCheck = Date.now();
  1574.             domCheckTimeStamp = ctDOMCheck;
  1575.  
  1576.             if (!firstDOMCheck) {
  1577.                 firstDOMCheck = true;
  1578.                 USE_CHANNEL_META && firstDOMChecker();
  1579.             }
  1580.  
  1581.             const isDocumentModifying = ctDOMCheck - ltDOMCheck < 230;
  1582.  
  1583.             Promise.resolve()
  1584.                 .then(() => {
  1585.                     if (lastNewAnchorLast && mutex.nextIndex >= 1) {
  1586.  
  1587.                         if (isDocumentModifying) {
  1588.  
  1589.                         } else {
  1590.                             if ((lastNewAnchorLast.compareDocumentPosition(cNewAnchorFirst) & 2) === 2) {
  1591.                                 mutex.nextIndex = 0;
  1592.                             }
  1593.                         }
  1594.  
  1595.                         /*
  1596.                         if (mutex.nextIndex === 0) {
  1597.                             // no change
  1598.                         } else if ((lastNewAnchorLast.compareDocumentPosition(cNewAnchorLast) & 2) === 2) { // when "XX replies" clicked
  1599.                             mutex.nextIndex = 0; // highest priority
  1600.                         } else if (cNewAnchorLast !== cNewAnchorFirst && (lastNewAnchorLast.compareDocumentPosition(cNewAnchorFirst) & 2) === 1) { // rarely
  1601.                             mutex.nextIndex = Math.floor(mutex.nextIndex / 2); // relatively higher priority
  1602.                         }
  1603.                         */
  1604.                     }
  1605.                 }).then(() => {
  1606.  
  1607.                     // newAnchorAdded = true;
  1608.                     for (const anchor of newAnchors) {
  1609.                         // author-text or name
  1610.                         // normal url: /channel/xxxxxxx
  1611.                         // Improve YouTube! - https://www.youtube.com/channel/xxxxxxx/videos
  1612.                         const href = anchor.getAttribute('href');
  1613.                         const channelId = obtainChannelId(href); // string, can be empty
  1614.                         anchor.setAttribute('jkrgy', channelId);
  1615.                         // intersectionobserver.unobserve(anchor);
  1616.                         // intersectionobserver.observe(anchor); // force first occurance
  1617.                         domCheckAsync(anchor, href, channelId);
  1618.                     }
  1619.  
  1620.                 }).then(lockResolve).catch(e => {
  1621.                     lockResolve();
  1622.                     console.warn(e);
  1623.                 });
  1624.  
  1625.         });
  1626.  
  1627.  
  1628.     };
  1629.  
  1630.  
  1631.     /** @type {MutationObserver | null} */
  1632.     let domObserver = null;
  1633.  
  1634.     /** @type {(callback: (event: Event)=>{})} */
  1635.     const onPageFetched = isMobile ? (callback) => {
  1636.  
  1637.         let state = 0;
  1638.  
  1639.         window.addEventListener('state-change', function (evt) {
  1640.             if (state === 1) return; // ignore intermediate events
  1641.             state = 1; // before value: 0 or 2;
  1642.             callback(evt);
  1643.         }, false);
  1644.  
  1645.         window.addEventListener('state-navigateend', function (evt) { // fallback
  1646.             let inSeq = state === 1;
  1647.             state = 2; // 2 when loaded
  1648.             if (!inSeq) callback(evt);
  1649.         }, false);
  1650.  
  1651.     } : (callback) => {
  1652.  
  1653.         let state = 0;
  1654.  
  1655.         document.addEventListener('yt-page-data-fetched', function (evt) {
  1656.             if (state === 1) return; // ignore intermediate events if any
  1657.             state = 1; // before value: 0 or 2;
  1658.             callback(evt);
  1659.         }, false);
  1660.  
  1661.         document.addEventListener('yt-navigate-finish', function (evt) { // fallback
  1662.             let inSeq = state === 1;
  1663.             state = 2; // 2 when loaded
  1664.             if (!inSeq) callback(evt);
  1665.         }, false);
  1666.  
  1667.     };
  1668.  
  1669.     /**
  1670.      *
  1671.      * @param {Node} app
  1672.      * @returns
  1673.      */
  1674.     function setupOnPageFetched(app) {
  1675.  
  1676.         firstDOMCheck = false;
  1677.  
  1678.         if (!cfg['INNERTUBE_API_KEY']) {
  1679.             console.warn("Userscript Error: INNERTUBE_API_KEY is not found.");
  1680.             return;
  1681.         }
  1682.  
  1683.         if (CHANGE_FOR_SHORTS_CHANNEL_NAME && location.pathname.startsWith('/shorts/')) {
  1684.             doShortsChecking = true;
  1685.         } else {
  1686.             doShortsChecking = false;
  1687.         }
  1688.  
  1689.         if (!domObserver) {
  1690.             domObserver = new MutationObserver(domChecker);
  1691.         } else {
  1692.             domObserver.takeRecords();
  1693.             domObserver.disconnect();
  1694.         }
  1695.  
  1696.         domObserver.observe(app, { childList: true, subtree: true });
  1697.         domChecker();
  1698.  
  1699.     }
  1700.  
  1701.     /**
  1702.      *
  1703.      * @param {Object|null} dest
  1704.      * @param {Object} ytcfg
  1705.      * @param {string[]} keys
  1706.      * @returns
  1707.      */
  1708.     function getYtConfig(dest, ytcfg, keys) {
  1709.         dest = dest || {};
  1710.         if (typeof ytcfg.get === 'function') { // mobile
  1711.             for (const key of keys) {
  1712.                 dest[key] = ytcfg.get(key);
  1713.             }
  1714.         } else {
  1715.             const cfgData = ytcfg.data_ || ytcfg.__data || ytcfg._data || ytcfg.data || ytcfg; // dekstop - ytcfg.data_
  1716.             for (const key of keys) {
  1717.                 dest[key] = cfgData[key];
  1718.             }
  1719.         }
  1720.         return dest;
  1721.     }
  1722.  
  1723.     /** @type { (evt: Object) => Element | null } */
  1724.     const getPageApp = isMobile
  1725.         ? ((evt) => (document.querySelector('ytm-app#app') || document.querySelector('ytm-app')))
  1726.         : ((evt) => ((evt || 0).target || document.querySelector('ytd-app')));
  1727.  
  1728.     onPageFetched(async (evt) => {
  1729.         const app = getPageApp(evt);
  1730.         console.assert(app);
  1731.         const ytcfg = ((window || 0).ytcfg || 0);
  1732.         getYtConfig(cfg, ytcfg, ['INNERTUBE_API_KEY', 'INNERTUBE_CLIENT_VERSION']);
  1733.         setupOnPageFetched(app);
  1734.     });
  1735.  
  1736. })({ Promise, fetch, JSON, Request, AbortController, setTimeout, clearTimeout });