!function() {

  // https://www.youtube.com/s/desktop/28b0985e/jsbin/desktop_polymer.vflset/desktop_polymer.js

  /*
  var Lx = function(a) {
    this.event = a
};
*/

/*

    if (window.ShadyDOM && window.ShadyDOM.inUse && window.ShadyDOM.noPatch && window.ShadyDOM.Wrapper) {
        var NUa = window.ShadyDOM.Wrapper
          , OUa = function() {  // MUa
            return NUa.apply(this, arguments) || this  
        };
*/
       

/*

CP = new WeakMap();

Ki = {
  cancelDebouncedJobMap: new WeakMap(),
  cancelThrottledJobMap: new WeakMap(),
}

*/


/*

// psudeo element
    function kD(a) {
        return a instanceof lD ? a : new lD(a)
    }

    */



    var addToPool = function(element) { // Fib
        const componentName = element.is;
        if (componentName) {
            let pool = Cib.get(componentName);
            if (!pool) {
                pool = [];
                Cib.set(componentName, pool);
            }
            const poolConfig = getConfigEntry("ELEMENT_POOL_CONFIG") || {};
            let poolCap = poolConfig[componentName];
            if (void 0 === poolCap) {
                poolCap = sl("ELEMENT_POOL_DEFAULT_CAP", 0);
            }
            if (pool.length < poolCap) pool.push(element);
        } else
            zq(new Cm("Element pool should only handle custom elements:",element.nodeName))
    }


  /**
   * @param {string} componentName
   * @param {Element} elementNode
   * @param {boolean} isCustomCreation
   * @return {undefined}
   */
  function removeRendererStamper(componentName, elementNode, isCustomCreation) { // zUb
    if (isCustomCreation) {
      if (elementNode.is) {
        if (DP.has(elementNode)) {
          let options = DP.get(elementNode);
          let item = options.listener;
          delete elementNode[options.property];
          if ("element" === item.type) {
            elementNode.removeEventListener(item.eventName, item.handler);
          } else {
            if ("polymer" === item.type) {
              elementNode.unlisten(elementNode, item.eventName, item.methodName);
            }
          }
          DP.delete(elementNode);
        }
        addToPool(elementNode);
      } else {
        if (elementNode.__proto__ == HTMLElement.prototype) {
          elementNode = new Cm("Rendererstamper removed a non custom element", "Stamper: " + componentName + " element: " + (elementNode && elementNode.nodeName));
          zq(elementNode);
        }
      }
    }
  }


  var ytConfigData = yt.config_; // ql

  /**
   * @param {Text} componentName
   * @param {Node} parentNode
   * @param {Object} node
   * @param {boolean} isCustomCreation
   * @return {undefined}
   */
  function remove(componentName, parentNode, node, isCustomCreation) { // AUb
    var root = parentNode.node ? parentNode.node : parentNode;
    if (kD(node).parentNode === root) {
      parentNode.removeChild(node);
      removeRendererStamper(componentName, node, isCustomCreation);
    }
    let handler = CP.get(node);
    if (handler) {
      CP.delete(node);
      Ki.cancelJob(handler);
    }
    /** @type {boolean} */
    node.hidden = false;
  }
  /**
   * @param {string} name
   * @param {boolean} def
   * @return {any}
   */
  function getConfigEntry(name, def) { // sl
    return name in ytConfigData ? ytConfigData[name] : def;
  }
  /**
   * @param {string} name
   * @param {boolean} def
   * @return {boolean}
   */
  function hasConfigEntry(name, def) { // tl
    return !!getConfigEntry(name, def);
  }
  /**
   * @param {Object} obj
   * @param {Object} context
   * @return {string | null}
   */
  function getObjectTag(obj, context) { // vUb
    var key;
    for (key in obj) {
      if (obj.hasOwnProperty(key) && context[key]) {
        return key;
      }
    }
    return null;
  }
  /**
   * @param {any} val
   * @return {?}
   */
  function isReusedVal(val) { // yUb
      if (void 0 === val) {
          if (H("kevlar_tuner_should_test_reuse_components")) {
              return H("kevlar_tuner_should_reuse_components");
          } else {
              return hasConfigEntry("REUSE_COMPONENTS", false);
          }
      }
    return  val || false;
  }
  /**
   * @param {string} componentName
   * @param {Element} parent
   * @param {number} idx
   * @param {boolean} isCustomCreation
   * @return {undefined}
   */
  function removeAfterChildIdx(componentName, parent, idx, isCustomCreation) { // BUb
    if (!parent) return;
    if (!parent.children) return;
    /** @type {Element} */
    var child = parent.children[idx];
    if (child) {
      if (hasConfigEntry("DEFERRED_DETACH")) {
        for (; child && !CP.has(child); child = child.nextElementSibling) {
          /** @type {Object} */
          var node = child;
          /** @type {boolean} */
          node.hidden = true;
          var pdataOld = Gm(Ki, remove.bind(null, componentName, parent, node, isCustomCreation), 0);
          CP.set(node, pdataOld);
        }
      } else {
        for (; (node = parent.lastElementChild);) {
          parent.removeChild(node);
          removeRendererStamper(componentName, node, isCustomCreation);
          if (node == child) break;
        }
      }
    }
  }
  /**
   * @param {EventTarget} target
   * @param {string} evtType
   * @param {any} detail
   * @param {Object} eventOptions
   * @return {?}
   */
  function dispatchCustomEvent(target, evtType, detail, eventOptions) { // Xz
    if (!eventOptions) {
      eventOptions = {
        bubbles : true,
        cancelable : false,
        composed : true
      };
    }
    if (null !== detail) {
      if (void 0 !== detail) {
        /** @type {number} */
        eventOptions.detail = detail;
      }
    }
    /** @type {CustomEvent} */
    evtType = new CustomEvent(evtType, eventOptions);
    target.dispatchEvent(evtType);
    return evtType;
  }
  /**
   * @param {Element} elem
   * @return {?}
   */
  var getDomApi = function(elem) { // Mx
    elem = elem || document;
    if (elem instanceof MUa) {
      return elem;
    }
    if (elem instanceof Lx) {
      return elem;
    }
    var obj = elem.__domApi;
    if (!obj) {
      if (elem instanceof Event) {
        obj = new Lx(elem);
      } else {
        obj = new MUa(elem);
      }
      elem.__domApi = obj;
    }
    return obj;
  };

  const stableListKey1 = "kevlar_tuner_should_test_maintain_stable_list";
  const stableListKey2 = "kevlar_should_maintain_stable_list";
  window.myFuncs = {
    /**
     * @param {(Array<>|null)} dataArray
     * @param {string} containerId
     * @param {Object} childComponents
     * @param {boolean} isCustomCreation
     * @param {boolean} toDispatchFinished
     * @param {boolean} isStableList
     * @return {undefined}
     */
    stampDomArray_ : function(dataArray, containerId, childComponents, isCustomCreation, toDispatchFinished, isStableList) {
      var container = this.getStampContainer_(containerId);
      if (container) {
        let nativeElement = getDomApi(container)
        isCustomCreation = isReusedVal(isCustomCreation)
        if (dataArray) {
          /** @type {number} */
          let counter = 0;
          /** @type {number} */
          var idx = 0;
          var child;
          if (void 0 === isStableList) {
            isStableList = H(stableListKey1) ? H(stableListKey2) : hasConfigEntry("STAMPER_STABLE_LIST", false)
          } else {
            isStableList = isStableList || false;
          }
          if (isStableList) {
            for (child = nativeElement.firstElementChild;child && (!CP.has(child) && dataArray.length > idx);) {
              let dataEntry = dataArray[idx];
              let objectTag = getObjectTag(childComponents, dataEntry);
              if (objectTag) {
                var componentName = this.getComponentName_(childComponents[objectTag], dataEntry[objectTag])
                if (componentName != child.is) {
                  var node = this.createComponent_(childComponents[objectTag], dataEntry[objectTag], isCustomCreation);
                  var nextElm = getDomApi(child).nextElementSibling;
                  if (nextElm) {
                    nativeElement.insertBefore(node, nextElm);
                  } else {
                    nativeElement.appendChild(node);
                  }
                  remove(this.is, nativeElement, child, isCustomCreation);
                  child = node;
                } else {
                  this.telemetry_.reuse++;
                }
                this.deferRenderStamperBinding_(child, childComponents[objectTag], dataEntry[objectTag]);
                counter++;
                idx++;
                child = getDomApi(child).nextElementSibling;
              } else {
                idx++;
              }
            }
          }
          removeAfterChildIdx(this.is, nativeElement, counter, isCustomCreation);
          let childElement = child;
          if (dataArray.length > idx) {
            /** @type {DocumentFragment} */
            let newFragment = document.createDocumentFragment();
            /** @type {number} */
            let fragmentListCount = dataArray.length;
            for (;idx < fragmentListCount;idx++) {
              let oldFragment = dataArray[idx]
              const objectTag = getObjectTag(childComponents, oldFragment)
              if (objectTag) {
                child = this.createComponent_(childComponents[objectTag], oldFragment[objectTag], isCustomCreation);
                this.deferRenderStamperBinding_(child, childComponents[objectTag], oldFragment[objectTag]);
                newFragment.appendChild(child);
              }
            }
            if (childElement && (getDomApi(childElement).parentNode && (child && !CP.has(child)))) {
              nativeElement.insertBefore(newFragment, childElement);
            } else {
              nativeElement.appendChild(newFragment);
            }
          }
          this.flushRenderStamperComponentBindings_();
          if (this.markDirty) {
            this.markDirty();
          }
          if (toDispatchFinished) {
            dispatchCustomEvent(this.hostElement, "yt-rendererstamper-finished", {
              container : container
            });
          }
        } else {
          removeAfterChildIdx(this.is, nativeElement, 0, isCustomCreation);
        }
      } else {
        yq(new Cm("Container object not found", containerId, this.hostElement ? this.hostElement.is : ""));
      }
    }
  };
}();

