darkreader 4.9.77 → 4.9.78

package/darkreader.js

@@ -1,5 +1,5 @@
 /**
- * Dark Reader v4.9.77
+ * Dark Reader v4.9.78
  * https://darkreader.org/
  */
 
@@ -1145,7 +1145,7 @@
                         getElementsTreeOperations(mutations);
                     observerCallbacks.forEach(function (_a) {
                         var onMinorMutations = _a.onMinorMutations;
-                        return onMinorMutations(elementsOperations_1);
+                        return onMinorMutations(root, elementsOperations_1);
                     });
                 }
             });
@@ -5147,7 +5147,7 @@
             variablesStore.matchVariablesAndDependents();
         }
         var treeObserver = createOptimizedTreeObserver(root, {
-            onMinorMutations: function (_a) {
+            onMinorMutations: function (_root, _a) {
                 var additions = _a.additions;
                 additions.forEach(function (added) {
                     return discoverNodes(added);
@@ -5950,6 +5950,116 @@
         };
     }
 
+    var canUseSheetProxy$1 = false;
+    document.addEventListener(
+        "__darkreader__inlineScriptsAllowed",
+        function () {
+            return (canUseSheetProxy$1 = true);
+        },
+        {once: true}
+    );
+    function createSheetWatcher(
+        element,
+        safeGetSheetRules,
+        callback,
+        isCancelled
+    ) {
+        var rafSheetWatcher = null;
+        function watchForSheetChanges() {
+            watchForSheetChangesUsingProxy();
+            if (!(canUseSheetProxy$1 && element.sheet)) {
+                rafSheetWatcher = createRAFSheetWatcher(
+                    element,
+                    safeGetSheetRules,
+                    callback,
+                    isCancelled
+                );
+                rafSheetWatcher.start();
+            }
+        }
+        var areSheetChangesPending = false;
+        function onSheetChange() {
+            canUseSheetProxy$1 = true;
+            rafSheetWatcher === null || rafSheetWatcher === void 0
+                ? void 0
+                : rafSheetWatcher.stop();
+            if (areSheetChangesPending) {
+                return;
+            }
+            function handleSheetChanges() {
+                areSheetChangesPending = false;
+                if (isCancelled()) {
+                    return;
+                }
+                callback();
+            }
+            areSheetChangesPending = true;
+            queueMicrotask(handleSheetChanges);
+        }
+        function watchForSheetChangesUsingProxy() {
+            element.addEventListener(
+                "__darkreader__updateSheet",
+                onSheetChange
+            );
+        }
+        function stopWatchingForSheetChangesUsingProxy() {
+            element.removeEventListener(
+                "__darkreader__updateSheet",
+                onSheetChange
+            );
+        }
+        function stopWatchingForSheetChanges() {
+            stopWatchingForSheetChangesUsingProxy();
+            rafSheetWatcher === null || rafSheetWatcher === void 0
+                ? void 0
+                : rafSheetWatcher.stop();
+        }
+        return {
+            start: watchForSheetChanges,
+            stop: stopWatchingForSheetChanges
+        };
+    }
+    function createRAFSheetWatcher(
+        element,
+        safeGetSheetRules,
+        callback,
+        isCancelled
+    ) {
+        var rulesChangeKey = null;
+        var rulesCheckFrameId = null;
+        function getRulesChangeKey() {
+            var rules = safeGetSheetRules();
+            return rules ? rules.length : null;
+        }
+        function didRulesKeyChange() {
+            return getRulesChangeKey() !== rulesChangeKey;
+        }
+        function watchForSheetChangesUsingRAF() {
+            rulesChangeKey = getRulesChangeKey();
+            stopWatchingForSheetChangesUsingRAF();
+            var checkForUpdate = function () {
+                var cancelled = isCancelled();
+                if (!cancelled && didRulesKeyChange()) {
+                    rulesChangeKey = getRulesChangeKey();
+                    callback();
+                }
+                if (cancelled || (canUseSheetProxy$1 && element.sheet)) {
+                    stopWatchingForSheetChangesUsingRAF();
+                    return;
+                }
+                rulesCheckFrameId = requestAnimationFrame(checkForUpdate);
+            };
+            checkForUpdate();
+        }
+        function stopWatchingForSheetChangesUsingRAF() {
+            rulesCheckFrameId && cancelAnimationFrame(rulesCheckFrameId);
+        }
+        return {
+            start: watchForSheetChangesUsingRAF,
+            stop: stopWatchingForSheetChangesUsingRAF
+        };
+    }
+
     var STYLE_SELECTOR = 'style, link[rel*="stylesheet" i]:not([disabled])';
     function isFontsGoogleApiStyle(element) {
         if (!element.href) {
@@ -6012,14 +6122,6 @@
     }
     var syncStyleSet = new WeakSet();
     var corsStyleSet = new WeakSet();
-    var canOptimizeUsingProxy$1 = false;
-    document.addEventListener(
-        "__darkreader__inlineScriptsAllowed",
-        function () {
-            canOptimizeUsingProxy$1 = true;
-        },
-        {once: true, passive: true}
-    );
     var loadingLinkCounter = 0;
     var rejectorsForLoadingLinks = new Map();
     function cleanLoadingLinks() {
@@ -6049,9 +6151,27 @@
         var syncStylePositionWatcher = null;
         var cancelAsyncOperations = false;
         var isOverrideEmpty = true;
+        var isAsyncCancelled = function () {
+            return cancelAsyncOperations;
+        };
         var sheetModifier = createStyleSheetModifier();
-        var observer = new MutationObserver(function () {
-            update();
+        var observer = new MutationObserver(function (mutations) {
+            var _a;
+            if (
+                mutations.some(function (m) {
+                    return m.type === "characterData";
+                }) &&
+                containsCSSImport()
+            ) {
+                var cssText = (
+                    (_a = element.textContent) !== null && _a !== void 0
+                        ? _a
+                        : ""
+                ).trim();
+                createOrUpdateCORSCopy(cssText, location.href).then(update);
+            } else {
+                update();
+            }
         });
         var observerOptions = {
             attributes: true,
@@ -6159,12 +6279,7 @@
         var loadingLinkId = ++loadingLinkCounter;
         function getRulesAsync() {
             return __awaiter(this, void 0, void 0, function () {
-                var cssText,
-                    cssBasePath,
-                    _a,
-                    cssRules,
-                    accessError,
-                    fullCSSText;
+                var cssText, cssBasePath, _a, cssRules, accessError;
                 var _b;
                 return __generator(this, function (_c) {
                     switch (_c.label) {
@@ -6224,29 +6339,64 @@
                             }
                             _c.label = 8;
                         case 8:
-                            if (!cssText) return [3, 13];
-                            _c.label = 9;
+                            return [
+                                4,
+                                createOrUpdateCORSCopy(cssText, cssBasePath)
+                            ];
                         case 9:
-                            _c.trys.push([9, 11, , 12]);
+                            _c.sent();
+                            if (corsCopy) {
+                                return [2, corsCopy.sheet.cssRules];
+                            }
+                            return [2, null];
+                    }
+                });
+            });
+        }
+        function createOrUpdateCORSCopy(cssText, cssBasePath) {
+            var _a, _b;
+            return __awaiter(this, void 0, void 0, function () {
+                var fullCSSText;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            if (!cssText) return [3, 5];
+                            _c.label = 1;
+                        case 1:
+                            _c.trys.push([1, 3, , 4]);
                             return [4, replaceCSSImports(cssText, cssBasePath)];
-                        case 10:
+                        case 2:
                             fullCSSText = _c.sent();
-                            corsCopy = createCORSCopy(element, fullCSSText);
-                            return [3, 12];
-                        case 11:
+                            if (corsCopy) {
+                                if (
+                                    ((_b =
+                                        (_a = corsCopy.textContent) === null ||
+                                        _a === void 0
+                                            ? void 0
+                                            : _a.length) !== null &&
+                                    _b !== void 0
+                                        ? _b
+                                        : 0) < fullCSSText.length
+                                ) {
+                                    corsCopy.textContent = fullCSSText;
+                                }
+                            } else {
+                                corsCopy = createCORSCopy(element, fullCSSText);
+                            }
+                            return [3, 4];
+                        case 3:
                             _c.sent();
-                            return [3, 12];
-                        case 12:
+                            return [3, 4];
+                        case 4:
                             if (corsCopy) {
                                 corsCopyPositionWatcher = watchForNodePosition(
                                     corsCopy,
                                     "prev-sibling"
                                 );
-                                return [2, corsCopy.sheet.cssRules];
                             }
-                            _c.label = 13;
-                        case 13:
-                            return [2, null];
+                            _c.label = 5;
+                        case 5:
+                            return [2];
                     }
                 });
             });
@@ -6327,9 +6477,7 @@
                     theme: theme,
                     ignoreImageAnalysis: ignoreImageAnalysis,
                     force: force,
-                    isAsyncCancelled: function () {
-                        return cancelAsyncOperations;
-                    }
+                    isAsyncCancelled: isAsyncCancelled
                 });
                 isOverrideEmpty = syncStyle.sheet.cssRules.length === 0;
                 if (sheetModifier.shouldRebuildStyle()) {
@@ -6362,84 +6510,18 @@
             }
             return cssRules;
         }
-        function watchForSheetChanges() {
-            watchForSheetChangesUsingProxy();
-            if (!(canOptimizeUsingProxy$1 && element.sheet)) {
-                watchForSheetChangesUsingRAF();
-            }
-        }
-        var rulesChangeKey = null;
-        var rulesCheckFrameId = null;
-        function getRulesChangeKey() {
-            var rules = safeGetSheetRules();
-            return rules ? rules.length : null;
-        }
-        function didRulesKeyChange() {
-            return getRulesChangeKey() !== rulesChangeKey;
-        }
-        function watchForSheetChangesUsingRAF() {
-            rulesChangeKey = getRulesChangeKey();
-            stopWatchingForSheetChangesUsingRAF();
-            var checkForUpdate = function () {
-                if (didRulesKeyChange()) {
-                    rulesChangeKey = getRulesChangeKey();
-                    update();
-                }
-                if (canOptimizeUsingProxy$1 && element.sheet) {
-                    stopWatchingForSheetChangesUsingRAF();
-                    return;
-                }
-                rulesCheckFrameId = requestAnimationFrame(checkForUpdate);
-            };
-            checkForUpdate();
-        }
-        function stopWatchingForSheetChangesUsingRAF() {
-            cancelAnimationFrame(rulesCheckFrameId);
-        }
-        var areSheetChangesPending = false;
-        function onSheetChange() {
-            canOptimizeUsingProxy$1 = true;
-            stopWatchingForSheetChangesUsingRAF();
-            if (areSheetChangesPending) {
-                return;
-            }
-            function handleSheetChanges() {
-                areSheetChangesPending = false;
-                if (cancelAsyncOperations) {
-                    return;
-                }
-                update();
-            }
-            areSheetChangesPending = true;
-            if (typeof queueMicrotask === "function") {
-                queueMicrotask(handleSheetChanges);
-            } else {
-                requestAnimationFrame(handleSheetChanges);
-            }
-        }
-        function watchForSheetChangesUsingProxy() {
-            element.addEventListener(
-                "__darkreader__updateSheet",
-                onSheetChange,
-                {passive: true}
-            );
-        }
-        function stopWatchingForSheetChangesUsingProxy() {
-            element.removeEventListener(
-                "__darkreader__updateSheet",
-                onSheetChange
-            );
-        }
-        function stopWatchingForSheetChanges() {
-            stopWatchingForSheetChangesUsingProxy();
-            stopWatchingForSheetChangesUsingRAF();
-        }
+        var sheetChangeWatcher = createSheetWatcher(
+            element,
+            safeGetSheetRules,
+            update,
+            isAsyncCancelled
+        );
         function pause() {
             observer.disconnect();
             cancelAsyncOperations = true;
             corsCopyPositionWatcher && corsCopyPositionWatcher.stop();
             syncStylePositionWatcher && syncStylePositionWatcher.stop();
-            stopWatchingForSheetChanges();
+            sheetChangeWatcher.stop();
         }
         function destroy() {
             pause();
@@ -6455,7 +6537,7 @@
         function watch() {
             observer.observe(element, observerOptions);
             if (element instanceof HTMLStyleElement) {
-                watchForSheetChanges();
+                sheetChangeWatcher.start();
             }
         }
         var maxMoveCount = 10;
@@ -6666,8 +6748,6 @@
         return cors;
     }
 
-    var observers = [];
-    var observedRoots;
     var definedCustomElements = new Set();
     var undefinedGroups = new Map();
     var elementsDefinitionCallback;
@@ -6791,9 +6871,35 @@
             handleIsDefined
         );
     }
-    function watchForStyleChanges(currentStyles, update, shadowRootDiscovered) {
-        stopWatchingForStyleChanges();
-        var prevStyles = new Set(currentStyles);
+
+    var observers = [];
+    var observedRoots;
+    function watchForStylePositions(
+        currentStyles,
+        update,
+        shadowRootDiscovered
+    ) {
+        stopWatchingForStylePositions();
+        var prevStylesByRoot = new WeakMap();
+        var getPrevStyles = function (root) {
+            if (!prevStylesByRoot.has(root)) {
+                prevStylesByRoot.set(root, new Set());
+            }
+            return prevStylesByRoot.get(root);
+        };
+        currentStyles.forEach(function (node) {
+            var root = node;
+            while ((root = root.parentNode)) {
+                if (
+                    root === document ||
+                    root.nodeType === Node.DOCUMENT_FRAGMENT_NODE
+                ) {
+                    var prevStyles = getPrevStyles(root);
+                    prevStyles.add(node);
+                    break;
+                }
+            }
+        });
         var prevStyleSiblings = new WeakMap();
         var nextStyleSiblings = new WeakMap();
         function saveStylePosition(style) {
@@ -6811,7 +6917,7 @@
             );
         }
         currentStyles.forEach(saveStylePosition);
-        function handleStyleOperations(operations) {
+        function handleStyleOperations(root, operations) {
             var createdStyles = operations.createdStyles,
                 removedStyles = operations.removedStyles,
                 movedStyles = operations.movedStyles;
@@ -6824,6 +6930,7 @@
             removedStyles.forEach(function (s) {
                 return forgetStylePosition(s);
             });
+            var prevStyles = getPrevStyles(root);
             createdStyles.forEach(function (s) {
                 return prevStyles.add(s);
             });
@@ -6842,7 +6949,7 @@
                 });
             }
         }
