cloakbrowser 0.3.22 → 0.3.23

package/dist/human-puppeteer/index.js

@@ -0,0 +1,780 @@
+/**
+ * Human-like behavioral layer for cloakbrowser — Puppeteer edition.
+ *
+ * Mirrors Playwright humanize architecture, adapted for Puppeteer API.
+ *
+ * Patches ALL native Puppeteer interaction surfaces:
+ *
+ * PAGE-LEVEL:
+ *   click (with clickCount support for dblclick), hover, type,
+ *   select, focus, tap, goto
+ *
+ * MOUSE:
+ *   move, click (with clickCount support for dblclick), wheel,
+ *   dragAndDrop
+ *
+ * KEYBOARD:
+ *   type, down, up, press, sendCharacter
+ *
+ * FRAME-LEVEL:
+ *   click, hover, type, select, focus, tap
+ *   + $, $$, waitForSelector (return patched ElementHandles)
+ *
+ * ELEMENTHANDLE-LEVEL (Puppeteer-specific, no Playwright equivalent):
+ *   click (with clickCount), hover, type, press, tap, select,
+ *   focus, drop, dragAndDrop
+ *   + $, $$, waitForSelector (nested elements are also patched)
+ *
+ * BROWSER-LEVEL:
+ *   newPage, createBrowserContext / createIncognitoBrowserContext,
+ *   targetcreated event
+ *
+ * Stealth-aware:
+ *   - isInputElement / isSelectorFocused use CDP Isolated Worlds
+ *   - Shift symbol typing uses CDP Input.dispatchKeyEvent (isTrusted=true)
+ *   - ElementHandle isInput check uses CDP DOM.describeNode (no JS execution)
+ *   - Falls back to page.evaluate only when CDP session is unavailable
+ *
+ * Puppeteer-specific adaptations:
+ *   - page.createCDPSession() instead of context.newCDPSession(page)
+ *   - page.viewport() instead of page.viewportSize()
+ *   - page.$(selector) instead of page.locator(selector)
+ *   - keyboard.sendCharacter() mapped via RawKeyboard.insertText
+ *   - mouse.wheel({deltaX, deltaY}) object form adapted to (dx, dy)
+ *   - page.select() instead of page.selectOption()
+ *   - ElementHandle prototype patching (Puppeteer-only)
+ *   - No page.dblclick() — Puppeteer uses click({clickCount:2})
+ */
+import { rand, randRange, sleep } from '../human/config.js';
+import { humanMove, humanClick, clickTarget, humanIdle } from '../human/mouse.js';
+import { humanType } from './keyboard.js';
+import { scrollToElement, smoothWheel } from './scroll.js';
+export { resolveConfig } from '../human/config.js';
+export { humanMove, humanClick, clickTarget, humanIdle } from '../human/mouse.js';
+export { humanType } from './keyboard.js';
+export { scrollToElement } from './scroll.js';
+// ============================================================================
+// CDP Isolated World — stealth DOM evaluation (Puppeteer version)
+// ============================================================================
+class StealthEval {
+    cdp = null;
+    contextId = null;
+    page;
+    constructor(page) {
+        this.page = page;
+    }
+    async ensureCdp() {
+        if (!this.cdp) {
+            this.cdp = await this.page.createCDPSession();
+        }
+        return this.cdp;
+    }
+    async createWorld() {
+        const cdp = await this.ensureCdp();
+        const tree = await cdp.send('Page.getFrameTree');
+        const frameId = tree.frameTree.frame.id;
+        const result = await cdp.send('Page.createIsolatedWorld', {
+            frameId,
+            worldName: '',
+            grantUniveralAccess: true,
+        });
+        const ctxId = result.executionContextId;
+        this.contextId = ctxId;
+        return ctxId;
+    }
+    async evaluate(expression) {
+        if (this.contextId === null) {
+            await this.createWorld();
+        }
+        for (let attempt = 0; attempt < 2; attempt++) {
+            try {
+                const cdp = await this.ensureCdp();
+                const result = await cdp.send('Runtime.evaluate', {
+                    expression,
+                    contextId: this.contextId,
+                    returnByValue: true,
+                });
+                if (result.exceptionDetails) {
+                    if (attempt === 0) {
+                        await this.createWorld();
+                        continue;
+                    }
+                    return undefined;
+                }
+                return result.result?.value;
+            }
+            catch {
+                if (attempt === 0) {
+                    this.contextId = null;
+                    try {
+                        await this.createWorld();
+                    }
+                    catch {
+                        return undefined;
+                    }
+                    continue;
+                }
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    invalidate() {
+        this.contextId = null;
+    }
+    async getCdpSession() {
+        return this.ensureCdp();
+    }
+}
+// ============================================================================
+// Cursor state
+// ============================================================================
+class CursorState {
+    x = 0;
+    y = 0;
+    initialized = false;
+}
+// ============================================================================
+// Stealth DOM queries
+// ============================================================================
+async function isInputElement(stealth, page, selector) {
+    if (stealth) {
+        try {
+            const escaped = JSON.stringify(selector);
+            const result = await stealth.evaluate(`
+        (() => {
+          const el = document.querySelector(${escaped});
+          if (!el) return false;
+          const tag = el.tagName.toLowerCase();
+          return tag === 'input' || tag === 'textarea'
+            || el.getAttribute('contenteditable') === 'true';
+        })()
+      `);
+            return !!result;
+        }
+        catch { /* fallthrough */ }
+    }
+    return page.evaluate((sel) => {
+        const el = document.querySelector(sel);
+        if (!el)
+            return false;
+        const tag = el.tagName.toLowerCase();
+        return tag === 'input' || tag === 'textarea'
+            || el.getAttribute('contenteditable') === 'true';
+    }, selector).catch(() => false);
+}
+async function isSelectorFocused(stealth, page, selector) {
+    if (stealth) {
+        try {
+            const escaped = JSON.stringify(selector);
+            const result = await stealth.evaluate(`
+        (() => {
+          const el = document.querySelector(${escaped});
+          return el === document.activeElement;
+        })()
+      `);
+            return !!result;
+        }
+        catch { /* fallthrough */ }
+    }
+    return page.evaluate((sel) => {
+        const el = document.querySelector(sel);
+        return el === document.activeElement;
+    }, selector).catch(() => false);
+}
+// ============================================================================
+// Stealth ElementHandle input check — uses CDP DOM.describeNode
+// instead of el.evaluate() to avoid main-world JS execution.
+// ============================================================================
+async function isInputElementHandle(stealth, el) {
+    if (stealth) {
+        try {
+            const cdp = await stealth.getCdpSession();
+            const remoteObject = el.remoteObject?.();
+            if (remoteObject?.objectId) {
+                const { node } = await cdp.send('DOM.describeNode', {
+                    objectId: remoteObject.objectId,
+                });
+                const tag = (node?.nodeName || '').toLowerCase();
+                if (tag === 'input' || tag === 'textarea')
+                    return true;
+                const attrs = node?.attributes || [];
+                for (let i = 0; i < attrs.length; i += 2) {
+                    if (attrs[i] === 'contenteditable' && attrs[i + 1] === 'true') {
+                        return true;
+                    }
+                }
+                return false;
+            }
+        }
+        catch { /* fallthrough to el.evaluate */ }
+    }
+    return el.evaluate((node) => {
+        const tag = node.tagName?.toLowerCase();
+        return tag === 'input' || tag === 'textarea'
+            || node.getAttribute?.('contenteditable') === 'true';
+    }).catch(() => false);
+}
+// ============================================================================
+// Page-level patching
+// ============================================================================
+function patchPage(page, cfg, cursor) {
+    const originals = {
+        click: page.click.bind(page),
+        hover: page.hover.bind(page),
+        type: page.type.bind(page),
+        select: page.select.bind(page),
+        focus: page.focus.bind(page),
+        goto: page.goto.bind(page),
+        tap: page.tap.bind(page),
+        mouseMove: page.mouse.move.bind(page.mouse),
+        mouseClick: page.mouse.click.bind(page.mouse),
+        mouseDown: page.mouse.down.bind(page.mouse),
+        mouseUp: page.mouse.up.bind(page.mouse),
+        mouseWheel: page.mouse.wheel?.bind(page.mouse),
+        mouseDragAndDrop: page.mouse.dragAndDrop?.bind(page.mouse),
+        keyboardType: page.keyboard.type.bind(page.keyboard),
+        keyboardDown: page.keyboard.down.bind(page.keyboard),
+        keyboardUp: page.keyboard.up.bind(page.keyboard),
+        keyboardPress: page.keyboard.press.bind(page.keyboard),
+        keyboardSendCharacter: page.keyboard.sendCharacter.bind(page.keyboard),
+    };
+    page._original = originals;
+    page._humanCfg = cfg;
+    const stealth = new StealthEval(page);
+    page._stealth = stealth;
+    let cdpSession = null;
+    const ensureCdp = async () => {
+        if (!cdpSession) {
+            try {
+                cdpSession = await stealth.getCdpSession();
+            }
+            catch { }
+        }
+        return cdpSession;
+    };
+    const raw = {
+        move: originals.mouseMove,
+        down: originals.mouseDown,
+        up: originals.mouseUp,
+        wheel: async (deltaX, deltaY) => {
+            if (originals.mouseWheel) {
+                await originals.mouseWheel({ deltaX, deltaY });
+            }
+        },
+    };
+    const rawKb = {
+        down: originals.keyboardDown,
+        up: originals.keyboardUp,
+        type: originals.keyboardType,
+        insertText: originals.keyboardSendCharacter,
+    };
+    async function ensureCursorInit() {
+        if (!cursor.initialized) {
+            cursor.x = rand(cfg.initial_cursor_x[0], cfg.initial_cursor_x[1]);
+            cursor.y = rand(cfg.initial_cursor_y[0], cfg.initial_cursor_y[1]);
+            await originals.mouseMove(cursor.x, cursor.y);
+            cursor.initialized = true;
+        }
+    }
+    // ==== goto ====
+    const humanGoto = async (url, options) => {
+        const response = await originals.goto(url, options);
+        stealth.invalidate();
+        patchFrames(page, cfg, cursor, raw, rawKb, originals, stealth);
+        return response;
+    };
+    // ==== click (with clickCount support for dblclick) ====
+    const humanClickFn = async (selector, options) => {
+        await ensureCursorInit();
+        if (cfg.idle_between_actions) {
+            await humanIdle(raw, rand(cfg.idle_between_duration[0], cfg.idle_between_duration[1]), cursor.x, cursor.y, cfg);
+        }
+        const { box, cursorX, cursorY } = await scrollToElement(page, raw, selector, cursor.x, cursor.y, cfg);
+        cursor.x = cursorX;
+        cursor.y = cursorY;
+        const isInput = await isInputElement(stealth, page, selector);
+        const target = clickTarget(box, isInput, cfg);
+        await humanMove(raw, cursor.x, cursor.y, target.x, target.y, cfg);
+        cursor.x = target.x;
+        cursor.y = target.y;
+        const clickCount = options?.clickCount ?? options?.count ?? 1;
+        if (clickCount >= 2) {
+            await humanClick(raw, isInput, cfg);
+            await sleep(rand(40, 90));
+            await raw.down({ clickCount: 2 });
+            await sleep(rand(30, 60));
+            await raw.up({ clickCount: 2 });
+        }
+        else {
+            await humanClick(raw, isInput, cfg);
+        }
+    };
+    // ==== hover ====
+    const humanHoverFn = async (selector, options) => {
+        await ensureCursorInit();
+        if (cfg.idle_between_actions) {
+            await humanIdle(raw, rand(cfg.idle_between_duration[0], cfg.idle_between_duration[1]), cursor.x, cursor.y, cfg);
+        }
+        const { box, cursorX, cursorY } = await scrollToElement(page, raw, selector, cursor.x, cursor.y, cfg);
+        cursor.x = cursorX;
+        cursor.y = cursorY;
+        const target = clickTarget(box, false, cfg);
+        await humanMove(raw, cursor.x, cursor.y, target.x, target.y, cfg);
+        cursor.x = target.x;
+        cursor.y = target.y;
+    };
+    // ==== type ====
+    const humanTypeFn = async (selector, text, options) => {
+        await sleep(randRange(cfg.field_switch_delay));
+        await humanClickFn(selector);
+        await sleep(rand(100, 250));
+        const cdp = await ensureCdp();
+        await humanType(page, rawKb, text, cfg, cdp);
+    };
+    // ==== select ====
+    const humanSelectFn = async (selector, ...values) => {
+        await humanHoverFn(selector);
+        await sleep(rand(100, 300));
+        return originals.select(selector, ...values);
+    };
+    // ==== focus ====
+    const humanFocusFn = async (selector) => {
+        if (!await isSelectorFocused(stealth, page, selector)) {
+            await humanClickFn(selector);
+        }
+    };
+    // ==== tap ====
+    const humanTapFn = async (selector, options) => {
+        await humanClickFn(selector, options);
+    };
+    // ============================================================
+    // Assign page-level patches
+    // ============================================================
+    page.goto = humanGoto;
+    page.click = humanClickFn;
+    page.hover = humanHoverFn;
+    page.type = humanTypeFn;
+    page.select = humanSelectFn;
+    page.focus = humanFocusFn;
+    page.tap = humanTapFn;
+    // ============================================================
+    // Mouse patches
+    // ============================================================
+    page.mouse.move = async (x, y, options) => {
+        await ensureCursorInit();
+        await humanMove(raw, cursor.x, cursor.y, x, y, cfg);
+        cursor.x = x;
+        cursor.y = y;
+    };
+    page.mouse.click = async (x, y, options) => {
+        await ensureCursorInit();
+        await humanMove(raw, cursor.x, cursor.y, x, y, cfg);
+        cursor.x = x;
+        cursor.y = y;
+        const clickCount = options?.clickCount ?? options?.count ?? 1;
+        if (clickCount >= 2) {
+            await humanClick(raw, false, cfg);
+            await sleep(rand(40, 90));
+            await raw.down({ clickCount: 2 });
+            await sleep(rand(30, 60));
+            await raw.up({ clickCount: 2 });
+        }
+        else {
+            await humanClick(raw, false, cfg);
+        }
+    };
+    if (originals.mouseWheel) {
+        page.mouse.wheel = async (options) => {
+            const dx = options?.deltaX ?? 0;
+            const dy = options?.deltaY ?? 0;
+            if (Math.abs(dy) > 0) {
+                await smoothWheel(raw, dy, cfg, 'y');
+            }
+            if (Math.abs(dx) > 0) {
+                await smoothWheel(raw, dx, cfg, 'x');
+            }
+        };
+    }
+    if (originals.mouseDragAndDrop) {
+        page.mouse.dragAndDrop = async (start, target, options) => {
+            await ensureCursorInit();
+            await humanMove(raw, cursor.x, cursor.y, start.x, start.y, cfg);
+            cursor.x = start.x;
+            cursor.y = start.y;
+            await sleep(rand(100, 200));
+            await originals.mouseDown();
+            await sleep(rand(80, 150));
+            await humanMove(raw, cursor.x, cursor.y, target.x, target.y, cfg);
+            cursor.x = target.x;
+            cursor.y = target.y;
+            await sleep(rand(80, 150));
+            await originals.mouseUp();
+        };
+    }
+    // ============================================================
+    // Keyboard patches
+    // ============================================================
+    page.keyboard.type = async (text, options) => {
+        const cdp = await ensureCdp();
+        await humanType(page, rawKb, text, cfg, cdp);
+    };
+    page.keyboard.press = async (key, options) => {
+        await sleep(rand(20, 60));
+        await originals.keyboardDown(key);
+        await sleep(randRange(cfg.key_hold));
+        await originals.keyboardUp(key);
+    };
+    page.keyboard.down = async (key) => {
+        await sleep(rand(10, 30));
+        await originals.keyboardDown(key);
+    };
+    page.keyboard.up = async (key) => {
+        await sleep(rand(10, 30));
+        await originals.keyboardUp(key);
+    };
+    // ============================================================
+    // Store helpers for frame/element patching
+    // ============================================================
+    page._humanCursor = cursor;
+    page._humanRaw = raw;
+    page._humanRawKb = rawKb;
+    page._ensureCursorInit = ensureCursorInit;
+    // Initialize cursor
+    cursor.x = rand(cfg.initial_cursor_x[0], cfg.initial_cursor_x[1]);
+    cursor.y = rand(cfg.initial_cursor_y[0], cfg.initial_cursor_y[1]);
+    originals.mouseMove(cursor.x, cursor.y).then(() => {
+        cursor.initialized = true;
+    }).catch(() => { });
+    // Patch frames
+    patchFrames(page, cfg, cursor, raw, rawKb, originals, stealth);
+    // Patch ElementHandle selectors
+    patchElementHandle(page, cfg, cursor, raw, rawKb, originals, stealth);
+}
+// ============================================================================
+// ElementHandle patching — PUPPETEER-SPECIFIC
+// ============================================================================
+function patchElementHandle(page, cfg, cursor, raw, rawKb, originals, stealth) {
+    const orig$ = page.$.bind(page);
+    const orig$$ = page.$$.bind(page);
+    const origWaitForSelector = page.waitForSelector.bind(page);
+    page.$ = async (selector) => {
+        const el = await orig$(selector);
+        if (el)
+            patchSingleElementHandle(el, page, cfg, cursor, raw, rawKb, originals, stealth);
+        return el;
+    };
+    page.$$ = async (selector) => {
+        const els = await orig$$(selector);
+        for (const el of els) {
+            patchSingleElementHandle(el, page, cfg, cursor, raw, rawKb, originals, stealth);
+        }
+        return els;
+    };
+    page.waitForSelector = async (selector, options) => {
+        const el = await origWaitForSelector(selector, options);
+        if (el)
+            patchSingleElementHandle(el, page, cfg, cursor, raw, rawKb, originals, stealth);
+        return el;
+    };
+}
+function patchSingleElementHandle(el, page, cfg, cursor, raw, rawKb, originals, stealth) {
+    if (el._humanPatched)
+        return;
+    el._humanPatched = true;
+    const origElClick = el.click.bind(el);
+    const origElHover = el.hover.bind(el);
+    const origElType = el.type.bind(el);
+    const origElPress = el.press?.bind(el);
+    const origElTap = el.tap?.bind(el);
+    const origElFocus = el.focus?.bind(el);
+    const origElDragAndDrop = el.dragAndDrop?.bind(el);
+    const origElSelect = el.select?.bind(el);
+    const origElDrop = el.drop?.bind(el);
+    // --- Nested selectors ---
+    const origEl$ = el.$.bind(el);
+    const origEl$$ = el.$$.bind(el);
+    const origElWaitForSelector = el.waitForSelector.bind(el);
+    el.$ = async (selector) => {
+        const child = await origEl$(selector);
+        if (child)
+            patchSingleElementHandle(child, page, cfg, cursor, raw, rawKb, originals, stealth);
+        return child;
+    };
+    el.$$ = async (selector) => {
+        const children = await origEl$$(selector);
+        for (const child of children) {
+            patchSingleElementHandle(child, page, cfg, cursor, raw, rawKb, originals, stealth);
+        }
+        return children;
+    };
+    el.waitForSelector = async (selector, options) => {
+        const child = await origElWaitForSelector(selector, options);
+        if (child)
+            patchSingleElementHandle(child, page, cfg, cursor, raw, rawKb, originals, stealth);
+        return child;
+    };
+    // --- Helper: get box and move cursor ---
+    const moveToElement = async () => {
+        await page._ensureCursorInit();
+        const box = await el.boundingBox();
+        if (!box)
+            return null;
+        const isInp = await isInputElementHandle(stealth, el);
+        const target = clickTarget(box, isInp, cfg);
+        if (cfg.idle_between_actions) {
+            await humanIdle(raw, rand(cfg.idle_between_duration[0], cfg.idle_between_duration[1]), cursor.x, cursor.y, cfg);
+        }
+        await humanMove(raw, cursor.x, cursor.y, target.x, target.y, cfg);
+        cursor.x = target.x;
+        cursor.y = target.y;
+        return { box, isInp };
+    };
+    // --- el.click() ---
+    el.click = async (options) => {
+        const info = await moveToElement();
+        if (!info)
+            return origElClick(options);
+        const clickCount = options?.clickCount ?? options?.count ?? 1;
+        if (clickCount >= 2) {
+            await humanClick(raw, info.isInp, cfg);
+            await sleep(rand(40, 90));
+            await raw.down({ clickCount: 2 });
+            await sleep(rand(30, 60));
+            await raw.up({ clickCount: 2 });
+        }
+        else {
+            await humanClick(raw, info.isInp, cfg);
+        }
+    };
+    // --- el.hover() ---
+    el.hover = async () => {
+        const info = await moveToElement();
+        if (!info)
+            return origElHover();
+    };
+    // --- el.type() ---
+    el.type = async (text, options) => {
+        const info = await moveToElement();
+        if (!info)
+            return origElType(text, options);
+        await humanClick(raw, info.isInp, cfg);
+        await sleep(rand(100, 250));
+        const cdp = await stealth.getCdpSession().catch(() => null);
+        await humanType(page, rawKb, text, cfg, cdp);
+    };
+    // --- el.press() ---
+    if (origElPress) {
+        el.press = async (key, options) => {
+            await sleep(rand(20, 60));
+            await originals.keyboardDown(key);
+            await sleep(randRange(cfg.key_hold));
+            await originals.keyboardUp(key);
+        };
+    }
+    // --- el.tap() ---
+    if (origElTap) {
+        el.tap = async () => {
+            const info = await moveToElement();
+            if (!info)
+                return origElTap();
+            await humanClick(raw, info.isInp, cfg);
+        };
+    }
+    // --- el.focus() ---
+    if (origElFocus) {
+        el.focus = async () => {
+            const info = await moveToElement();
+            if (!info)
+                return origElFocus();
+            await humanClick(raw, info.isInp, cfg);
+        };
+    }
+    // --- el.select() ---
+    if (origElSelect) {
+        el.select = async (...values) => {
+            const info = await moveToElement();
+            if (!info)
+                return origElSelect(...values);
+            await humanClick(raw, false, cfg);
+            await sleep(rand(100, 300));
+            return origElSelect(...values);
+        };
+    }
+    // --- el.drop() ---
+    if (origElDrop) {
+        el.drop = async (draggable, options) => {
+            const srcBox = await draggable.boundingBox();
+            const tgtBox = await el.boundingBox();
+            if (srcBox && tgtBox) {
+                const sx = srcBox.x + srcBox.width / 2;
+                const sy = srcBox.y + srcBox.height / 2;
+                const tx = tgtBox.x + tgtBox.width / 2;
+                const ty = tgtBox.y + tgtBox.height / 2;
+                await page._ensureCursorInit();
+                await humanMove(raw, cursor.x, cursor.y, sx, sy, cfg);
+                cursor.x = sx;
+                cursor.y = sy;
+                await sleep(rand(100, 200));
+                await originals.mouseDown();
+                await sleep(rand(80, 150));
+                await humanMove(raw, cursor.x, cursor.y, tx, ty, cfg);
+                cursor.x = tx;
+                cursor.y = ty;
+                await sleep(rand(80, 150));
+                await originals.mouseUp();
+            }
+            else {
+                return origElDrop(draggable, options);
+            }
+        };
+    }
+    // --- el.dragAndDrop() ---
+    if (origElDragAndDrop) {
+        el.dragAndDrop = async (targetEl, options) => {
+            const srcBox = await el.boundingBox();
+            const tgtBox = await targetEl.boundingBox();
+            if (srcBox && tgtBox) {
+                const sx = srcBox.x + srcBox.width / 2;
+                const sy = srcBox.y + srcBox.height / 2;
+                const tx = tgtBox.x + tgtBox.width / 2;
+                const ty = tgtBox.y + tgtBox.height / 2;
+                await page._ensureCursorInit();
+                await humanMove(raw, cursor.x, cursor.y, sx, sy, cfg);
+                cursor.x = sx;
+                cursor.y = sy;
+                await sleep(rand(100, 200));
+                await originals.mouseDown();
+                await sleep(rand(80, 150));
+                await humanMove(raw, cursor.x, cursor.y, tx, ty, cfg);
+                cursor.x = tx;
+                cursor.y = ty;
+                await sleep(rand(80, 150));
+                await originals.mouseUp();
+            }
+            else {
+                return origElDragAndDrop(targetEl, options);
+            }
+        };
+    }
+}
+// ============================================================================
+// Frame-level patching — native Puppeteer Frame methods only
+// Puppeteer Frame has: click, hover, type, select, focus, tap
+// ============================================================================
+function patchFrames(page, cfg, cursor, raw, rawKb, originals, stealth) {
+    for (const frame of iterFrames(page)) {
+        patchSingleFrame(frame, page, cfg, cursor, raw, rawKb, originals, stealth);
+    }
+}
+function patchSingleFrame(frame, page, cfg, cursor, raw, rawKb, originals, stealth) {
+    if (frame._humanPatched)
+        return;
+    frame._humanPatched = true;
+    const origFrameSelect = frame.select.bind(frame);
+    frame.click = async (selector, options) => {
+        await page.click(selector, options);
+    };
+    frame.hover = async (selector, options) => {
+        await page.hover(selector, options);
+    };
+    frame.type = async (selector, text, options) => {
+        await page.type(selector, text, options);
+    };
+    frame.select = async (selector, ...values) => {
+        await page.hover(selector);
+        await sleep(rand(100, 300));
+        return origFrameSelect(selector, ...values);
+    };
+    frame.focus = async (selector) => {
+        await page.focus(selector);
+    };
+    frame.tap = async (selector, options) => {
+        await page.click(selector, options);
+    };
+    // Patch frame.$() to return patched ElementHandles
+    const origFrame$ = frame.$.bind(frame);
+    const origFrame$$ = frame.$$.bind(frame);
+    const origFrameWaitForSelector = frame.waitForSelector.bind(frame);
+    frame.$ = async (selector) => {
+        const el = await origFrame$(selector);
+        if (el)
+            patchSingleElementHandle(el, page, cfg, cursor, raw, rawKb, originals, stealth);
+        return el;
+    };
+    frame.$$ = async (selector) => {
+        const els = await origFrame$$(selector);
+        for (const el of els) {
+            patchSingleElementHandle(el, page, cfg, cursor, raw, rawKb, originals, stealth);
+        }
+        return els;
+    };
+    frame.waitForSelector = async (selector, options) => {
+        const el = await origFrameWaitForSelector(selector, options);
+        if (el)
+            patchSingleElementHandle(el, page, cfg, cursor, raw, rawKb, originals, stealth);
+        return el;
+    };
+}
+function* iterFrames(page) {
+    try {
+        const mainFrame = page.mainFrame();
+        yield mainFrame;
+        for (const child of mainFrame.childFrames()) {
+            yield child;
+        }
+    }
+    catch { }
+}
+// ============================================================================
+// Browser-level patching
+// ============================================================================
+export function patchBrowser(browser, cfg) {
+    browser.pages().then(pages => {
+        for (const page of pages) {
+            if (!page._original) {
+                patchPage(page, cfg, new CursorState());
+            }
+        }
+    }).catch(() => { });
+    const origNewPage = browser.newPage.bind(browser);
+    browser.newPage = async () => {
+        const page = await origNewPage();
+        if (!page._original) {
+            patchPage(page, cfg, new CursorState());
+        }
+        return page;
+    };
+    // v21: createIncognitoBrowserContext
+    // v22+: createBrowserContext (renamed in puppeteer/puppeteer#11834)
+    for (const methodName of ['createBrowserContext', 'createIncognitoBrowserContext']) {
+        if (typeof browser[methodName] === 'function') {
+            const origCreateContext = browser[methodName].bind(browser);
+            browser[methodName] = async (options) => {
+                const context = await origCreateContext(options);
+                const origCtxNewPage = context.newPage.bind(context);
+                context.newPage = async () => {
+                    const page = await origCtxNewPage();
+                    if (!page._original) {
+                        patchPage(page, cfg, new CursorState());
+                    }
+                    return page;
+                };
+                return context;
+            };
+        }
+    }
+    browser.on('targetcreated', async (target) => {
+        try {
+            if (target.type() === 'page') {
+                const page = await target.page();
+                if (page && !page._original) {
+                    patchPage(page, cfg, new CursorState());
+                }
+            }
+        }
+        catch { }
+    });
+}
+export { patchPage };
+//# sourceMappingURL=index.js.map