'use strict';

(() => {

    function z(inputValue) {
        inputValue = yl(inputValue);
        if (inputValue === "false") {
            return false;
        }
        return !!(inputValue);
    }

    function lq(a) {
        kq(a, "WARNING")
    }

    const Ls = function (element = document) {
        if (element instanceof Js) {
            return element;
        }
        if (element instanceof Is) {
            return element;
        }
        
        let domApi = element.__domApi;
        
        if (!domApi) {
            domApi = element instanceof Event ? new Is(element) : new Js(element);
            element.__domApi = domApi;
        }
        
        return domApi;
    };

    const uE = new WeakMap;
    const vE = new WeakMap;
    function ZHa(objectA, objectB) {
        for (const property in objectA) {
            if (objectA.hasOwnProperty(property) && objectB[property]) {
                return property;
            }
        }
        return null;
    }
    function aIa(reuseComponentsFlag) {
        if (typeof reuseComponentsFlag === "undefined") {
            if (z("kevlar_tuner_should_test_reuse_components")) {
                return z("kevlar_tuner_should_reuse_components");
            }
            return ll("REUSE_COMPONENTS", false);
        }
        return reuseComponentsFlag || false;
    }
    function bIa(typeOfElement, childrenElement, reuseComponentsFlag) {
        reuseComponentsFlag && (childrenElement.is ? (vE.has(childrenElement) && (typeOfElement = vE.get(childrenElement),
        reuseComponentsFlag = typeOfElement.listener,
        delete childrenElement[typeOfElement.property],
        "element" === reuseComponentsFlag.type ? childrenElement.removeEventListener(reuseComponentsFlag.eventName, reuseComponentsFlag.handler) : "polymer" === reuseComponentsFlag.type && childrenElement.unlisten(childrenElement, reuseComponentsFlag.eventName, reuseComponentsFlag.methodName),
        vE.delete(childrenElement)),
        GC(childrenElement)) : childrenElement.__proto__ == HTMLElement.prototype && (childrenElement = new tm("Rendererstamper removed a non custom element","Stamper: " + typeOfElement + " element: " + (childrenElement && childrenElement.nodeName)),
        lq(childrenElement)))
    }
    function cIa(typeOfElement, domContainer, childrenElement, reuseComponentsFlag) {
        const node = domContainer.node ? domContainer.node : domContainer;
        if (Ls(childrenElement).parentNode == node) {
            domContainer.removeChild(childrenElement);
            bIa(typeOfElement, childrenElement, reuseComponentsFlag);
        }
        let timeoutId = uE.get(childrenElement);
        if (timeoutId) {
            uE.delete(childrenElement);
            xi.cancelJob(timeoutId);
        }
        childrenElement.hidden = false;
    }

    function dIa(typeOfElement, domContainer, index, reuseComponentsFlag) {
        if (domContainer && domContainer.children) {
            let childrenElement = domContainer.children[index];
            if (childrenElement) {
                if (ll("DEFERRED_DETACH")) {
                    while (childrenElement && !uE.has(childrenElement)) {
                        const e = typeOfElement;
                        const h = domContainer;
                        const l = childrenElement;
                        const m = reuseComponentsFlag;
                        l.hidden = true;
                        const timeoutId = Bm(0, cIa.bind(null, e, h, l, m), 0);
                        uE.set(l, timeoutId);
                        childrenElement = childrenElement.nextElementSibling;
                    }
                } else {
                    let element;
                    while (element = domContainer.lastElementChild) {
                        domContainer.removeChild(element);
                        bIa(typeOfElement, element, reuseComponentsFlag);
                        if (element === childrenElement) break;
                    }
                }
            }
        }
    }

    window.p301 = {
        Ls,
        aIa
    };

    window.q301 = {
        stampDomArray_: function (inputArray, containerId, pivotEntry, reuseComponentsFlag, fireEvent, maintainStableListFlag) {
            let container = this.getStampContainer_(containerId);

            if (container) {
                const domContainer = Ls(container);
                reuseComponentsFlag = aIa(reuseComponentsFlag);

                if (inputArray) {
                    let currentIndex = 0;
                    let arrayIndex = 0;
                    let currentNode;
 
                    let isMaintainStableListFlag = maintainStableListFlag === undefined ? z("kevlar_tuner_should_test_maintain_stable_list") ? z("kevlar_should_maintain_stable_list") : !!ll("STAMPER_STABLE_LIST", false) : maintainStableListFlag || false;

                    if (isMaintainStableListFlag) {
                        currentNode = domContainer.firstElementChild;
                        
                        while (currentNode && !uE.has(currentNode) && inputArray.length > arrayIndex) {
                            const currentEntry = inputArray[arrayIndex];
                            const extractedData = ZHa(pivotEntry, currentEntry);

                            if (extractedData) {
                                const componentName = this.getComponentName_(pivotEntry[extractedData], currentEntry[extractedData]);
                                if (componentName !== currentNode.is) {
                                    const newNode = this.createComponent_(pivotEntry[extractedData], currentEntry[extractedData], reuseComponentsFlag);
                                    const nextSiblingNode = Ls(currentNode).nextElementSibling;
                                    
                                    if (nextSiblingNode) {
                                        domContainer.insertBefore(newNode, nextSiblingNode);
                                    } else {
                                        domContainer.appendChild(newNode);
                                    }
                                    cIa(this.is, domContainer, currentNode, reuseComponentsFlag);
                                    currentNode = newNode;
                                } else {
                                    this.telemetry_.reuse++;
                                }
                                this.deferRenderStamperBinding_(currentNode, pivotEntry[extractedData], currentEntry[extractedData]);
                                currentIndex++;
                                arrayIndex++;
                                currentNode = Ls(currentNode).nextElementSibling;
                            } else {
                                arrayIndex++;
                            }
                        }
                    }
                    dIa(this.is, domContainer, currentIndex, reuseComponentsFlag);
                    const subsequentNode = currentNode;

                    if (inputArray.length > arrayIndex) {
                        const fragment = document.createDocumentFragment();
                        
                        for (; arrayIndex < inputArray.length; arrayIndex++) {
                            const currentValue = inputArray[arrayIndex];
                            const extractedValue = ZHa(pivotEntry, currentValue);
                            if (extractedValue) {
                                currentNode = this.createComponent_(pivotEntry[extractedValue], currentValue[extractedValue], reuseComponentsFlag);
                                this.deferRenderStamperBinding_(currentNode, pivotEntry[extractedValue], currentValue[extractedValue]);
                                fragment.appendChild(currentNode);
                            }
                        }

                        if (subsequentNode && Ls(subsequentNode).parentNode && currentNode && !uE.has(currentNode)) {
                            domContainer.insertBefore(fragment, subsequentNode);
                        } else {
                            domContainer.appendChild(fragment);
                        }
                    }
                    this.flushRenderStamperComponentBindings_();

                    if (this.markDirty) {
                        this.markDirty();
                    }
                    if (fireEvent) {
                        Au(this.hostElement, "yt-rendererstamper-finished", { container: container });
                    }
                } else {
                    dIa(this.is, domContainer, 0, reuseComponentsFlag);
                }
            } else {
                kq(new tm("Container object not found", containerId));
            }
        }
    };
})();

// ==UserScript==
// @name        Testing Script 186
// @namespace   Violentmonkey Scripts
// @match       https://www.youtube.com/live_chat*
// @grant       none
// @version     1.0
// @author      -
// @description 8/19/2023, 11:41:39 PM
// @run-at              document-start
// @grant               none
// @unwrap
// @allFrames           true
// @inject-into         page
// ==/UserScript==

(() => {
  'use strict';

  const updateFlags = () => {
    const EXPERIMENT_FLAGS = (window.ytcfg && window.ytcfg.data_) ? window.ytcfg.data_.EXPERIMENT_FLAGS : null;
    if (!EXPERIMENT_FLAGS) return;
    Object.assign(EXPERIMENT_FLAGS, {
      kevlar_tuner_should_test_maintain_stable_list: true,
      kevlar_should_maintain_stable_list: true
    });
  };

  const mo = new MutationObserver(updateFlags);
  mo.observe(document, { subtree: true, childList: true });

  updateFlags();

})();