-        function handleMinorTreeMutations(_a) {
+        function handleMinorTreeMutations(root, _a) {
             var additions = _a.additions,
                 moves = _a.moves,
                 deletions = _a.deletions;
@@ -6864,13 +6971,13 @@
                     return movedStyles.add(style);
                 });
             });
-            handleStyleOperations({
+            handleStyleOperations(root, {
                 createdStyles: createdStyles,
                 removedStyles: removedStyles,
                 movedStyles: movedStyles
             });
             additions.forEach(function (n) {
-                extendedIterateShadowHosts(n);
+                deepObserve(n);
                 collectUndefinedElements(n);
             });
             additions.forEach(function (node) {
@@ -6882,6 +6989,7 @@
             var createdStyles = new Set();
             var removedStyles = new Set();
             var movedStyles = new Set();
+            var prevStyles = getPrevStyles(root);
             styles.forEach(function (s) {
                 if (!prevStyles.has(s)) {
                     createdStyles.add(s);
@@ -6901,12 +7009,12 @@
                     movedStyles.add(s);
                 }
             });
-            handleStyleOperations({
+            handleStyleOperations(root, {
                 createdStyles: createdStyles,
                 removedStyles: removedStyles,
                 movedStyles: movedStyles
             });
-            extendedIterateShadowHosts(root);
+            deepObserve(root);
             collectUndefinedElements(root);
         }
         function handleAttributeMutations(mutations) {
@@ -6958,11 +7066,11 @@
             observe(shadowRoot);
             shadowRootDiscovered(shadowRoot);
         }
-        function extendedIterateShadowHosts(node) {
+        function deepObserve(node) {
             iterateShadowHosts(node, subscribeForShadowRootChanges);
         }
         observe(document);
-        extendedIterateShadowHosts(document.documentElement);
+        deepObserve(document.documentElement);
         watchWhenCustomElementsDefined(function (hosts) {
             var newStyles = [];
             hosts.forEach(function (host) {
@@ -6975,13 +7083,11 @@
                     return;
                 }
                 subscribeForShadowRootChanges(host);
-                extendedIterateShadowHosts(shadowRoot);
+                deepObserve(shadowRoot);
                 collectUndefinedElements(shadowRoot);
             });
         });
-        document.addEventListener("__darkreader__isDefined", handleIsDefined, {
-            passive: true
-        });
+        document.addEventListener("__darkreader__isDefined", handleIsDefined);
         collectUndefinedElements(document);
     }
     function resetObservers() {
@@ -6991,17 +7097,30 @@
         observers.splice(0, observers.length);
         observedRoots = new WeakSet();
     }
-    function stopWatchingForStyleChanges() {
+    function stopWatchingForStylePositions() {
         resetObservers();
         unsubscribeFromDefineCustomElements();
     }
 
+    function watchForStyleChanges(currentStyles, update, shadowRootDiscovered) {
+        watchForStylePositions(currentStyles, update, shadowRootDiscovered);
+    }
+    function stopWatchingForStyleChanges() {
+        stopWatchingForStylePositions();
+    }
+
+    var canUseSheetProxy = false;
+    document.addEventListener(
+        "__darkreader__inlineScriptsAllowed",
+        function () {
+            return (canUseSheetProxy = true);
+        },
+        {once: true}
+    );
     var overrides = new WeakSet();
-    function hasAdoptedStyleSheets(node) {
-        return (
-            Array.isArray(node.adoptedStyleSheets) &&
-            node.adoptedStyleSheets.length > 0
-        );
+    var overridesBySource = new WeakMap();
+    function canHaveAdoptedStyleSheets(node) {
+        return Array.isArray(node.adoptedStyleSheets);
     }
     function createAdoptedStyleSheetOverride(node) {
         var cancelAsyncOperations = false;
@@ -7042,8 +7161,15 @@
             if (node.adoptedStyleSheets.length !== newSheets.length) {
                 node.adoptedStyleSheets = newSheets;
             }
+            sourceSheets = new WeakSet();
+            sourceDeclarations = new WeakSet();
         }
+        var cleaners = [];
         function destroy() {
+            cleaners.forEach(function (c) {
+                return c();
+            });
+            cleaners.splice(0);
             cancelAsyncOperations = true;
             clear();
             if (frameId) {
@@ -7063,6 +7189,8 @@
             }
             return count;
         }
+        var sourceSheets = new WeakSet();
+        var sourceDeclarations = new WeakSet();
         function render(theme, ignoreImageAnalysis) {
             clear();
             var _loop_1 = function (i) {
@@ -7070,8 +7198,19 @@
                 if (overrides.has(sheet)) {
                     return "continue";
                 }
+                sourceSheets.add(sheet);
+                var readyOverride = overridesBySource.get(sheet);
+                if (readyOverride) {
+                    rulesChangeKey = getRulesChangeKey();
+                    injectSheet(sheet, readyOverride);
+                    return "continue";
+                }
                 var rules = sheet.cssRules;
                 var override = new CSSStyleSheet();
+                overridesBySource.set(sheet, override);
+                iterateCSSRules(rules, function (rule) {
+                    return sourceDeclarations.add(rule.style);
+                });
                 var prepareSheet = function () {
                     for (
                         var i_1 = override.cssRules.length - 1;
@@ -7080,6 +7219,7 @@
                     ) {
                         override.deleteRule(i_1);
                     }
+                    override.insertRule("#__darkreader__adoptedOverride {}");
                     injectSheet(sheet, override);
                     overrides.add(override);
                     return override;
@@ -7101,21 +7241,66 @@
             }
             rulesChangeKey = getRulesChangeKey();
         }
+        var callbackRequested = false;
+        function handleArrayChange(callback) {
+            if (callbackRequested) {
+                return;
+            }
+            callbackRequested = true;
+            queueMicrotask(function () {
+                callbackRequested = false;
+                var sheets = node.adoptedStyleSheets.filter(function (s) {
+                    return !overrides.has(s);
+                });
+                sheets.forEach(function (sheet) {
+                    return overridesBySource.delete(sheet);
+                });
+                callback(sheets);
+            });
+        }
         function checkForUpdates() {
             return getRulesChangeKey() !== rulesChangeKey;
         }
         var frameId = null;
-        function watch(callback) {
+        function watchUsingRAF(callback) {
             frameId = requestAnimationFrame(function () {
+                if (canUseSheetProxy) {
+                    return;
+                }
                 if (checkForUpdates()) {
-                    var sheets = node.adoptedStyleSheets.filter(function (s) {
-                        return !overrides.has(s);
-                    });
-                    callback(sheets);
+                    handleArrayChange(callback);
                 }
-                watch(callback);
+                watchUsingRAF(callback);
             });
         }
+        function addSheetChangeEventListener(type, listener) {
+            node.addEventListener(type, listener);
+            cleaners.push(function () {
+                return node.removeEventListener(type, listener);
+            });
+        }
+        function watch(callback) {
+            var onAdoptedSheetsChange = function () {
+                canUseSheetProxy = true;
+                handleArrayChange(callback);
+            };
+            addSheetChangeEventListener(
+                "__darkreader__adoptedStyleSheetsChange",
+                onAdoptedSheetsChange
+            );
+            addSheetChangeEventListener(
+                "__darkreader__adoptedStyleSheetChange",
+                onAdoptedSheetsChange
+            );
+            addSheetChangeEventListener(
+                "__darkreader__adoptedStyleDeclarationChange",
+                onAdoptedSheetsChange
+            );
+            if (canUseSheetProxy) {
+                return;
+            }
+            watchUsingRAF(callback);
+        }
         return {
             render: render,
             destroy: destroy,
@@ -7244,340 +7429,207 @@
         document.dispatchEvent(
             new CustomEvent("__darkreader__inlineScriptsAllowed")
         );
-        var addRuleDescriptor = Object.getOwnPropertyDescriptor(
-            CSSStyleSheet.prototype,
-            "addRule"
-        );
-        var insertRuleDescriptor = Object.getOwnPropertyDescriptor(
-            CSSStyleSheet.prototype,
-            "insertRule"
-        );
-        var deleteRuleDescriptor = Object.getOwnPropertyDescriptor(
-            CSSStyleSheet.prototype,
-            "deleteRule"
-        );
-        var removeRuleDescriptor = Object.getOwnPropertyDescriptor(
-            CSSStyleSheet.prototype,
-            "removeRule"
-        );
-        var replaceDescriptor = Object.getOwnPropertyDescriptor(
-            CSSStyleSheet.prototype,
-            "replace"
-        );
-        var replaceSyncDescriptor = Object.getOwnPropertyDescriptor(
-            CSSStyleSheet.prototype,
-            "replaceSync"
-        );
-        var documentStyleSheetsDescriptor = enableStyleSheetsProxy
-            ? Object.getOwnPropertyDescriptor(Document.prototype, "styleSheets")
-            : null;
-        var customElementRegistryDefineDescriptor =
-            enableCustomElementRegistryProxy
-                ? Object.getOwnPropertyDescriptor(
-                      CustomElementRegistry.prototype,
-                      "define"
-                  )
-                : null;
-        var shouldWrapHTMLElement = [
-            "baidu.com",
-            "baike.baidu.com",
-            "ditu.baidu.com",
-            "map.baidu.com",
-            "maps.baidu.com",
-            "haokan.baidu.com",
-            "pan.baidu.com",
-            "passport.baidu.com",
-            "tieba.baidu.com",
-            "www.baidu.com"
-        ].includes(location.hostname);
-        var getElementsByTagNameDescriptor = shouldWrapHTMLElement
-            ? Object.getOwnPropertyDescriptor(
-                  Element.prototype,
-                  "getElementsByTagName"
-              )
-            : null;
-        var shouldProxyChildNodes = location.hostname === "www.vy.no";
-        var childNodesDescriptor = shouldProxyChildNodes
-            ? Object.getOwnPropertyDescriptor(Node.prototype, "childNodes")
-            : null;
         var cleaners = [];
-        var cleanUp = function () {
-            Object.defineProperty(
-                CSSStyleSheet.prototype,
-                "addRule",
-                addRuleDescriptor
-            );
-            Object.defineProperty(
-                CSSStyleSheet.prototype,
-                "insertRule",
-                insertRuleDescriptor
-            );
-            Object.defineProperty(
-                CSSStyleSheet.prototype,
-                "deleteRule",
-                deleteRuleDescriptor
-            );
-            Object.defineProperty(
-                CSSStyleSheet.prototype,
-                "removeRule",
-                removeRuleDescriptor
-            );
-            Object.defineProperty(
-                CSSStyleSheet.prototype,
-                "replace",
-                replaceDescriptor
-            );
-            Object.defineProperty(
-                CSSStyleSheet.prototype,
-                "replaceSync",
-                replaceSyncDescriptor
-            );
-            document.removeEventListener("__darkreader__cleanUp", cleanUp);
-            document.removeEventListener(
-                "__darkreader__addUndefinedResolver",
-                addUndefinedResolver
-            );
-            document.removeEventListener(
-                "__darkreader__blobURLCheckRequest",
-                checkBlobURLSupport
-            );
-            if (enableStyleSheetsProxy) {
-                Object.defineProperty(
-                    Document.prototype,
-                    "styleSheets",
-                    documentStyleSheetsDescriptor
-                );
-            }
-            if (enableCustomElementRegistryProxy) {
-                Object.defineProperty(
-                    CustomElementRegistry.prototype,
-                    "define",
-                    customElementRegistryDefineDescriptor
-                );
-            }
-            if (shouldWrapHTMLElement) {
-                Object.defineProperty(
-                    Element.prototype,
-                    "getElementsByTagName",
-                    getElementsByTagNameDescriptor
-                );
-            }
-            if (shouldProxyChildNodes) {
-                Object.defineProperty(
-                    Node.prototype,
-                    "childNodes",
-                    childNodesDescriptor
-                );
-            }
+        function cleanUp() {
             cleaners.forEach(function (clean) {
                 return clean();
             });
             cleaners.splice(0);
-        };
-        var addUndefinedResolverInner = function (tag) {
-            customElements.whenDefined(tag).then(function () {
-                document.dispatchEvent(
-                    new CustomEvent("__darkreader__isDefined", {
-                        detail: {tag: tag}
-                    })
-                );
+        }
+        function documentEventListener(type, listener, options) {
+            document.addEventListener(type, listener, options);
+            cleaners.push(function () {
+                return document.removeEventListener(type, listener);
             });
-        };
-        var addUndefinedResolver = function (e) {
-            return addUndefinedResolverInner(e.detail.tag);
-        };
-        document.addEventListener("__darkreader__cleanUp", cleanUp, {
-            passive: true
-        });
-        document.addEventListener(
-            "__darkreader__addUndefinedResolver",
-            addUndefinedResolver,
-            {passive: true}
-        );
-        document.addEventListener(
-            "__darkreader__blobURLCheckRequest",
-            checkBlobURLSupport,
-            {once: true}
-        );
-        var updateSheetEvent = new Event("__darkreader__updateSheet");
-        function proxyAddRule(selector, style, index) {
-            addRuleDescriptor.value.call(this, selector, style, index);
-            if (
-                this.ownerNode &&
-                !(
-                    this.ownerNode.classList &&
-                    this.ownerNode.classList.contains("darkreader")
-                )
-            ) {
-                this.ownerNode.dispatchEvent(updateSheetEvent);
-            }
-            return -1;
         }
-        function proxyInsertRule(rule, index) {
-            var returnValue = insertRuleDescriptor.value.call(
-                this,
-                rule,
-                index
-            );
-            if (
-                this.ownerNode &&
-                !(
-                    this.ownerNode.classList &&
-                    this.ownerNode.classList.contains("darkreader")
-                )
-            ) {
-                this.ownerNode.dispatchEvent(updateSheetEvent);
-            }
-            return returnValue;
+        documentEventListener("__darkreader__cleanUp", cleanUp);
+        function overrideProperty(cls, prop, overrides) {
+            var proto = cls.prototype;
+            var oldDescriptor = Object.getOwnPropertyDescriptor(proto, prop);
+            var newDescriptor = __assign({}, oldDescriptor);
+            Object.keys(overrides).forEach(function (key) {
+                var factory = overrides[key];
+                newDescriptor[key] = factory(oldDescriptor[key]);
+            });
+            Object.defineProperty(proto, prop, newDescriptor);
+            cleaners.push(function () {
+                return Object.defineProperty(proto, prop, oldDescriptor);
+            });
         }
-        function proxyDeleteRule(index) {
-            deleteRuleDescriptor.value.call(this, index);
-            if (
-                this.ownerNode &&
-                !(
-                    this.ownerNode.classList &&
-                    this.ownerNode.classList.contains("darkreader")
-                )
-            ) {
-                this.ownerNode.dispatchEvent(updateSheetEvent);
-            }
+        function override(cls, prop, factory) {
+            overrideProperty(cls, prop, {value: factory});
         }
-        function proxyRemoveRule(index) {
-            removeRuleDescriptor.value.call(this, index);
-            if (
-                this.ownerNode &&
-                !(
-                    this.ownerNode.classList &&
-                    this.ownerNode.classList.contains("darkreader")
-                )
-            ) {
-                this.ownerNode.dispatchEvent(updateSheetEvent);
+        function isDRElement(element) {
+            var _a;
+            return (_a =
+                element === null || element === void 0
+                    ? void 0
+                    : element.classList) === null || _a === void 0
+                ? void 0
+                : _a.contains("darkreader");
+        }
+        function isDRSheet(sheet) {
+            return isDRElement(sheet.ownerNode);
+        }
+        var updateSheetEvent = new CustomEvent("__darkreader__updateSheet");
+        var adoptedSheetChangeEvent = new CustomEvent(
+            "__darkreader__adoptedStyleSheetChange"
+        );
+        var adoptedSheetOwners = new WeakMap();
+        var adoptedDeclarationSheets = new WeakMap();
+        function onAdoptedSheetChange(sheet) {
+            var owners = adoptedSheetOwners.get(sheet);
+            owners === null || owners === void 0
+                ? void 0
+                : owners.forEach(function (node) {
+                      if (node.isConnected) {
+                          node.dispatchEvent(adoptedSheetChangeEvent);
+                      } else {
+                          owners.delete(node);
+                      }
+                  });
+        }
+        function reportSheetChange(sheet) {
+            if (sheet.ownerNode && !isDRSheet(sheet)) {
+                sheet.ownerNode.dispatchEvent(updateSheetEvent);
+            }
+            if (adoptedSheetOwners.has(sheet)) {
+                onAdoptedSheetChange(sheet);
             }
         }
-        function proxyReplace(cssText) {
-            var _this = this;
-            var returnValue = replaceDescriptor.value.call(this, cssText);
+        function reportSheetChangeAsync(sheet, promise) {
+            var ownerNode = sheet.ownerNode;
             if (
-                this.ownerNode &&
-                !(
-                    this.ownerNode.classList &&
-                    this.ownerNode.classList.contains("darkreader")
-                ) &&
-                returnValue &&
-                returnValue instanceof Promise
+                ownerNode &&
+                !isDRSheet(sheet) &&
+                promise &&
+                promise instanceof Promise
             ) {
-                returnValue.then(function () {
-                    return _this.ownerNode.dispatchEvent(updateSheetEvent);
+                promise.then(function () {
+                    return ownerNode.dispatchEvent(updateSheetEvent);
                 });
             }
-            return returnValue;
-        }
-        function proxyReplaceSync(cssText) {
-            replaceSyncDescriptor.value.call(this, cssText);
-            if (
-                this.ownerNode &&
-                !(
-                    this.ownerNode.classList &&
-                    this.ownerNode.classList.contains("darkreader")
-                )
-            ) {
-                this.ownerNode.dispatchEvent(updateSheetEvent);
+            if (adoptedSheetOwners.has(sheet)) {
+                if (promise && promise instanceof Promise) {
+                    promise.then(function () {
+                        return onAdoptedSheetChange(sheet);
+                    });
+                }
             }
         }
-        function proxyDocumentStyleSheets() {
-            var _this = this;
-            var getCurrentValue = function () {
-                var docSheets = documentStyleSheetsDescriptor.get.call(_this);
-                var filteredSheets = __spreadArray(
-                    [],
-                    __read(docSheets),
-                    false
-                ).filter(function (styleSheet) {
-                    return (
-                        styleSheet.ownerNode &&
-                        !(
-                            styleSheet.ownerNode.classList &&
-                            styleSheet.ownerNode.classList.contains(
-                                "darkreader"
-                            )
-                        )
-                    );
-                });
-                filteredSheets.item = function (item) {
-                    return filteredSheets[item];
-                };
-                return Object.setPrototypeOf(
-                    filteredSheets,
-                    StyleSheetList.prototype
-                );
+        override(CSSStyleSheet, "addRule", function (native) {
+            return function (selector, style, index) {
+                native.call(this, selector, style, index);
+                reportSheetChange(this);
+                return -1;
             };
-            var elements = getCurrentValue();
-            var styleSheetListBehavior = {
-                get: function (_, property) {
-                    return getCurrentValue()[property];
-                }
+        });
+        override(CSSStyleSheet, "insertRule", function (native) {
+            return function (rule, index) {
+                var returnValue = native.call(this, rule, index);
+                reportSheetChange(this);
+                return returnValue;
             };
-            elements = new Proxy(elements, styleSheetListBehavior);
-            return elements;
-        }
-        function proxyCustomElementRegistryDefine(name, constructor, options) {
-            addUndefinedResolverInner(name);
-            customElementRegistryDefineDescriptor.value.call(
-                this,
-                name,
-                constructor,
-                options
-            );
-        }
-        function proxyGetElementsByTagName(tagName) {
-            var _this = this;
-            if (tagName !== "style") {
-                return getElementsByTagNameDescriptor.value.call(this, tagName);
-            }
-            var getCurrentElementValue = function () {
-                var elements = getElementsByTagNameDescriptor.value.call(
-                    _this,
-                    tagName
-                );
-                return Object.setPrototypeOf(
-                    __spreadArray([], __read(elements), false).filter(
-                        function (element) {
-                            return (
-                                element &&
-                                !(
-                                    element.classList &&
-                                    element.classList.contains("darkreader")
-                                )
-                            );
-                        }
-                    ),
-                    NodeList.prototype
-                );
+        });
+        override(CSSStyleSheet, "deleteRule", function (native) {
+            return function (index) {
+                native.call(this, index);
+                reportSheetChange(this);
             };
-            var elements = getCurrentElementValue();
-            var nodeListBehavior = {
-                get: function (_, property) {
-                    return getCurrentElementValue()[
-                        Number(property) || property
-                    ];
-                }
+        });
+        override(CSSStyleSheet, "removeRule", function (native) {
+            return function (index) {
+                native.call(this, index);
+                reportSheetChange(this);
             };
-            elements = new Proxy(elements, nodeListBehavior);
-            return elements;
-        }
-        function proxyChildNodes() {
-            var childNodes = childNodesDescriptor.get.call(this);
-            return Object.setPrototypeOf(
-                __spreadArray([], __read(childNodes), false).filter(
-                    function (element) {
-                        return (
-                            !element.classList ||
-                            !element.classList.contains("darkreader")
-                        );
+        });
+        override(CSSStyleSheet, "replace", function (native) {
+            return function (cssText) {
+                var returnValue = native.call(this, cssText);
+                reportSheetChangeAsync(this, returnValue);
+                return returnValue;
+            };
+        });
+        override(CSSStyleSheet, "replaceSync", function (native) {
+            return function (cssText) {
+                native.call(this, cssText);
+                reportSheetChange(this);
+            };
+        });
+        var shouldWrapHTMLElement =
+            location.hostname === "baidu.com" ||
+            location.hostname.endsWith(".baidu.com");
+        if (shouldWrapHTMLElement) {
+            override(Element, "getElementsByTagName", function (native) {
+                return function (tagName) {
+                    var _this = this;
+                    if (tagName !== "style") {
+                        return native.call(this, tagName);
                     }
-                ),
-                NodeList.prototype
-            );
+                    var getCurrentElementValue = function () {
+                        var elements = native.call(_this, tagName);
+                        return Object.setPrototypeOf(
+                            __spreadArray([], __read(elements), false).filter(
+                                function (element) {
+                                    return element && !isDRElement(element);
+                                }
+                            ),
+                            NodeList.prototype
+                        );
+                    };
+                    var elements = getCurrentElementValue();
+                    var nodeListBehavior = {
+                        get: function (_, property) {
+                            return getCurrentElementValue()[
+                                Number(property) || property
+                            ];
+                        }
+                    };
+                    elements = new Proxy(elements, nodeListBehavior);
+                    return elements;
+                };
+            });
+        }
+        var shouldProxyChildNodes = location.hostname === "www.vy.no";
+        if (shouldProxyChildNodes) {
+            overrideProperty(Node, "childNodes", {
+                get: function (native) {
+                    return function () {
+                        var childNodes = native.call(this);
+                        return Object.setPrototypeOf(
+                            __spreadArray([], __read(childNodes), false).filter(
+                                function (element) {
+                                    return !isDRElement(element);
+                                }
+                            ),
+                            NodeList.prototype
+                        );
+                    };
+                }
+            });
+        }
+        function resolveCustomElement(tag) {
+            customElements.whenDefined(tag).then(function () {
+                document.dispatchEvent(
+                    new CustomEvent("__darkreader__isDefined", {
+                        detail: {tag: tag}
+                    })
+                );
+            });
+        }
+        documentEventListener(
+            "__darkreader__addUndefinedResolver",
+            function (e) {
+                return resolveCustomElement(e.detail.tag);
+            }
+        );
+        if (enableCustomElementRegistryProxy) {
+            override(CustomElementRegistry, "define", function (native) {
+                return function (name, constructor, options) {
+                    resolveCustomElement(name);
+                    native.call(this, name, constructor, options);
+                };
+            });
         }
         function checkBlobURLSupport() {
             return __awaiter(this, void 0, void 0, function () {
@@ -7629,79 +7681,195 @@
                 });
             });
         }
-        Object.defineProperty(
-            CSSStyleSheet.prototype,
-            "addRule",
-            __assign(__assign({}, addRuleDescriptor), {value: proxyAddRule})
-        );
-        Object.defineProperty(
-            CSSStyleSheet.prototype,
-            "insertRule",
-            __assign(__assign({}, insertRuleDescriptor), {
-                value: proxyInsertRule
-            })
-        );
-        Object.defineProperty(
-            CSSStyleSheet.prototype,
-            "deleteRule",
-            __assign(__assign({}, deleteRuleDescriptor), {
-                value: proxyDeleteRule
-            })
-        );
-        Object.defineProperty(
-            CSSStyleSheet.prototype,
-            "removeRule",
-            __assign(__assign({}, removeRuleDescriptor), {
-                value: proxyRemoveRule
-            })
-        );
-        Object.defineProperty(
-            CSSStyleSheet.prototype,
-            "replace",
-            __assign(__assign({}, replaceDescriptor), {value: proxyReplace})
-        );
-        Object.defineProperty(
-            CSSStyleSheet.prototype,
-            "replaceSync",
-            __assign(__assign({}, replaceSyncDescriptor), {
-                value: proxyReplaceSync
-            })
+        documentEventListener(
+            "__darkreader__blobURLCheckRequest",
+            checkBlobURLSupport,
+            {once: true}
         );
         if (enableStyleSheetsProxy) {
-            Object.defineProperty(
-                Document.prototype,
-                "styleSheets",
-                __assign(__assign({}, documentStyleSheetsDescriptor), {
-                    get: proxyDocumentStyleSheets
-                })
-            );
-        }
-        if (enableCustomElementRegistryProxy) {
-            Object.defineProperty(
-                CustomElementRegistry.prototype,
-                "define",
-                __assign(__assign({}, customElementRegistryDefineDescriptor), {
-                    value: proxyCustomElementRegistryDefine
-                })
-            );
+            overrideProperty(Document, "styleSheets", {
+                get: function (native) {
+                    return function () {
+                        var _this = this;
+                        var getCurrentValue = function () {
+                            var docSheets = native.call(_this);
+                            var filteredSheets = __spreadArray(
+                                [],
+                                __read(docSheets),
+                                false
+                            ).filter(function (styleSheet) {
+                                return (
+                                    styleSheet.ownerNode &&
+                                    !isDRSheet(styleSheet)
+                                );
+                            });
+                            filteredSheets.item = function (item) {
+                                return filteredSheets[item];
+                            };
+                            return Object.setPrototypeOf(
+                                filteredSheets,
+                                StyleSheetList.prototype
+                            );
+                        };
+                        var elements = getCurrentValue();
+                        var styleSheetListBehavior = {
+                            get: function (_, property) {
+                                return getCurrentValue()[property];
+                            }
+                        };
+                        elements = new Proxy(elements, styleSheetListBehavior);
+                        return elements;
+                    };
+                }
+            });
         }
-        if (shouldWrapHTMLElement) {
-            Object.defineProperty(
-                Element.prototype,
-                "getElementsByTagName",
-                __assign(__assign({}, getElementsByTagNameDescriptor), {
-                    value: proxyGetElementsByTagName
-                })
+        {
+            var adoptedSheetsSourceProxies_1 = new WeakMap();
+            var adoptedSheetsProxySources_1 = new WeakMap();
+            var adoptedSheetsChangeEvent_1 = new CustomEvent(
+                "__darkreader__adoptedStyleSheetsChange"
             );
-        }
-        if (shouldProxyChildNodes) {
-            Object.defineProperty(
-                Node.prototype,
-                "childNodes",
-                __assign(__assign({}, childNodesDescriptor), {
-                    get: proxyChildNodes
-                })
+            var adoptedSheetOverrideCache_1 = new WeakSet();
+            var adoptedSheetsSnapshots_1 = new WeakMap();
+            var isDRAdoptedSheetOverride_1 = function (sheet) {
+                if (!sheet || !sheet.cssRules) {
+                    return false;
+                }
+                if (adoptedSheetOverrideCache_1.has(sheet)) {
+                    return true;
+                }
+                if (
+                    sheet.cssRules.length > 0 &&
+                    sheet.cssRules[0].cssText.startsWith(
+                        "#__darkreader__adoptedOverride"
+                    )
+                ) {
+                    adoptedSheetOverrideCache_1.add(sheet);
+                    return true;
+                }
+                return false;
+            };
+            var areArraysEqual_1 = function (a, b) {
+                return (
+                    a.length === b.length &&
+                    a.every(function (x, i) {
+                        return x === b[i];
+                    })
+                );
+            };
+            var onAdoptedSheetsChange_1 = function (node) {
+                var prev = adoptedSheetsSnapshots_1.get(node);
+                var curr = (node.adoptedStyleSheets || []).filter(function (s) {
+                    return !isDRAdoptedSheetOverride_1(s);
+                });
+                adoptedSheetsSnapshots_1.set(node, curr);
+                if (!prev || !areArraysEqual_1(prev, curr)) {
+                    curr.forEach(function (sheet) {
+                        var e_1, _a;
+                        if (!adoptedSheetOwners.has(sheet)) {
+                            adoptedSheetOwners.set(sheet, new Set());
+                        }
+                        adoptedSheetOwners.get(sheet).add(node);
+                        try {
+                            for (
+                                var _b = __values(sheet.cssRules),
+                                    _c = _b.next();
+                                !_c.done;
+                                _c = _b.next()
+                            ) {
+                                var rule = _c.value;
+                                var declaration = rule.style;
+                                if (declaration) {
+                                    adoptedDeclarationSheets.set(
+                                        declaration,
+                                        sheet
+                                    );
+                                }
+                            }
+                        } catch (e_1_1) {
+                            e_1 = {error: e_1_1};
+                        } finally {
+                            try {
+                                if (_c && !_c.done && (_a = _b.return))
+                                    _a.call(_b);
+                            } finally {
+                                if (e_1) throw e_1.error;
+                            }
+                        }
+                    });
+                    node.dispatchEvent(adoptedSheetsChangeEvent_1);
+                }
+            };
+            var proxyAdoptedSheetsArray_1 = function (node, source) {
+                if (adoptedSheetsProxySources_1.has(source)) {
+                    return source;
+                }
+                if (adoptedSheetsSourceProxies_1.has(source)) {
+                    return adoptedSheetsSourceProxies_1.get(source);
+                }
+                var proxy = new Proxy(source, {
+                    deleteProperty: function (target, property) {
+                        delete target[property];
+                        return true;
+                    },
+                    set: function (target, property, value) {
+                        target[property] = value;
+                        if (property === "length") {
+                            onAdoptedSheetsChange_1(node);
+                        }
+                        return true;
+                    }
+                });
+                adoptedSheetsSourceProxies_1.set(source, proxy);
+                adoptedSheetsProxySources_1.set(proxy, source);
+                return proxy;
+            };
+            [Document, ShadowRoot].forEach(function (ctor) {
+                overrideProperty(ctor, "adoptedStyleSheets", {
+                    get: function (native) {
+                        return function () {
+                            var source = native.call(this);
+                            return proxyAdoptedSheetsArray_1(this, source);
+                        };
+                    },
+                    set: function (native) {
+                        return function (source) {
+                            if (adoptedSheetsProxySources_1.has(source)) {
+                                source =
+                                    adoptedSheetsProxySources_1.get(source);
+                            }
+                            native.call(this, source);
+                            onAdoptedSheetsChange_1(this);
+                        };
+                    }
+                });
+            });
+            var adoptedDeclarationChangeEvent_1 = new CustomEvent(
+                "__darkreader__adoptedStyleDeclarationChange"
             );
+            ["setProperty", "removeProperty"].forEach(function (key) {
+                override(CSSStyleDeclaration, key, function (native) {
+                    return function () {
+                        var args = [];
+                        for (var _i = 0; _i < arguments.length; _i++) {
+                            args[_i] = arguments[_i];
+                        }
+                        var returnValue = native.apply(this, args);
+                        var sheet = adoptedDeclarationSheets.get(this);
+                        if (sheet) {
+                            var owners = adoptedSheetOwners.get(sheet);
+                            if (owners) {
+                                owners.forEach(function (node) {
+                                    node.dispatchEvent(
+                                        adoptedDeclarationChangeEvent_1
+                                    );
+                                });
+                            }
+                        }
+                        return returnValue;
+                    };
+                });
+            });
         }
     }
 
@@ -8256,7 +8424,7 @@
             fallback.render(theme, ignoredImageAnalysisSelectors);
             return;
         }
-        if (hasAdoptedStyleSheets(node)) {
+        if (canHaveAdoptedStyleSheets(node)) {
             node.adoptedStyleSheets.forEach(function (s) {
                 variablesStore.addRulesForMatching(s.cssRules);
             });