Оптимизируй и улучши код, я не могу понять, почему ShadowDOM не ищется без Timeout, а с ними всё работает.  Разберись в вопросе и оптимизируй конкретно этот участок кода

```js

import "requestidlecallback-polyfill";
import { EventImpl } from "./EventImpl.js";
import debug from "./debug.ts";

const adKeywords = new Set([
  "advertise",
  "promo",
  "sponsor",
  "banner",
  "commercial",
  "preroll",
  "midroll",
  "postroll",
  "ad-container",
  "sponsored",
]);

const adKeywordsRegex = (() => {
  const pattern = Array.from(adKeywords).join("|");
  return new RegExp(pattern, "i");
})();

const filterVideoNodes = (nodes) => {
  const result = [];
  for (let i = 0; i < nodes.length; i++) {
    const node = nodes[i];
    if (node instanceof HTMLVideoElement) {
      result.push(node);
    } else if (node instanceof HTMLElement) {
      const videos = node.querySelectorAll("video");
      for (let j = 0; j < videos.length; j++) {
        result.push(videos[j]);
      }
    } else if (node.shadowRoot) {
      const shadowVideos = node.shadowRoot.querySelectorAll("video");
      for (let k = 0; k < shadowVideos.length; k++) {
        result.push(shadowVideos[k]);
      }
    }
  }
  return result;
};

const isAdVideo = (video) => {
  if (
    adKeywordsRegex.test(video.className) ||
    adKeywordsRegex.test(video.title)
  )
    return true;

  let parent = video.parentElement;
  while (parent) {
    if (
      adKeywordsRegex.test(parent.className) ||
      adKeywordsRegex.test(parent.id)
    )
      return true;
    parent = parent.parentElement;
  }

  return false;
};

const isMutedVideo = (video) => {
  return (
    video.hasAttribute("muted") &&
    !video.classList.contains("vjs-tech") &&
    !video.preload
  );
};

const isVideoReady = (video) => video.readyState >= 3;

const waitForVideoReady = (video, callback) => {
  const checkVideoState = () => {
    if (isVideoReady(video)) {
      callback(video);
    } else {
      requestAnimationFrame(checkVideoState);
    }
  };

  checkVideoState();
};

export class VideoObserver {
  constructor() {
    this.videoCache = new Set();
    this.onVideoAdded = new EventImpl();
    this.onVideoRemoved = new EventImpl();
    this.mutationTimeout = null;
    this.isSearchingShadowRoot = false;
    this.hasDoneInitialShadowSearch = false;

    this.observer = new MutationObserver(this.handleMutations);
  }

  handleMutations = (mutationsList) => {
    if (this.mutationTimeout) {
      clearTimeout(this.mutationTimeout);
    }

    window.requestIdleCallback(
      () => {
        for (let i = 0; i < mutationsList.length; i++) {
          const mutation = mutationsList[i];
          if (mutation.type !== "childList") continue;

          const addedVideos = filterVideoNodes(mutation.addedNodes);
          for (let j = 0; j < addedVideos.length; j++) {
            this.checkAndHandleVideo(addedVideos[j]);
          }

          const removedVideos = filterVideoNodes(mutation.removedNodes);
          for (let k = 0; k < removedVideos.length; k++) {
            this.handleVideoRemoved(removedVideos[k]);
          }
        }

        if (!this.hasDoneInitialShadowSearch) {
          this.mutationTimeout = setTimeout(() => {
            this.searchInShadowRoots();
            this.hasDoneInitialShadowSearch = true;
          }, 5000);
        }
      },
      { timeout: 1000 },
    );
  };

  searchInShadowRoots = () => {
    if (this.isSearchingShadowRoot) return;
    this.isSearchingShadowRoot = true;

    const findVideosInShadowDOM = (root) => {
      const videos = new Set();
      
      // Helper function to recursively search shadow roots
      const searchNode = (node) => {
        // Check if the node itself is a video
        if (node instanceof HTMLVideoElement) {
          videos.add(node);
        }

        // Search in regular DOM
        const directVideos = node.querySelectorAll('video');
        directVideos.forEach(video => videos.add(video));

        // Search in shadow DOM
        if (node.shadowRoot) {
          const shadowVideos = node.shadowRoot.querySelectorAll('video');
          shadowVideos.forEach(video => videos.add(video));
          
          // Recursively search all elements in shadow root
          node.shadowRoot.querySelectorAll('*').forEach(searchNode);
        }

        // Search children's shadow roots
        if (node.children) {
          Array.from(node.children).forEach(searchNode);
        }
      };

      searchNode(root);
      return Array.from(videos);
    };

    // Start search from document root
    const foundVideos = findVideosInShadowDOM(document.documentElement);
    foundVideos.forEach(video => {
      this.checkAndHandleVideo(video);
    });

    this.isSearchingShadowRoot = false;
  };

  enable() {
    this.observer.observe(document, { childList: true, subtree: true });
    
    // Initial scan of regular DOM
    const regularVideos = document.querySelectorAll("video");
    for (let i = 0; i < regularVideos.length; i++) {
      this.checkAndHandleVideo(regularVideos[i]);
    }
    
    if (!this.hasDoneInitialShadowSearch) {
      this.mutationTimeout = setTimeout(() => {
        this.searchInShadowRoots();
        this.hasDoneInitialShadowSearch = true;
      }, 5000);
    }
  }

  disable() {
    this.observer.disconnect();
    if (this.mutationTimeout) {
      clearTimeout(this.mutationTimeout);
    }
  }

  checkAndHandleVideo = (video) => {
    if (this.videoCache.has(video)) return;
    this.videoCache.add(video);
    
    if (isAdVideo(video) || isMutedVideo(video)) {
      debug.log("The promotional/muted video was ignored", video);
      return;
    }
    waitForVideoReady(video, this.handleVideoAdded);
  };

  handleVideoAdded = (video) => {
    this.onVideoAdded.dispatch(video);
  };

  handleVideoRemoved = (video) => {
    if (!document.contains(video)) {
      this.videoCache.delete(video);
      this.onVideoRemoved.dispatch(video);
    }
  };
}

```