// ==UserScript==
// @name         Bypass detectDevTools (v3.3)
// @namespace    http://tampermonkey.net/
// @version      3.3
// @description  Neutralizes devtools detection & debugger traps (Chromium + Firefox)
// @match        *://*/*
// @grant        none
// @inject-into page
// @run-at       document-start
// ==/UserScript==
(function bootstrap() {
    'use strict';

    // ------------------------------------------------------------------
    // Resolve the REAL page window.
    //   • Chromium, @grant none          ? window IS the page realm
    //   • Firefox / sandbox mode         ? unsafeWindow (TM/VM) or
    //     window.wrappedJSObject (Firefox Xray) is the real page global
    // ------------------------------------------------------------------
    let pageWin = null;
    try { if (typeof unsafeWindow !== 'undefined' && unsafeWindow) pageWin = unsafeWindow; } catch (e) {}
    try { if (!pageWin && window.wrappedJSObject) pageWin = window.wrappedJSObject; } catch (e) {}
    if (!pageWin) pageWin = window;

    // Already in the page realm ? install directly (the Chromium fast path).
    if (pageWin === window) { install(window); return; }

    // Sandboxed ? inject the payload into the page realm as a real <script>.
    // A random flag verifies it actually ran (page CSP can block it). The flag
    // is set and deleted synchronously during bootstrap, before any page
    // script executes, so it is never observable.
    const FLAG = '__d3vtools_' + Math.random().toString(36).slice(2, 12);
    try {
        if (document.documentElement) {
            const s = document.createElement('script');
            s.textContent = '(' + install.toString() + ')(window, ' + JSON.stringify(FLAG) + ');';
            (document.head || document.documentElement).appendChild(s);
            s.remove();
        }
    } catch (e) {}
    if (pageWin[FLAG]) { try { delete pageWin[FLAG]; } catch (e) {} return; }

    // CSP blocked the script tag ? try page-realm eval (gated by unsafe-eval).
    try { pageWin.eval('(' + install.toString() + ')(window, ' + JSON.stringify(FLAG) + ');'); } catch (e) {}
    if (pageWin[FLAG]) { try { delete pageWin[FLAG]; } catch (e) {} return; }

    // Both injection paths blocked ? patch the page cross-realm from here.
    install(pageWin);

    // ==================================================================
    // PAYLOAD — must be fully self-contained: it gets serialized and run
    // inside the page when injection succeeds. Everything targets `win`.
    // ==================================================================
    function install(win, flag) {
        'use strict';
        if (flag) { try { win[flag] = 1; } catch (e) {} }

        // ---------- native-code spoofing ----------
        // In cross-realm mode the SAME proxy is installed on BOTH realms'
        // Function.prototype.toString: our functions live in this realm
        // (method lookups land here), while page-side
        // Function.prototype.toString.call(x) checks land on the page's copy.
        const registry = new Map();
        const origToString = Function.prototype.toString;
        const toStringProxy = new Proxy(origToString, {
            apply(target, thisArg, args) {
                if (registry.has(thisArg)) return registry.get(thisArg);
                return Reflect.apply(target, thisArg, args);
            }
        });
        registry.set(toStringProxy, 'function toString() { [native code] }');

        function defineToString(proto) {
            try {
                Object.defineProperty(proto, 'toString', {
                    value: toStringProxy, writable: true, configurable: true
                });
            } catch (e) {}
        }
        defineToString(Function.prototype); // this realm
        try {
            if (win.Function && win.Function.prototype !== Function.prototype) {
                defineToString(win.Function.prototype); // page realm (cross-realm mode)
            }
        } catch (e) {}

        function makeNative(fn, name) {
            const p = new Proxy(fn, {
                apply(t, ta, a) { return Reflect.apply(t, ta, a); }
            });
            registry.set(p, 'function ' + name + '() { [native code] }');
            return p;
        }

        // ---------- debugger-statement stripper ----------
        const DEBUGGER_RE = /(?<![.\w$'"`])debugger(?=\s*(?:[;}\n\r]|$))/g;
        function strip(code) {
            if (typeof code !== 'string' || code.indexOf('debugger') === -1) return code;
            try { return code.replace(DEBUGGER_RE, ';'); } catch (e) { return code; }
        }

        // ---------- eval ----------
        try {
            const origEval = win.eval;
            win.eval = makeNative(new Proxy(origEval, {
                apply(t, ta, a) {
                    if (a.length) a[0] = strip(a[0]);
                    return Reflect.apply(t, ta, a);
                }
            }), 'eval');
        } catch (e) {}

        // ---------- Function constructor ----------
        try {
            const OrigFunction = win.Function;
            const fnProxy = new Proxy(OrigFunction, {
                construct(t, a) { return Reflect.construct(t, a.map(strip)); },
                apply(t, ta, a) { return Reflect.apply(t, ta, a.map(strip)); }
            });
            win.Function = fnProxy;
            registry.set(fnProxy, 'function Function() { [native code] }');
            Object.defineProperty(OrigFunction.prototype, 'constructor', {
                value: fnProxy, writable: true, configurable: true
            });
        } catch (e) {}

        // ---------- timers & rAF ----------
        const PURE_DEBUGGER_FN = /^\s*(?:async\s+)?(?:function[\w$]*\s*\([^()]*\)|(?:\([^()]*\)|[\w$]+)\s*=>)\s*\{?\s*(?:;?\s*debugger\s*;?\s*)+\}?\s*$/;
        function sanitizeTimer(fn) {
            try {
                const src = Function.prototype.toString.call(fn);
                return PURE_DEBUGGER_FN.test(src) ? function () {} : fn;
            } catch (e) { return fn; }
        }
        function patchTimer(name, fnIsFirst) {
            try {
                const orig = win[name];
                if (typeof orig !== 'function') return;
                win[name] = makeNative(function () {
                    const args = Array.prototype.slice.call(arguments);
                    if (typeof args[0] === 'string') args[0] = strip(args[0]);
                    else if (typeof args[0] === 'function') args[0] = sanitizeTimer(args[0]);
                    return orig.apply(win, args);
                }, name);
            } catch (e) {}
        }
        patchTimer('setTimeout');
        patchTimer('setInterval');
        patchTimer('requestAnimationFrame');
        patchTimer('requestIdleCallback');

        // ---------- script text properties ----------
        function patchTextProp(proto, prop) {
            try {
                const d = Object.getOwnPropertyDescriptor(proto, prop);
                if (!d || !d.set) return;
                Object.defineProperty(proto, prop, {
                    configurable: true, enumerable: d.enumerable,
                    get() { return d.get.call(this); },
                    set(v) { d.set.call(this, strip(v)); }
                });
            } catch (e) {}
        }
        try {
            patchTextProp(win.HTMLScriptElement.prototype, 'text');
            patchTextProp(win.Node.prototype, 'textContent');
            patchTextProp(win.Element.prototype, 'innerHTML');
        } catch (e) {}

        // ---------- document.write / writeln (strip inside <script> only) ----------
        const SCRIPT_BLOCK_RE = /(<script\b[^>]*>)([\s\S]*?)(<\/script\s*>)/gi;
        function stripHTML(html) {
            if (typeof html !== 'string' || html.indexOf('debugger') === -1) return html;
            return html.replace(SCRIPT_BLOCK_RE, function (m, o, c, cl) { return o + strip(c) + cl; });
        }
        try {
            ['write', 'writeln'].forEach(function (name) {
                const orig = win.Document.prototype[name];
                win.Document.prototype[name] = makeNative(function () {
                    return orig.apply(this, Array.prototype.map.call(arguments, stripHTML));
                }, name);
            });
        } catch (e) {}

        // ---------- node insertion ----------
        function sanitizeTree(node) {
            if (!node) return;
            try {
                if (node.nodeType === 1 && String(node.nodeName).toUpperCase() === 'SCRIPT') {
                    for (let i = 0; i < node.childNodes.length; i++) {
                        const c = node.childNodes[i];
                        if (c.nodeType === 3) c.data = strip(c.data);
                    }
                } else if (node.nodeType === 11) {
                    for (let i = 0; i < node.childNodes.length; i++) sanitizeTree(node.childNodes[i]);
                }
            } catch (e) {}
        }
        function sanitizeArgs(parent, args) {
            let intoScript = false;
            try { intoScript = !!parent && String(parent.nodeName).toUpperCase() === 'SCRIPT'; } catch (e) {}
            for (let i = 0; i < args.length; i++) {
                const a = args[i];
                if (typeof a === 'string') { if (intoScript) args[i] = strip(a); }
                else if (a && a.nodeType === 3) { if (intoScript) a.data = strip(a.data); }
                else if (a && (a.nodeType === 1 || a.nodeType === 11)) sanitizeTree(a);
            }
            return args;
        }
        try {
            [
                [win.Node.prototype, 'appendChild'],
                [win.Node.prototype, 'insertBefore'],
                [win.Element.prototype, 'append'],
                [win.Element.prototype, 'prepend'],
                [win.Document.prototype, 'append'],
                [win.Document.prototype, 'prepend']
            ].forEach(function (t) {
                if (!t[0] || typeof t[0][t[1]] !== 'function') return;
                const orig = t[0][t[1]];
                t[0][t[1]] = makeNative(function () {
                    return orig.apply(this, sanitizeArgs(this, Array.prototype.slice.call(arguments)));
                }, t[1]);
            });
        } catch (e) {}

        // ---------- clock gap absorption ----------
        const GAP = 500, MAX_OFF = 60000;
        const origDateNow = win.Date.now.bind(win.Date);
        const origPerfNow = win.performance && win.performance.now
            ? win.performance.now.bind(win.performance) : null;
        let visibleAt = 0;
        try {
            (win.document || document).addEventListener('visibilitychange', function () {
                if (this.visibilityState === 'visible') visibleAt = origPerfNow();
            });
        } catch (e) {}
        function absorber(orig) {
            let offset = 0, last = orig(), prev = Infinity;
            return function () {
                const real = orig();
                const delta = real - last;
                if (delta > GAP && prev < GAP) {
                    if (!(visibleAt && origPerfNow() - visibleAt < 2000) && offset < MAX_OFF) offset += delta;
                    prev = 0;
                } else prev = delta;
                last = real;
                return real - offset;
            };
        }
        try { win.Date.now = makeNative(absorber(origDateNow), 'now'); } catch (e) {}
        try { if (origPerfNow) win.performance.now = makeNative(absorber(origPerfNow), 'now'); } catch (e) {}

        // ---------- window sizes, flags, events, console ----------
        try {
            Object.defineProperty(win, 'outerWidth', {
                configurable: true,
                get: makeNative(function () { return win.innerWidth + 15; }, 'get outerWidth')
            });
            Object.defineProperty(win, 'outerHeight', {
                configurable: true,
                get: makeNative(function () { return win.innerHeight + 88; }, 'get outerHeight')
            });
        } catch (e) {}
        ['devtools', 'firebug'].forEach(function (n) {
            try {
                Object.defineProperty(win, n, {
                    configurable: true,
                    get: makeNative(function () { return undefined; }, 'get ' + n),
                    set: makeNative(function () {}, 'set ' + n)
                });
            } catch (e) {}
        });
        try {
            win.addEventListener('devtoolschange', function (e) {
                e.stopImmediatePropagation();
            }, true);
        } catch (e) {}
        try {
            if (win.console && win.console.clear) win.console.clear = makeNative(function () {}, 'clear');
        } catch (e) {}
    }
})();