(function () {
    "use strict";

    function injectProxy(
        enableStyleSheetsProxy,
        enableCustomElementRegistryProxy
    ) {
        document.dispatchEvent(
            new CustomEvent("__darkreader__inlineScriptsAllowed")
        );
        const cleaners = [];
        function cleanUp() {
            cleaners.forEach((clean) => clean());
            cleaners.splice(0);
        }
        function documentEventListener(type, listener, options) {
            document.addEventListener(type, listener, options);
            cleaners.push(() => document.removeEventListener(type, listener));
        }
        function disableConflictingPlugins() {
            const disableWPDarkMode = () => {
                if (window?.WPDarkMode?.deactivate) {
                    window.WPDarkMode.deactivate();
                }
            };
            disableWPDarkMode();
        }
        documentEventListener("__darkreader__cleanUp", cleanUp);
        documentEventListener(
            "__darkreader__disableConflictingPlugins",
            disableConflictingPlugins
        );
        function overrideProperty(cls, prop, overrides) {
            const proto = cls.prototype;
            const oldDescriptor = Object.getOwnPropertyDescriptor(proto, prop);
            const newDescriptor = {...oldDescriptor};
            Object.keys(overrides).forEach((key) => {
                const factory = overrides[key];
                newDescriptor[key] = factory(oldDescriptor[key]);
            });
            Object.defineProperty(proto, prop, newDescriptor);
            cleaners.push(() =>
                Object.defineProperty(proto, prop, oldDescriptor)
            );
        }
        function override(cls, prop, factory) {
            overrideProperty(cls, prop, {value: factory});
        }
        function isDRElement(element) {
            return element?.classList?.contains("darkreader");
        }
        function isDRSheet(sheet) {
            return isDRElement(sheet.ownerNode);
        }
        const updateSheetEvent = new CustomEvent("__darkreader__updateSheet");
        const adoptedSheetChangeEvent = new CustomEvent(
            "__darkreader__adoptedStyleSheetChange"
        );
        const adoptedSheetOwners = new WeakMap();
        const adoptedDeclarationSheets = new WeakMap();
        function onAdoptedSheetChange(sheet) {
            const owners = adoptedSheetOwners.get(sheet);
            owners?.forEach((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 reportSheetChangeAsync(sheet, promise) {
            const {ownerNode} = sheet;
            if (
                ownerNode &&
                !isDRSheet(sheet) &&
                promise &&
                promise instanceof Promise
            ) {
                promise.then(() => ownerNode.dispatchEvent(updateSheetEvent));
            }
            if (adoptedSheetOwners.has(sheet)) {
                if (promise && promise instanceof Promise) {
                    promise.then(() => onAdoptedSheetChange(sheet));
                }
            }
        }
        override(
            CSSStyleSheet,
            "addRule",
            (native) =>
                function (selector, style, index) {
                    native.call(this, selector, style, index);
                    reportSheetChange(this);
                    return -1;
                }
        );
        override(
            CSSStyleSheet,
            "insertRule",
            (native) =>
                function (rule, index) {
                    const returnValue = native.call(this, rule, index);
                    reportSheetChange(this);
                    return returnValue;
                }
        );
        override(
            CSSStyleSheet,
            "deleteRule",
            (native) =>
                function (index) {
                    native.call(this, index);
                    reportSheetChange(this);
                }
        );
        override(
            CSSStyleSheet,
            "removeRule",
            (native) =>
                function (index) {
                    native.call(this, index);
                    reportSheetChange(this);
                }
        );
        override(
            CSSStyleSheet,
            "replace",
            (native) =>
                function (cssText) {
                    const returnValue = native.call(this, cssText);
                    reportSheetChangeAsync(this, returnValue);
                    return returnValue;
                }
        );
        override(
            CSSStyleSheet,
            "replaceSync",
            (native) =>
                function (cssText) {
                    native.call(this, cssText);
                    reportSheetChange(this);
                }
        );
        const shouldWrapHTMLElement =
            location.hostname === "baidu.com" ||
            location.hostname.endsWith(".baidu.com");
        if (shouldWrapHTMLElement) {
            override(
                Element,
                "getElementsByTagName",
                (native) =>
                    function (tagName) {
                        if (tagName !== "style") {
                            return native.call(this, tagName);
                        }
                        const getCurrentElementValue = () => {
                            const elements = native.call(this, tagName);
                            return Object.setPrototypeOf(
                                [...elements].filter(
                                    (element) =>
                                        element && !isDRElement(element)
                                ),
                                NodeList.prototype
                            );
                        };
                        let elements = getCurrentElementValue();
                        const nodeListBehavior = {
                            get: function (_, property) {
                                return getCurrentElementValue()[
                                    Number(property) || property
                                ];
                            }
                        };
                        elements = new Proxy(elements, nodeListBehavior);
                        return elements;
                    }
            );
        }
        const shouldProxyChildNodes = ["brilliant.org", "www.vy.no"].includes(
            location.hostname
        );
        if (shouldProxyChildNodes) {
            overrideProperty(Node, "childNodes", {
                get: (native) =>
                    function () {
                        const childNodes = native.call(this);
                        return Object.setPrototypeOf(
                            [...childNodes].filter((element) => {
                                return !isDRElement(element);
                            }),
                            NodeList.prototype
                        );
                    }
            });
        }
        function resolveCustomElement(tag) {
            customElements.whenDefined(tag).then(() => {
                document.dispatchEvent(
                    new CustomEvent("__darkreader__isDefined", {detail: {tag}})
                );
            });
        }
        documentEventListener("__darkreader__addUndefinedResolver", (e) =>
            resolveCustomElement(e.detail.tag)
        );
        if (enableCustomElementRegistryProxy) {
            override(
                CustomElementRegistry,
                "define",
                (native) =>
                    function (name, constructor, options) {
                        resolveCustomElement(name);
                        native.call(this, name, constructor, options);
                    }
            );
        }
        async function checkBlobURLSupport() {
            const svg =
                '<svg xmlns="http://www.w3.org/2000/svg" width="1" height="1"><rect width="1" height="1" fill="transparent"/></svg>';
            const bytes = new Uint8Array(svg.length);
            for (let i = 0; i < svg.length; i++) {
                bytes[i] = svg.charCodeAt(i);
            }
            const blob = new Blob([bytes], {type: "image/svg+xml"});
            const objectURL = URL.createObjectURL(blob);
            let blobURLAllowed;
            try {
                const image = new Image();
                await new Promise((resolve, reject) => {
                    image.onload = () => resolve();
                    image.onerror = () => reject();
                    image.src = objectURL;
                });
                blobURLAllowed = true;
            } catch (err) {
                blobURLAllowed = false;
            }
            document.dispatchEvent(
                new CustomEvent("__darkreader__blobURLCheckResponse", {
                    detail: {blobURLAllowed}
                })
            );
        }
        documentEventListener(
            "__darkreader__blobURLCheckRequest",
            checkBlobURLSupport,
            {once: true}
        );
        if (enableStyleSheetsProxy) {
            overrideProperty(Document, "styleSheets", {
                get: (native) =>
                    function () {
                        const getCurrentValue = () => {
                            const docSheets = native.call(this);
                            const filteredSheets = [...docSheets].filter(
                                (styleSheet) =>
                                    styleSheet.ownerNode &&
                                    !isDRSheet(styleSheet)
                            );
                            filteredSheets.item = (item) =>
                                filteredSheets[item];
                            return Object.setPrototypeOf(
                                filteredSheets,
                                StyleSheetList.prototype
                            );
                        };
                        let elements = getCurrentValue();
                        const styleSheetListBehavior = {
                            get: function (_, property) {
                                return getCurrentValue()[property];
                            }
                        };
                        elements = new Proxy(elements, styleSheetListBehavior);
                        return elements;
                    }
            });
        }
        {
            const adoptedSheetsSourceProxies = new WeakMap();
            const adoptedSheetsProxySources = new WeakMap();
            const adoptedSheetsChangeEvent = new CustomEvent(
                "__darkreader__adoptedStyleSheetsChange"
            );
            const adoptedSheetOverrideCache = new WeakSet();
            const adoptedSheetsSnapshots = new WeakMap();
            const isDRAdoptedSheetOverride = (sheet) => {
                if (!sheet || !sheet.cssRules) {
                    return false;
                }
                if (adoptedSheetOverrideCache.has(sheet)) {
                    return true;
                }
                if (
                    sheet.cssRules.length > 0 &&
                    sheet.cssRules[0].cssText.startsWith(
                        "#__darkreader__adoptedOverride"
                    )
                ) {
                    adoptedSheetOverrideCache.add(sheet);
                    return true;
                }
                return false;
            };
            const areArraysEqual = (a, b) => {
                return a.length === b.length && a.every((x, i) => x === b[i]);
            };
            const onAdoptedSheetsChange = (node) => {
                const prev = adoptedSheetsSnapshots.get(node);
                const curr = (node.adoptedStyleSheets || []).filter(
                    (s) => !isDRAdoptedSheetOverride(s)
                );
                adoptedSheetsSnapshots.set(node, curr);
                if (!prev || !areArraysEqual(prev, curr)) {
                    curr.forEach((sheet) => {
                        if (!adoptedSheetOwners.has(sheet)) {
                            adoptedSheetOwners.set(sheet, new Set());
                        }
                        adoptedSheetOwners.get(sheet).add(node);
                        for (const rule of sheet.cssRules) {
                            const declaration = rule.style;
                            if (declaration) {
                                adoptedDeclarationSheets.set(
                                    declaration,
                                    sheet
                                );
                            }
                        }
                    });
                    node.dispatchEvent(adoptedSheetsChangeEvent);
                }
            };
            const proxyAdoptedSheetsArray = (node, source) => {
                if (adoptedSheetsProxySources.has(source)) {
                    return source;
                }
                if (adoptedSheetsSourceProxies.has(source)) {
                    return adoptedSheetsSourceProxies.get(source);
                }
                const proxy = new Proxy(source, {
                    deleteProperty(target, property) {
                        delete target[property];
                        return true;
                    },
                    set(target, property, value) {
                        target[property] = value;
                        if (property === "length") {
                            onAdoptedSheetsChange(node);
                        }
                        return true;
                    }
                });
                adoptedSheetsSourceProxies.set(source, proxy);
                adoptedSheetsProxySources.set(proxy, source);
                return proxy;
            };
            [Document, ShadowRoot].forEach((ctor) => {
                overrideProperty(ctor, "adoptedStyleSheets", {
                    get: (native) =>
                        function () {
                            const source = native.call(this);
                            return proxyAdoptedSheetsArray(this, source);
                        },
                    set: (native) =>
                        function (source) {
                            if (adoptedSheetsProxySources.has(source)) {
                                source = adoptedSheetsProxySources.get(source);
                            }
                            native.call(this, source);
                            onAdoptedSheetsChange(this);
                        }
                });
            });
            const adoptedDeclarationChangeEvent = new CustomEvent(
                "__darkreader__adoptedStyleDeclarationChange"
            );
            ["setProperty", "removeProperty"].forEach((key) => {
                override(CSSStyleDeclaration, key, (native) => {
                    return function (...args) {
                        const returnValue = native.apply(this, args);
                        const sheet = adoptedDeclarationSheets.get(this);
                        if (sheet) {
                            const owners = adoptedSheetOwners.get(sheet);
                            if (owners) {
                                owners.forEach((node) => {
                                    node.dispatchEvent(
                                        adoptedDeclarationChangeEvent
                                    );
                                });
                            }
                        }
                        return returnValue;
                    };
                });
            });
        }
    }

    var MessageTypeUItoBG;
    (function (MessageTypeUItoBG) {
        MessageTypeUItoBG["GET_DATA"] = "ui-bg-get-data";
        MessageTypeUItoBG["GET_DEVTOOLS_DATA"] = "ui-bg-get-devtools-data";
        MessageTypeUItoBG["SUBSCRIBE_TO_CHANGES"] =
            "ui-bg-subscribe-to-changes";
        MessageTypeUItoBG["UNSUBSCRIBE_FROM_CHANGES"] =
            "ui-bg-unsubscribe-from-changes";
        MessageTypeUItoBG["CHANGE_SETTINGS"] = "ui-bg-change-settings";
        MessageTypeUItoBG["SET_THEME"] = "ui-bg-set-theme";
        MessageTypeUItoBG["TOGGLE_ACTIVE_TAB"] = "ui-bg-toggle-active-tab";
        MessageTypeUItoBG["MARK_NEWS_AS_READ"] = "ui-bg-mark-news-as-read";
        MessageTypeUItoBG["MARK_NEWS_AS_DISPLAYED"] =
            "ui-bg-mark-news-as-displayed";
        MessageTypeUItoBG["LOAD_CONFIG"] = "ui-bg-load-config";
        MessageTypeUItoBG["APPLY_DEV_DYNAMIC_THEME_FIXES"] =
            "ui-bg-apply-dev-dynamic-theme-fixes";
        MessageTypeUItoBG["RESET_DEV_DYNAMIC_THEME_FIXES"] =
            "ui-bg-reset-dev-dynamic-theme-fixes";
        MessageTypeUItoBG["APPLY_DEV_INVERSION_FIXES"] =
            "ui-bg-apply-dev-inversion-fixes";
        MessageTypeUItoBG["RESET_DEV_INVERSION_FIXES"] =
            "ui-bg-reset-dev-inversion-fixes";
        MessageTypeUItoBG["APPLY_DEV_STATIC_THEMES"] =
            "ui-bg-apply-dev-static-themes";
        MessageTypeUItoBG["RESET_DEV_STATIC_THEMES"] =
            "ui-bg-reset-dev-static-themes";
        MessageTypeUItoBG["COLOR_SCHEME_CHANGE"] = "ui-bg-color-scheme-change";
        MessageTypeUItoBG["HIDE_HIGHLIGHTS"] = "ui-bg-hide-highlights";
    })(MessageTypeUItoBG || (MessageTypeUItoBG = {}));
    var MessageTypeBGtoUI;
    (function (MessageTypeBGtoUI) {
        MessageTypeBGtoUI["CHANGES"] = "bg-ui-changes";
    })(MessageTypeBGtoUI || (MessageTypeBGtoUI = {}));
    var DebugMessageTypeBGtoUI;
    (function (DebugMessageTypeBGtoUI) {
        DebugMessageTypeBGtoUI["CSS_UPDATE"] = "debug-bg-ui-css-update";
        DebugMessageTypeBGtoUI["UPDATE"] = "debug-bg-ui-update";
    })(DebugMessageTypeBGtoUI || (DebugMessageTypeBGtoUI = {}));
    var MessageTypeBGtoCS;
    (function (MessageTypeBGtoCS) {
        MessageTypeBGtoCS["ADD_CSS_FILTER"] = "bg-cs-add-css-filter";
        MessageTypeBGtoCS["ADD_DYNAMIC_THEME"] = "bg-cs-add-dynamic-theme";
        MessageTypeBGtoCS["ADD_STATIC_THEME"] = "bg-cs-add-static-theme";
        MessageTypeBGtoCS["ADD_SVG_FILTER"] = "bg-cs-add-svg-filter";
        MessageTypeBGtoCS["CLEAN_UP"] = "bg-cs-clean-up";
        MessageTypeBGtoCS["FETCH_RESPONSE"] = "bg-cs-fetch-response";
        MessageTypeBGtoCS["UNSUPPORTED_SENDER"] = "bg-cs-unsupported-sender";
    })(MessageTypeBGtoCS || (MessageTypeBGtoCS = {}));
    var DebugMessageTypeBGtoCS;
    (function (DebugMessageTypeBGtoCS) {
        DebugMessageTypeBGtoCS["RELOAD"] = "debug-bg-cs-reload";
    })(DebugMessageTypeBGtoCS || (DebugMessageTypeBGtoCS = {}));
    var MessageTypeCStoBG;
    (function (MessageTypeCStoBG) {
        MessageTypeCStoBG["COLOR_SCHEME_CHANGE"] = "cs-bg-color-scheme-change";
        MessageTypeCStoBG["DARK_THEME_DETECTED"] = "cs-bg-dark-theme-detected";
        MessageTypeCStoBG["DARK_THEME_NOT_DETECTED"] =
            "cs-bg-dark-theme-not-detected";
        MessageTypeCStoBG["FETCH"] = "cs-bg-fetch";
        MessageTypeCStoBG["DOCUMENT_CONNECT"] = "cs-bg-document-connect";
        MessageTypeCStoBG["DOCUMENT_FORGET"] = "cs-bg-document-forget";
        MessageTypeCStoBG["DOCUMENT_FREEZE"] = "cs-bg-document-freeze";
        MessageTypeCStoBG["DOCUMENT_RESUME"] = "cs-bg-document-resume";
    })(MessageTypeCStoBG || (MessageTypeCStoBG = {}));
    var DebugMessageTypeCStoBG;
    (function (DebugMessageTypeCStoBG) {
        DebugMessageTypeCStoBG["LOG"] = "debug-cs-bg-log";
    })(DebugMessageTypeCStoBG || (DebugMessageTypeCStoBG = {}));
    var MessageTypeCStoUI;
    (function (MessageTypeCStoUI) {
        MessageTypeCStoUI["EXPORT_CSS_RESPONSE"] = "cs-ui-export-css-response";
    })(MessageTypeCStoUI || (MessageTypeCStoUI = {}));
    var MessageTypeUItoCS;
    (function (MessageTypeUItoCS) {
        MessageTypeUItoCS["EXPORT_CSS"] = "ui-cs-export-css";
    })(MessageTypeUItoCS || (MessageTypeUItoCS = {}));

    function logInfo(...args) {}

    document.currentScript && document.currentScript.remove();
    const key = "darkreaderProxyInjected";
    const EVENT_DONE = "__darkreader__stylesheetProxy__done";
    const EVENT_ARG = "__darkreader__stylesheetProxy__arg";
    const registeredScriptPath = !document.currentScript;
    function injectProxyAndCleanup(args) {
        injectProxy(
            args.enableStyleSheetsProxy,
            args.enableCustomElementRegistryProxy
        );
        doneReceiver();
        document.dispatchEvent(new CustomEvent(EVENT_DONE));
    }
    function regularPath() {
        const argString = document.currentScript.dataset.arg;
        if (argString !== undefined) {
            document.documentElement.dataset[key] = "true";
            const args = JSON.parse(argString);
            injectProxyAndCleanup(args);
        }
    }
    function dataReceiver(e) {
        document.removeEventListener(EVENT_ARG, dataReceiver);
        if (document.documentElement.dataset[key] !== undefined) {
            return;
        }
        document.documentElement.dataset[key] = "true";
        logInfo(
            `MV3 proxy injector: ${registeredScriptPath ? "registered" : "dedicated"} path runs injectProxy(${e.detail}).`
        );
        injectProxyAndCleanup(e.detail);
    }
    function doneReceiver() {
        document.removeEventListener(EVENT_ARG, dataReceiver);
        document.removeEventListener(EVENT_DONE, doneReceiver);
    }
    function dedicatedPath() {
        const listenerOptions = {
            passive: true,
            once: true
        };
        document.addEventListener(EVENT_ARG, dataReceiver, listenerOptions);
        document.addEventListener(EVENT_DONE, doneReceiver, listenerOptions);
    }
    function inject() {
        if (document.documentElement.dataset[key] !== undefined) {
            return;
        }
        document.currentScript && regularPath();
        dedicatedPath();
    }
    inject();
})();