@midscene/recorder 0.21.4-beta-20250711063424.0 → 0.21.4-beta-20250714025212.0

package/dist/recorder-iife.js

@@ -1,300 +1,1672 @@
+/*! For license information please see recorder-iife.js.LICENSE.txt */
 (()=>{
-    "use strict";
-    const DEBUG = 'true' === localStorage.getItem('DEBUG');
-    function debugLog(...args) {
-        if (DEBUG) console.log('[EventRecorder]', ...args);
-    }
-    function generateHashId(type, elementRect) {
-        const rectStr = elementRect ? `${elementRect.left}_${elementRect.top}_${elementRect.width}_${elementRect.height}${void 0 !== elementRect.x ? `_${elementRect.x}` : ''}${void 0 !== elementRect.y ? `_${elementRect.y}` : ''}` : 'no_rect';
-        const combined = `${type}_${rectStr}`;
-        let hash = 0;
-        for(let i = 0; i < combined.length; i++){
-            const char = combined.charCodeAt(i);
-            hash = (hash << 5) - hash + char;
-            hash &= hash;
-        }
-        return Math.abs(hash).toString(36);
-    }
-    const isSameInputTarget = (event1, event2)=>event1.element === event2.element;
-    const isSameScrollTarget = (event1, event2)=>event1.element === event2.element;
-    const getLastLabelClick = (events)=>{
-        for(let i = events.length - 1; i >= 0; i--){
-            const event = events[i];
-            if ('click' === event.type && event.isLabelClick) return event;
-        }
-    };
-    function getAllScrollableElements() {
-        const elements = [];
-        const all = document.querySelectorAll('body *');
-        all.forEach((el)=>{
-            const style = window.getComputedStyle(el);
-            const overflowY = style.overflowY;
-            const overflowX = style.overflowX;
-            const isScrollableY = ('auto' === overflowY || 'scroll' === overflowY) && el.scrollHeight > el.clientHeight;
-            const isScrollableX = ('auto' === overflowX || 'scroll' === overflowX) && el.scrollWidth > el.clientWidth;
-            if (isScrollableY || isScrollableX) elements.push(el);
-        });
-        return elements;
-    }
-    class EventRecorder {
-        isRecording = false;
-        eventCallback;
-        scrollThrottleTimer = null;
-        scrollThrottleDelay = 200;
-        lastViewportScroll = null;
-        scrollTargets = [];
-        sessionId;
-        constructor(eventCallback, sessionId){
-            this.eventCallback = eventCallback;
-            this.sessionId = sessionId;
-        }
-        createNavigationEvent(url, title) {
-            return {
-                type: 'navigation',
-                url,
-                title,
-                pageInfo: {
-                    width: window.innerWidth,
-                    height: window.innerHeight
-                },
-                timestamp: Date.now(),
-                hashId: 'navigation_0'
+    var __webpack_modules__ = {
+        "../../node_modules/.pnpm/js-sha256@0.11.0/node_modules/js-sha256/src/sha256.js": function(module, __unused_webpack_exports, __webpack_require__) {
+            /**
+ * [js-sha256]{@link https://github.com/emn178/js-sha256}
+ *
+ * @version 0.11.0
+ * @author Chen, Yi-Cyuan [emn178@gmail.com]
+ * @copyright Chen, Yi-Cyuan 2014-2024
+ * @license MIT
+ */ (function() {
+                'use strict';
+                var ERROR = 'input is invalid type';
+                var WINDOW = 'object' == typeof window;
+                var root = WINDOW ? window : {};
+                if (root.JS_SHA256_NO_WINDOW) WINDOW = false;
+                var WEB_WORKER = !WINDOW && 'object' == typeof self;
+                var NODE_JS = !root.JS_SHA256_NO_NODE_JS && 'object' == typeof process && process.versions && process.versions.node;
+                if (NODE_JS) root = __webpack_require__.g;
+                else if (WEB_WORKER) root = self;
+                var COMMON_JS = !root.JS_SHA256_NO_COMMON_JS && true && module.exports;
+                var AMD = 'function' == typeof define && define.amd;
+                var ARRAY_BUFFER = !root.JS_SHA256_NO_ARRAY_BUFFER && 'undefined' != typeof ArrayBuffer;
+                var HEX_CHARS = '0123456789abcdef'.split('');
+                var EXTRA = [
+                    -2147483648,
+                    8388608,
+                    32768,
+                    128
+                ];
+                var SHIFT = [
+                    24,
+                    16,
+                    8,
+                    0
+                ];
+                var K = [
+                    0x428a2f98,
+                    0x71374491,
+                    0xb5c0fbcf,
+                    0xe9b5dba5,
+                    0x3956c25b,
+                    0x59f111f1,
+                    0x923f82a4,
+                    0xab1c5ed5,
+                    0xd807aa98,
+                    0x12835b01,
+                    0x243185be,
+                    0x550c7dc3,
+                    0x72be5d74,
+                    0x80deb1fe,
+                    0x9bdc06a7,
+                    0xc19bf174,
+                    0xe49b69c1,
+                    0xefbe4786,
+                    0x0fc19dc6,
+                    0x240ca1cc,
+                    0x2de92c6f,
+                    0x4a7484aa,
+                    0x5cb0a9dc,
+                    0x76f988da,
+                    0x983e5152,
+                    0xa831c66d,
+                    0xb00327c8,
+                    0xbf597fc7,
+                    0xc6e00bf3,
+                    0xd5a79147,
+                    0x06ca6351,
+                    0x14292967,
+                    0x27b70a85,
+                    0x2e1b2138,
+                    0x4d2c6dfc,
+                    0x53380d13,
+                    0x650a7354,
+                    0x766a0abb,
+                    0x81c2c92e,
+                    0x92722c85,
+                    0xa2bfe8a1,
+                    0xa81a664b,
+                    0xc24b8b70,
+                    0xc76c51a3,
+                    0xd192e819,
+                    0xd6990624,
+                    0xf40e3585,
+                    0x106aa070,
+                    0x19a4c116,
+                    0x1e376c08,
+                    0x2748774c,
+                    0x34b0bcb5,
+                    0x391c0cb3,
+                    0x4ed8aa4a,
+                    0x5b9cca4f,
+                    0x682e6ff3,
+                    0x748f82ee,
+                    0x78a5636f,
+                    0x84c87814,
+                    0x8cc70208,
+                    0x90befffa,
+                    0xa4506ceb,
+                    0xbef9a3f7,
+                    0xc67178f2
+                ];
+                var OUTPUT_TYPES = [
+                    'hex',
+                    'array',
+                    'digest',
+                    'arrayBuffer'
+                ];
+                var blocks = [];
+                if (root.JS_SHA256_NO_NODE_JS || !Array.isArray) Array.isArray = function(obj) {
+                    return '[object Array]' === Object.prototype.toString.call(obj);
+                };
+                if (ARRAY_BUFFER && (root.JS_SHA256_NO_ARRAY_BUFFER_IS_VIEW || !ArrayBuffer.isView)) ArrayBuffer.isView = function(obj) {
+                    return 'object' == typeof obj && obj.buffer && obj.buffer.constructor === ArrayBuffer;
+                };
+                var createOutputMethod = function(outputType, is224) {
+                    return function(message) {
+                        return new Sha256(is224, true).update(message)[outputType]();
+                    };
+                };
+                var createMethod = function(is224) {
+                    var method = createOutputMethod('hex', is224);
+                    if (NODE_JS) method = nodeWrap(method, is224);
+                    method.create = function() {
+                        return new Sha256(is224);
+                    };
+                    method.update = function(message) {
+                        return method.create().update(message);
+                    };
+                    for(var i = 0; i < OUTPUT_TYPES.length; ++i){
+                        var type = OUTPUT_TYPES[i];
+                        method[type] = createOutputMethod(type, is224);
+                    }
+                    return method;
+                };
+                var nodeWrap = function(method, is224) {
+                    var crypto = __webpack_require__("?7342");
+                    var Buffer = __webpack_require__("?d94c").Buffer;
+                    var algorithm = is224 ? 'sha224' : 'sha256';
+                    var bufferFrom;
+                    bufferFrom = Buffer.from && !root.JS_SHA256_NO_BUFFER_FROM ? Buffer.from : function(message) {
+                        return new Buffer(message);
+                    };
+                    var nodeMethod = function(message) {
+                        if ('string' == typeof message) return crypto.createHash(algorithm).update(message, 'utf8').digest('hex');
+                        if (null == message) throw new Error(ERROR);
+                        if (message.constructor === ArrayBuffer) message = new Uint8Array(message);
+                        if (Array.isArray(message) || ArrayBuffer.isView(message) || message.constructor === Buffer) return crypto.createHash(algorithm).update(bufferFrom(message)).digest('hex');
+                        return method(message);
+                    };
+                    return nodeMethod;
+                };
+                var createHmacOutputMethod = function(outputType, is224) {
+                    return function(key, message) {
+                        return new HmacSha256(key, is224, true).update(message)[outputType]();
+                    };
+                };
+                var createHmacMethod = function(is224) {
+                    var method = createHmacOutputMethod('hex', is224);
+                    method.create = function(key) {
+                        return new HmacSha256(key, is224);
+                    };
+                    method.update = function(key, message) {
+                        return method.create(key).update(message);
+                    };
+                    for(var i = 0; i < OUTPUT_TYPES.length; ++i){
+                        var type = OUTPUT_TYPES[i];
+                        method[type] = createHmacOutputMethod(type, is224);
+                    }
+                    return method;
+                };
+                function Sha256(is224, sharedMemory) {
+                    if (sharedMemory) {
+                        blocks[0] = blocks[16] = blocks[1] = blocks[2] = blocks[3] = blocks[4] = blocks[5] = blocks[6] = blocks[7] = blocks[8] = blocks[9] = blocks[10] = blocks[11] = blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+                        this.blocks = blocks;
+                    } else this.blocks = [
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0,
+                        0
+                    ];
+                    if (is224) {
+                        this.h0 = 0xc1059ed8;
+                        this.h1 = 0x367cd507;
+                        this.h2 = 0x3070dd17;
+                        this.h3 = 0xf70e5939;
+                        this.h4 = 0xffc00b31;
+                        this.h5 = 0x68581511;
+                        this.h6 = 0x64f98fa7;
+                        this.h7 = 0xbefa4fa4;
+                    } else {
+                        this.h0 = 0x6a09e667;
+                        this.h1 = 0xbb67ae85;
+                        this.h2 = 0x3c6ef372;
+                        this.h3 = 0xa54ff53a;
+                        this.h4 = 0x510e527f;
+                        this.h5 = 0x9b05688c;
+                        this.h6 = 0x1f83d9ab;
+                        this.h7 = 0x5be0cd19;
+                    }
+                    this.block = this.start = this.bytes = this.hBytes = 0;
+                    this.finalized = this.hashed = false;
+                    this.first = true;
+                    this.is224 = is224;
+                }
+                Sha256.prototype.update = function(message) {
+                    if (this.finalized) return;
+                    var notString, type = typeof message;
+                    if ('string' !== type) {
+                        if ('object' === type) {
+                            if (null === message) throw new Error(ERROR);
+                            else if (ARRAY_BUFFER && message.constructor === ArrayBuffer) message = new Uint8Array(message);
+                            else if (!Array.isArray(message)) {
+                                if (!ARRAY_BUFFER || !ArrayBuffer.isView(message)) throw new Error(ERROR);
+                            }
+                        } else throw new Error(ERROR);
+                        notString = true;
+                    }
+                    var code, index = 0, i, length = message.length, blocks = this.blocks;
+                    while(index < length){
+                        if (this.hashed) {
+                            this.hashed = false;
+                            blocks[0] = this.block;
+                            this.block = blocks[16] = blocks[1] = blocks[2] = blocks[3] = blocks[4] = blocks[5] = blocks[6] = blocks[7] = blocks[8] = blocks[9] = blocks[10] = blocks[11] = blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+                        }
+                        if (notString) for(i = this.start; index < length && i < 64; ++index)blocks[i >>> 2] |= message[index] << SHIFT[3 & i++];
+                        else for(i = this.start; index < length && i < 64; ++index){
+                            code = message.charCodeAt(index);
+                            if (code < 0x80) blocks[i >>> 2] |= code << SHIFT[3 & i++];
+                            else if (code < 0x800) {
+                                blocks[i >>> 2] |= (0xc0 | code >>> 6) << SHIFT[3 & i++];
+                                blocks[i >>> 2] |= (0x80 | 0x3f & code) << SHIFT[3 & i++];
+                            } else if (code < 0xd800 || code >= 0xe000) {
+                                blocks[i >>> 2] |= (0xe0 | code >>> 12) << SHIFT[3 & i++];
+                                blocks[i >>> 2] |= (0x80 | code >>> 6 & 0x3f) << SHIFT[3 & i++];
+                                blocks[i >>> 2] |= (0x80 | 0x3f & code) << SHIFT[3 & i++];
+                            } else {
+                                code = 0x10000 + ((0x3ff & code) << 10 | 0x3ff & message.charCodeAt(++index));
+                                blocks[i >>> 2] |= (0xf0 | code >>> 18) << SHIFT[3 & i++];
+                                blocks[i >>> 2] |= (0x80 | code >>> 12 & 0x3f) << SHIFT[3 & i++];
+                                blocks[i >>> 2] |= (0x80 | code >>> 6 & 0x3f) << SHIFT[3 & i++];
+                                blocks[i >>> 2] |= (0x80 | 0x3f & code) << SHIFT[3 & i++];
+                            }
+                        }
+                        this.lastByteIndex = i;
+                        this.bytes += i - this.start;
+                        if (i >= 64) {
+                            this.block = blocks[16];
+                            this.start = i - 64;
+                            this.hash();
+                            this.hashed = true;
+                        } else this.start = i;
+                    }
+                    if (this.bytes > 4294967295) {
+                        this.hBytes += this.bytes / 4294967296 | 0;
+                        this.bytes = this.bytes % 4294967296;
+                    }
+                    return this;
+                };
+                Sha256.prototype.finalize = function() {
+                    if (this.finalized) return;
+                    this.finalized = true;
+                    var blocks = this.blocks, i = this.lastByteIndex;
+                    blocks[16] = this.block;
+                    blocks[i >>> 2] |= EXTRA[3 & i];
+                    this.block = blocks[16];
+                    if (i >= 56) {
+                        if (!this.hashed) this.hash();
+                        blocks[0] = this.block;
+                        blocks[16] = blocks[1] = blocks[2] = blocks[3] = blocks[4] = blocks[5] = blocks[6] = blocks[7] = blocks[8] = blocks[9] = blocks[10] = blocks[11] = blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+                    }
+                    blocks[14] = this.hBytes << 3 | this.bytes >>> 29;
+                    blocks[15] = this.bytes << 3;
+                    this.hash();
+                };
+                Sha256.prototype.hash = function() {
+                    var a = this.h0, b = this.h1, c = this.h2, d = this.h3, e = this.h4, f = this.h5, g = this.h6, h = this.h7, blocks = this.blocks, j, s0, s1, maj, t1, t2, ch, ab, da, cd, bc;
+                    for(j = 16; j < 64; ++j){
+                        t1 = blocks[j - 15];
+                        s0 = (t1 >>> 7 | t1 << 25) ^ (t1 >>> 18 | t1 << 14) ^ t1 >>> 3;
+                        t1 = blocks[j - 2];
+                        s1 = (t1 >>> 17 | t1 << 15) ^ (t1 >>> 19 | t1 << 13) ^ t1 >>> 10;
+                        blocks[j] = blocks[j - 16] + s0 + blocks[j - 7] + s1 | 0;
+                    }
+                    bc = b & c;
+                    for(j = 0; j < 64; j += 4){
+                        if (this.first) {
+                            if (this.is224) {
+                                ab = 300032;
+                                t1 = blocks[0] - 1413257819;
+                                h = t1 - 150054599 | 0;
+                                d = t1 + 24177077 | 0;
+                            } else {
+                                ab = 704751109;
+                                t1 = blocks[0] - 210244248;
+                                h = t1 - 1521486534 | 0;
+                                d = t1 + 143694565 | 0;
+                            }
+                            this.first = false;
+                        } else {
+                            s0 = (a >>> 2 | a << 30) ^ (a >>> 13 | a << 19) ^ (a >>> 22 | a << 10);
+                            s1 = (e >>> 6 | e << 26) ^ (e >>> 11 | e << 21) ^ (e >>> 25 | e << 7);
+                            ab = a & b;
+                            maj = ab ^ a & c ^ bc;
+                            ch = e & f ^ ~e & g;
+                            t1 = h + s1 + ch + K[j] + blocks[j];
+                            t2 = s0 + maj;
+                            h = d + t1 | 0;
+                            d = t1 + t2 | 0;
+                        }
+                        s0 = (d >>> 2 | d << 30) ^ (d >>> 13 | d << 19) ^ (d >>> 22 | d << 10);
+                        s1 = (h >>> 6 | h << 26) ^ (h >>> 11 | h << 21) ^ (h >>> 25 | h << 7);
+                        da = d & a;
+                        maj = da ^ d & b ^ ab;
+                        ch = h & e ^ ~h & f;
+                        t1 = g + s1 + ch + K[j + 1] + blocks[j + 1];
+                        t2 = s0 + maj;
+                        g = c + t1 | 0;
+                        c = t1 + t2 | 0;
+                        s0 = (c >>> 2 | c << 30) ^ (c >>> 13 | c << 19) ^ (c >>> 22 | c << 10);
+                        s1 = (g >>> 6 | g << 26) ^ (g >>> 11 | g << 21) ^ (g >>> 25 | g << 7);
+                        cd = c & d;
+                        maj = cd ^ c & a ^ da;
+                        ch = g & h ^ ~g & e;
+                        t1 = f + s1 + ch + K[j + 2] + blocks[j + 2];
+                        t2 = s0 + maj;
+                        f = b + t1 | 0;
+                        b = t1 + t2 | 0;
+                        s0 = (b >>> 2 | b << 30) ^ (b >>> 13 | b << 19) ^ (b >>> 22 | b << 10);
+                        s1 = (f >>> 6 | f << 26) ^ (f >>> 11 | f << 21) ^ (f >>> 25 | f << 7);
+                        bc = b & c;
+                        maj = bc ^ b & d ^ cd;
+                        ch = f & g ^ ~f & h;
+                        t1 = e + s1 + ch + K[j + 3] + blocks[j + 3];
+                        t2 = s0 + maj;
+                        e = a + t1 | 0;
+                        a = t1 + t2 | 0;
+                        this.chromeBugWorkAround = true;
+                    }
+                    this.h0 = this.h0 + a | 0;
+                    this.h1 = this.h1 + b | 0;
+                    this.h2 = this.h2 + c | 0;
+                    this.h3 = this.h3 + d | 0;
+                    this.h4 = this.h4 + e | 0;
+                    this.h5 = this.h5 + f | 0;
+                    this.h6 = this.h6 + g | 0;
+                    this.h7 = this.h7 + h | 0;
+                };
+                Sha256.prototype.hex = function() {
+                    this.finalize();
+                    var h0 = this.h0, h1 = this.h1, h2 = this.h2, h3 = this.h3, h4 = this.h4, h5 = this.h5, h6 = this.h6, h7 = this.h7;
+                    var hex = HEX_CHARS[h0 >>> 28 & 0x0F] + HEX_CHARS[h0 >>> 24 & 0x0F] + HEX_CHARS[h0 >>> 20 & 0x0F] + HEX_CHARS[h0 >>> 16 & 0x0F] + HEX_CHARS[h0 >>> 12 & 0x0F] + HEX_CHARS[h0 >>> 8 & 0x0F] + HEX_CHARS[h0 >>> 4 & 0x0F] + HEX_CHARS[0x0F & h0] + HEX_CHARS[h1 >>> 28 & 0x0F] + HEX_CHARS[h1 >>> 24 & 0x0F] + HEX_CHARS[h1 >>> 20 & 0x0F] + HEX_CHARS[h1 >>> 16 & 0x0F] + HEX_CHARS[h1 >>> 12 & 0x0F] + HEX_CHARS[h1 >>> 8 & 0x0F] + HEX_CHARS[h1 >>> 4 & 0x0F] + HEX_CHARS[0x0F & h1] + HEX_CHARS[h2 >>> 28 & 0x0F] + HEX_CHARS[h2 >>> 24 & 0x0F] + HEX_CHARS[h2 >>> 20 & 0x0F] + HEX_CHARS[h2 >>> 16 & 0x0F] + HEX_CHARS[h2 >>> 12 & 0x0F] + HEX_CHARS[h2 >>> 8 & 0x0F] + HEX_CHARS[h2 >>> 4 & 0x0F] + HEX_CHARS[0x0F & h2] + HEX_CHARS[h3 >>> 28 & 0x0F] + HEX_CHARS[h3 >>> 24 & 0x0F] + HEX_CHARS[h3 >>> 20 & 0x0F] + HEX_CHARS[h3 >>> 16 & 0x0F] + HEX_CHARS[h3 >>> 12 & 0x0F] + HEX_CHARS[h3 >>> 8 & 0x0F] + HEX_CHARS[h3 >>> 4 & 0x0F] + HEX_CHARS[0x0F & h3] + HEX_CHARS[h4 >>> 28 & 0x0F] + HEX_CHARS[h4 >>> 24 & 0x0F] + HEX_CHARS[h4 >>> 20 & 0x0F] + HEX_CHARS[h4 >>> 16 & 0x0F] + HEX_CHARS[h4 >>> 12 & 0x0F] + HEX_CHARS[h4 >>> 8 & 0x0F] + HEX_CHARS[h4 >>> 4 & 0x0F] + HEX_CHARS[0x0F & h4] + HEX_CHARS[h5 >>> 28 & 0x0F] + HEX_CHARS[h5 >>> 24 & 0x0F] + HEX_CHARS[h5 >>> 20 & 0x0F] + HEX_CHARS[h5 >>> 16 & 0x0F] + HEX_CHARS[h5 >>> 12 & 0x0F] + HEX_CHARS[h5 >>> 8 & 0x0F] + HEX_CHARS[h5 >>> 4 & 0x0F] + HEX_CHARS[0x0F & h5] + HEX_CHARS[h6 >>> 28 & 0x0F] + HEX_CHARS[h6 >>> 24 & 0x0F] + HEX_CHARS[h6 >>> 20 & 0x0F] + HEX_CHARS[h6 >>> 16 & 0x0F] + HEX_CHARS[h6 >>> 12 & 0x0F] + HEX_CHARS[h6 >>> 8 & 0x0F] + HEX_CHARS[h6 >>> 4 & 0x0F] + HEX_CHARS[0x0F & h6];
+                    if (!this.is224) hex += HEX_CHARS[h7 >>> 28 & 0x0F] + HEX_CHARS[h7 >>> 24 & 0x0F] + HEX_CHARS[h7 >>> 20 & 0x0F] + HEX_CHARS[h7 >>> 16 & 0x0F] + HEX_CHARS[h7 >>> 12 & 0x0F] + HEX_CHARS[h7 >>> 8 & 0x0F] + HEX_CHARS[h7 >>> 4 & 0x0F] + HEX_CHARS[0x0F & h7];
+                    return hex;
+                };
+                Sha256.prototype.toString = Sha256.prototype.hex;
+                Sha256.prototype.digest = function() {
+                    this.finalize();
+                    var h0 = this.h0, h1 = this.h1, h2 = this.h2, h3 = this.h3, h4 = this.h4, h5 = this.h5, h6 = this.h6, h7 = this.h7;
+                    var arr = [
+                        h0 >>> 24 & 0xFF,
+                        h0 >>> 16 & 0xFF,
+                        h0 >>> 8 & 0xFF,
+                        0xFF & h0,
+                        h1 >>> 24 & 0xFF,
+                        h1 >>> 16 & 0xFF,
+                        h1 >>> 8 & 0xFF,
+                        0xFF & h1,
+                        h2 >>> 24 & 0xFF,
+                        h2 >>> 16 & 0xFF,
+                        h2 >>> 8 & 0xFF,
+                        0xFF & h2,
+                        h3 >>> 24 & 0xFF,
+                        h3 >>> 16 & 0xFF,
+                        h3 >>> 8 & 0xFF,
+                        0xFF & h3,
+                        h4 >>> 24 & 0xFF,
+                        h4 >>> 16 & 0xFF,
+                        h4 >>> 8 & 0xFF,
+                        0xFF & h4,
+                        h5 >>> 24 & 0xFF,
+                        h5 >>> 16 & 0xFF,
+                        h5 >>> 8 & 0xFF,
+                        0xFF & h5,
+                        h6 >>> 24 & 0xFF,
+                        h6 >>> 16 & 0xFF,
+                        h6 >>> 8 & 0xFF,
+                        0xFF & h6
+                    ];
+                    if (!this.is224) arr.push(h7 >>> 24 & 0xFF, h7 >>> 16 & 0xFF, h7 >>> 8 & 0xFF, 0xFF & h7);
+                    return arr;
+                };
+                Sha256.prototype.array = Sha256.prototype.digest;
+                Sha256.prototype.arrayBuffer = function() {
+                    this.finalize();
+                    var buffer = new ArrayBuffer(this.is224 ? 28 : 32);
+                    var dataView = new DataView(buffer);
+                    dataView.setUint32(0, this.h0);
+                    dataView.setUint32(4, this.h1);
+                    dataView.setUint32(8, this.h2);
+                    dataView.setUint32(12, this.h3);
+                    dataView.setUint32(16, this.h4);
+                    dataView.setUint32(20, this.h5);
+                    dataView.setUint32(24, this.h6);
+                    if (!this.is224) dataView.setUint32(28, this.h7);
+                    return buffer;
+                };
+                function HmacSha256(key, is224, sharedMemory) {
+                    var i, type = typeof key;
+                    if ('string' === type) {
+                        var bytes = [], length = key.length, index = 0, code;
+                        for(i = 0; i < length; ++i){
+                            code = key.charCodeAt(i);
+                            if (code < 0x80) bytes[index++] = code;
+                            else if (code < 0x800) {
+                                bytes[index++] = 0xc0 | code >>> 6;
+                                bytes[index++] = 0x80 | 0x3f & code;
+                            } else if (code < 0xd800 || code >= 0xe000) {
+                                bytes[index++] = 0xe0 | code >>> 12;
+                                bytes[index++] = 0x80 | code >>> 6 & 0x3f;
+                                bytes[index++] = 0x80 | 0x3f & code;
+                            } else {
+                                code = 0x10000 + ((0x3ff & code) << 10 | 0x3ff & key.charCodeAt(++i));
+                                bytes[index++] = 0xf0 | code >>> 18;
+                                bytes[index++] = 0x80 | code >>> 12 & 0x3f;
+                                bytes[index++] = 0x80 | code >>> 6 & 0x3f;
+                                bytes[index++] = 0x80 | 0x3f & code;
+                            }
+                        }
+                        key = bytes;
+                    } else if ('object' === type) {
+                        if (null === key) throw new Error(ERROR);
+                        else if (ARRAY_BUFFER && key.constructor === ArrayBuffer) key = new Uint8Array(key);
+                        else if (!Array.isArray(key)) {
+                            if (!ARRAY_BUFFER || !ArrayBuffer.isView(key)) throw new Error(ERROR);
+                        }
+                    } else throw new Error(ERROR);
+                    if (key.length > 64) key = new Sha256(is224, true).update(key).array();
+                    var oKeyPad = [], iKeyPad = [];
+                    for(i = 0; i < 64; ++i){
+                        var b = key[i] || 0;
+                        oKeyPad[i] = 0x5c ^ b;
+                        iKeyPad[i] = 0x36 ^ b;
+                    }
+                    Sha256.call(this, is224, sharedMemory);
+                    this.update(iKeyPad);
+                    this.oKeyPad = oKeyPad;
+                    this.inner = true;
+                    this.sharedMemory = sharedMemory;
+                }
+                HmacSha256.prototype = new Sha256();
+                HmacSha256.prototype.finalize = function() {
+                    Sha256.prototype.finalize.call(this);
+                    if (this.inner) {
+                        this.inner = false;
+                        var innerHash = this.array();
+                        Sha256.call(this, this.is224, this.sharedMemory);
+                        this.update(this.oKeyPad);
+                        this.update(innerHash);
+                        Sha256.prototype.finalize.call(this);
+                    }
+                };
+                var exports = createMethod();
+                exports.sha256 = exports;
+                exports.sha224 = createMethod(true);
+                exports.sha256.hmac = createHmacMethod();
+                exports.sha224.hmac = createHmacMethod(true);
+                if (COMMON_JS) module.exports = exports;
+                else {
+                    root.sha256 = exports.sha256;
+                    root.sha224 = exports.sha224;
+                    if (AMD) define(function() {
+                        return exports;
+                    });
+                }
+            })();
+        },
+        "../shared/dist/lib/extractor.js": function(module, __unused_webpack_exports, __webpack_require__) {
+            "use strict";
+            var __defProp = Object.defineProperty;
+            var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+            var __getOwnPropNames = Object.getOwnPropertyNames;
+            var __hasOwnProp = Object.prototype.hasOwnProperty;
+            var __export = (target, all)=>{
+                for(var name in all)__defProp(target, name, {
+                    get: all[name],
+                    enumerable: true
+                });
             };
-        }
-        start() {
-            if (this.isRecording) return void debugLog('Recording already active, ignoring start request');
-            this.isRecording = true;
-            debugLog('Starting event recording');
-            this.scrollTargets = [];
-            if (0 === this.scrollTargets.length) {
-                this.scrollTargets = getAllScrollableElements();
-                this.scrollTargets.push(document.body);
-            }
-            debugLog('Added event listeners for', this.scrollTargets.length, 'scroll targets');
-            setTimeout(()=>{
-                const navigationEvent = this.createNavigationEvent(window.location.href, document.title);
-                this.eventCallback(navigationEvent);
-                debugLog('Added final navigation event', navigationEvent);
-            }, 0);
-            document.addEventListener('click', this.handleClick, true);
-            document.addEventListener('input', this.handleInput);
-            document.addEventListener('scroll', this.handleScroll, {
-                passive: true
+            var __copyProps = (to, from, except, desc)=>{
+                if (from && "object" == typeof from || "function" == typeof from) {
+                    for (let key of __getOwnPropNames(from))if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                        get: ()=>from[key],
+                        enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                    });
+                }
+                return to;
+            };
+            var __toCommonJS = (mod)=>__copyProps(__defProp({}, "__esModule", {
+                    value: true
+                }), mod);
+            var extractor_exports = {};
+            __export(extractor_exports, {
+                descriptionOfTree: ()=>descriptionOfTree,
+                generateElementByPosition: ()=>generateElementByPosition,
+                getElementInfoByXpath: ()=>getElementInfoByXpath,
+                getNodeFromCacheList: ()=>getNodeFromCacheList,
+                getNodeInfoByXpath: ()=>getNodeInfoByXpath,
+                getXpathsById: ()=>getXpathsById,
+                isNotContainerElement: ()=>isNotContainerElement,
+                setNodeHashCacheListOnWindow: ()=>setNodeHashCacheListOnWindow,
+                traverseTree: ()=>traverseTree,
+                treeToList: ()=>treeToList,
+                trimAttributes: ()=>trimAttributes,
+                truncateText: ()=>truncateText,
+                webExtractNodeTree: ()=>extractTreeNode,
+                webExtractNodeTreeAsString: ()=>extractTreeNodeAsString,
+                webExtractTextWithPosition: ()=>extractTextWithPosition
             });
-            this.scrollTargets.forEach((target)=>{
-                target.addEventListener('scroll', this.handleScroll, {
-                    passive: true
+            module.exports = __toCommonJS(extractor_exports);
+            function truncateText(text, maxLength = 150) {
+                if (void 0 === text) return "";
+                if ("object" == typeof text) text = JSON.stringify(text);
+                if ("number" == typeof text) return text.toString();
+                if ("string" == typeof text && text.length > maxLength) return `${text.slice(0, maxLength)}...`;
+                if ("string" == typeof text) return text.trim();
+                return "";
+            }
+            function trimAttributes(attributes, truncateTextLength) {
+                const tailorAttributes = Object.keys(attributes).reduce((res, currentKey)=>{
+                    const attributeVal = attributes[currentKey];
+                    if ("style" === currentKey || "htmlTagName" === currentKey || "nodeType" === currentKey) return res;
+                    res[currentKey] = truncateText(attributeVal, truncateTextLength);
+                    return res;
+                }, {});
+                return tailorAttributes;
+            }
+            var nodeSizeThreshold = 4;
+            function descriptionOfTree(tree, truncateTextLength, filterNonTextContent = false, visibleOnly = true) {
+                const attributesString = (kv)=>Object.entries(kv).map(([key, value])=>`${key}="${truncateText(value, truncateTextLength)}"`).join(" ");
+                function buildContentTree(node, indent = 0, visibleOnly2 = true) {
+                    let before = "";
+                    let contentWithIndent = "";
+                    let after = "";
+                    let emptyNode = true;
+                    const indentStr = "  ".repeat(indent);
+                    let children = "";
+                    for(let i = 0; i < (node.children || []).length; i++){
+                        const childContent = buildContentTree(node.children[i], indent + 1, visibleOnly2);
+                        if (childContent) children += `
+${childContent}`;
+                    }
+                    if (node.node && node.node.rect.width > nodeSizeThreshold && node.node.rect.height > nodeSizeThreshold && (!filterNonTextContent || filterNonTextContent && node.node.content) && (!visibleOnly2 || visibleOnly2 && node.node.isVisible)) {
+                        emptyNode = false;
+                        let nodeTypeString;
+                        nodeTypeString = node.node.attributes?.htmlTagName ? node.node.attributes.htmlTagName.replace(/[<>]/g, "") : node.node.attributes.nodeType.replace(/\sNode$/, "").toLowerCase();
+                        const markerId = node.node.indexId;
+                        const markerIdString = markerId ? `markerId="${markerId}"` : "";
+                        const rectAttribute = node.node.rect ? {
+                            left: node.node.rect.left,
+                            top: node.node.rect.top,
+                            width: node.node.rect.width,
+                            height: node.node.rect.height
+                        } : {};
+                        before = `<${nodeTypeString} id="${node.node.id}" ${markerIdString} ${attributesString(trimAttributes(node.node.attributes || {}, truncateTextLength))} ${attributesString(rectAttribute)}>`;
+                        const content = truncateText(node.node.content, truncateTextLength);
+                        contentWithIndent = content ? `
+${indentStr}  ${content}` : "";
+                        after = `</${nodeTypeString}>`;
+                    } else if (!filterNonTextContent) {
+                        if (!children.trim().startsWith("<>")) {
+                            before = "<>";
+                            contentWithIndent = "";
+                            after = "</>";
+                        }
+                    }
+                    if (emptyNode && !children.trim()) return "";
+                    const result2 = `${indentStr}${before}${contentWithIndent}${children}
+${indentStr}${after}`;
+                    if (result2.trim()) return result2;
+                    return "";
+                }
+                const result = buildContentTree(tree, 0, visibleOnly);
+                return result.replace(/^\s*\n/gm, "");
+            }
+            function treeToList(tree) {
+                const result = [];
+                function dfs(node) {
+                    if (node.node) result.push(node.node);
+                    for (const child of node.children)dfs(child);
+                }
+                dfs(tree);
+                return result;
+            }
+            function traverseTree(tree, onNode) {
+                function dfs(node) {
+                    if (node.node) node.node = onNode(node.node);
+                    for (const child of node.children)dfs(child);
+                }
+                dfs(tree);
+                return tree;
+            }
+            var CONTAINER_MINI_HEIGHT = 3;
+            var CONTAINER_MINI_WIDTH = 3;
+            var import_js_sha256 = __webpack_require__("../../node_modules/.pnpm/js-sha256@0.11.0/node_modules/js-sha256/src/sha256.js");
+            var hashMap = {};
+            function generateHashId(rect, content = "") {
+                const combined = JSON.stringify({
+                    content,
+                    rect
                 });
-            });
-        }
-        stop() {
-            if (!this.isRecording) return void debugLog('Recording not active, ignoring stop request');
-            this.isRecording = false;
-            debugLog('Stopping event recording');
-            if (this.scrollThrottleTimer) {
-                clearTimeout(this.scrollThrottleTimer);
-                this.scrollThrottleTimer = null;
-            }
-            document.removeEventListener('click', this.handleClick);
-            document.removeEventListener('input', this.handleInput);
-            this.scrollTargets.forEach((target)=>{
-                target.removeEventListener('scroll', this.handleScroll);
-            });
-            debugLog('Removed all event listeners');
-        }
-        handleClick = (event)=>{
-            if (!this.isRecording) return;
-            const target = event.target;
-            const { isLabelClick, labelInfo } = this.checkLabelClick(target);
-            target.getBoundingClientRect();
-            const elementRect = {
-                x: Number(event.clientX.toFixed(2)),
-                y: Number(event.clientY.toFixed(2))
-            };
-            const clickEvent = {
-                type: 'click',
-                elementRect,
-                pageInfo: {
-                    width: window.innerWidth,
-                    height: window.innerHeight
-                },
-                value: '',
-                timestamp: Date.now(),
-                hashId: generateHashId('click', {
-                    ...elementRect
-                }),
-                element: target,
-                isLabelClick,
-                labelInfo,
-                isTrusted: event.isTrusted,
-                detail: event.detail
+                let sliceLength = 5;
+                let slicedHash = "";
+                const hashHex = import_js_sha256.sha256.create().update(combined).hex();
+                const toLetters = (hex)=>hex.split("").map((char)=>{
+                        const code = Number.parseInt(char, 16);
+                        return String.fromCharCode(97 + code % 26);
+                    }).join("");
+                const hashLetters = toLetters(hashHex);
+                while(sliceLength < hashLetters.length - 1){
+                    slicedHash = hashLetters.slice(0, sliceLength);
+                    if (hashMap[slicedHash] && hashMap[slicedHash] !== combined) {
+                        sliceLength++;
+                        continue;
+                    }
+                    hashMap[slicedHash] = combined;
+                    break;
+                }
+                return slicedHash;
+            }
+            function isFormElement(node) {
+                return node instanceof HTMLElement && ("input" === node.tagName.toLowerCase() || "textarea" === node.tagName.toLowerCase() || "select" === node.tagName.toLowerCase() || "option" === node.tagName.toLowerCase());
+            }
+            function isButtonElement(node) {
+                return node instanceof HTMLElement && "button" === node.tagName.toLowerCase();
+            }
+            function isAElement(node) {
+                return node instanceof HTMLElement && "a" === node.tagName.toLowerCase();
+            }
+            function isImgElement(node) {
+                if (!includeBaseElement(node) && node instanceof Element) {
+                    const computedStyle = window.getComputedStyle(node);
+                    const backgroundImage = computedStyle.getPropertyValue("background-image");
+                    if ("none" !== backgroundImage) return true;
+                }
+                if (isIconfont(node)) return true;
+                return node instanceof HTMLElement && "img" === node.tagName.toLowerCase() || node instanceof SVGElement && "svg" === node.tagName.toLowerCase();
+            }
+            function isIconfont(node) {
+                if (node instanceof Element) {
+                    const computedStyle = window.getComputedStyle(node);
+                    const fontFamilyValue = computedStyle.fontFamily || "";
+                    return fontFamilyValue.toLowerCase().indexOf("iconfont") >= 0;
+                }
+                return false;
+            }
+            function isNotContainerElement(node) {
+                return isTextElement(node) || isIconfont(node) || isImgElement(node) || isButtonElement(node) || isAElement(node) || isFormElement(node);
+            }
+            function isTextElement(node) {
+                if (node instanceof Element) {
+                    if (node?.childNodes?.length === 1 && node?.childNodes[0] instanceof Text) return true;
+                }
+                return node.nodeName?.toLowerCase() === "#text" && !isIconfont(node);
+            }
+            function isContainerElement(node) {
+                if (!(node instanceof HTMLElement)) return false;
+                if (includeBaseElement(node)) return false;
+                const computedStyle = window.getComputedStyle(node);
+                const backgroundColor = computedStyle.getPropertyValue("background-color");
+                if (backgroundColor) return true;
+                return false;
+            }
+            function includeBaseElement(node) {
+                if (!(node instanceof HTMLElement)) return false;
+                if (node.innerText) return true;
+                const includeList = [
+                    "svg",
+                    "button",
+                    "input",
+                    "textarea",
+                    "select",
+                    "option",
+                    "img",
+                    "a"
+                ];
+                for (const tagName of includeList){
+                    const element = node.querySelectorAll(tagName);
+                    if (element.length > 0) return true;
+                }
+                return false;
+            }
+            function generateElementByPosition(position) {
+                const rect = {
+                    left: Math.max(position.x - 4, 0),
+                    top: Math.max(position.y - 4, 0),
+                    width: 8,
+                    height: 8
+                };
+                const id = generateHashId(rect);
+                const element = {
+                    id,
+                    attributes: {
+                        nodeType: "POSITION Node"
+                    },
+                    rect,
+                    content: "",
+                    center: [
+                        position.x,
+                        position.y
+                    ]
+                };
+                return element;
+            }
+            var MAX_VALUE_LENGTH = 300;
+            var debugMode = false;
+            function setDebugMode(mode) {
+                debugMode = mode;
+            }
+            function logger(..._msg) {
+                if (!debugMode) return;
+                console.log(..._msg);
+            }
+            function isElementPartiallyInViewport(rect, currentWindow, currentDocument, visibleAreaRatio = 2 / 3) {
+                const elementHeight = rect.height;
+                const elementWidth = rect.width;
+                const viewportRect = {
+                    left: 0,
+                    top: 0,
+                    width: currentWindow.innerWidth || currentDocument.documentElement.clientWidth,
+                    height: currentWindow.innerHeight || currentDocument.documentElement.clientHeight,
+                    right: currentWindow.innerWidth || currentDocument.documentElement.clientWidth,
+                    bottom: currentWindow.innerHeight || currentDocument.documentElement.clientHeight,
+                    x: 0,
+                    y: 0,
+                    zoom: 1
+                };
+                const overlapRect = overlappedRect(rect, viewportRect);
+                if (!overlapRect) return false;
+                const visibleArea = overlapRect.width * overlapRect.height;
+                const totalArea = elementHeight * elementWidth;
+                return visibleArea / totalArea >= visibleAreaRatio;
+            }
+            function getPseudoElementContent(element, currentWindow) {
+                if (!(element instanceof currentWindow.HTMLElement)) return {
+                    before: "",
+                    after: ""
+                };
+                const beforeContent = currentWindow.getComputedStyle(element, "::before").getPropertyValue("content");
+                const afterContent = currentWindow.getComputedStyle(element, "::after").getPropertyValue("content");
+                return {
+                    before: "none" === beforeContent ? "" : beforeContent.replace(/"/g, ""),
+                    after: "none" === afterContent ? "" : afterContent.replace(/"/g, "")
+                };
+            }
+            function overlappedRect(rect1, rect2) {
+                const left = Math.max(rect1.left, rect2.left);
+                const top = Math.max(rect1.top, rect2.top);
+                const right = Math.min(rect1.right, rect2.right);
+                const bottom = Math.min(rect1.bottom, rect2.bottom);
+                if (left < right && top < bottom) return {
+                    left,
+                    top,
+                    right,
+                    bottom,
+                    width: right - left,
+                    height: bottom - top,
+                    x: left,
+                    y: top,
+                    zoom: 1
+                };
+                return null;
+            }
+            function getRect(el, baseZoom, currentWindow) {
+                let originalRect;
+                let newZoom = 1;
+                if (el instanceof currentWindow.HTMLElement) {
+                    originalRect = el.getBoundingClientRect();
+                    if (!("currentCSSZoom" in el)) newZoom = Number.parseFloat(currentWindow.getComputedStyle(el).zoom) || 1;
+                } else {
+                    const range = currentWindow.document.createRange();
+                    range.selectNodeContents(el);
+                    originalRect = range.getBoundingClientRect();
+                }
+                const zoom = newZoom * baseZoom;
+                return {
+                    width: originalRect.width * zoom,
+                    height: originalRect.height * zoom,
+                    left: originalRect.left * zoom,
+                    top: originalRect.top * zoom,
+                    right: originalRect.right * zoom,
+                    bottom: originalRect.bottom * zoom,
+                    x: originalRect.x * zoom,
+                    y: originalRect.y * zoom,
+                    zoom
+                };
+            }
+            var isElementCovered = (el, rect, currentWindow)=>{
+                const x = rect.left + rect.width / 2;
+                const y = rect.top + rect.height / 2;
+                const topElement = currentWindow.document.elementFromPoint(x, y);
+                if (!topElement) return false;
+                if (topElement === el) return false;
+                if (el?.contains(topElement)) return false;
+                if (topElement?.contains(el)) return false;
+                const rectOfTopElement = getRect(topElement, 1, currentWindow);
+                const overlapRect = overlappedRect(rect, rectOfTopElement);
+                if (!overlapRect) return false;
+                logger(el, "Element is covered by another element", {
+                    topElement,
+                    el,
+                    rect,
+                    x,
+                    y
+                });
+                return true;
             };
-            this.eventCallback(clickEvent);
-        };
-        handleScroll = (event)=>{
-            if (!this.isRecording) return;
-            function isDocument(target) {
-                return target instanceof Document;
-            }
-            const target = event.target;
-            const scrollXTarget = isDocument(target) ? window.scrollX : target.scrollLeft;
-            const scrollYTarget = isDocument(target) ? window.scrollY : target.scrollTop;
-            const rect = isDocument(target) ? {
+            function elementRect(el, currentWindow, currentDocument, baseZoom = 1) {
+                if (!el) {
+                    logger(el, "Element is not in the DOM hierarchy");
+                    return false;
+                }
+                if (!(el instanceof currentWindow.HTMLElement) && el.nodeType !== Node.TEXT_NODE && "svg" !== el.nodeName.toLowerCase()) {
+                    logger(el, "Element is not in the DOM hierarchy");
+                    return false;
+                }
+                if (el instanceof currentWindow.HTMLElement) {
+                    const style = currentWindow.getComputedStyle(el);
+                    if ("none" === style.display || "hidden" === style.visibility || "0" === style.opacity && "INPUT" !== el.tagName) {
+                        logger(el, "Element is hidden");
+                        return false;
+                    }
+                }
+                const rect = getRect(el, baseZoom, currentWindow);
+                if (0 === rect.width && 0 === rect.height) {
+                    logger(el, "Element has no size");
+                    return false;
+                }
+                if (1 === baseZoom && isElementCovered(el, rect, currentWindow)) return false;
+                const isVisible = isElementPartiallyInViewport(rect, currentWindow, currentDocument);
+                let parent = el;
+                const parentUntilNonStatic = (currentNode)=>{
+                    let parent2 = currentNode?.parentElement;
+                    while(parent2){
+                        const style = currentWindow.getComputedStyle(parent2);
+                        if ("static" !== style.position) return parent2;
+                        parent2 = parent2.parentElement;
+                    }
+                    return null;
+                };
+                while(parent && parent !== currentDocument.body){
+                    if (!(parent instanceof currentWindow.HTMLElement)) {
+                        parent = parent.parentElement;
+                        continue;
+                    }
+                    const parentStyle = currentWindow.getComputedStyle(parent);
+                    if ("hidden" === parentStyle.overflow) {
+                        const parentRect = getRect(parent, 1, currentWindow);
+                        const tolerance = 10;
+                        if (rect.right < parentRect.left - tolerance || rect.left > parentRect.right + tolerance || rect.bottom < parentRect.top - tolerance || rect.top > parentRect.bottom + tolerance) {
+                            logger(el, "element is partially or totally hidden by an ancestor", {
+                                rect,
+                                parentRect
+                            });
+                            return false;
+                        }
+                    }
+                    if ("fixed" === parentStyle.position || "sticky" === parentStyle.position) break;
+                    parent = "absolute" === parentStyle.position ? parentUntilNonStatic(parent) : parent.parentElement;
+                }
+                return {
+                    left: Math.round(rect.left),
+                    top: Math.round(rect.top),
+                    width: Math.round(rect.width),
+                    height: Math.round(rect.height),
+                    zoom: rect.zoom,
+                    isVisible
+                };
+            }
+            function getNodeAttributes(node, currentWindow) {
+                if (!node || !(node instanceof currentWindow.HTMLElement) || !node.attributes) return {};
+                const attributesList = Array.from(node.attributes).map((attr)=>{
+                    if ("class" === attr.name) return [
+                        attr.name,
+                        `.${attr.value.split(" ").join(".")}`
+                    ];
+                    if (!attr.value) return [];
+                    let value = attr.value;
+                    if (value.startsWith("data:image")) value = "image";
+                    if (value.length > MAX_VALUE_LENGTH) value = `${value.slice(0, MAX_VALUE_LENGTH)}...`;
+                    return [
+                        attr.name,
+                        value
+                    ];
+                });
+                return Object.fromEntries(attributesList);
+            }
+            function midsceneGenerateHash(node, content, rect) {
+                const slicedHash = generateHashId(rect, content);
+                if (node) {
+                    if (!window.midsceneNodeHashCacheList) setNodeHashCacheListOnWindow();
+                    setNodeToCacheList(node, slicedHash);
+                }
+                return slicedHash;
+            }
+            function setNodeHashCacheListOnWindow() {
+                if ("undefined" != typeof window) window.midsceneNodeHashCacheList = [];
+            }
+            function setNodeToCacheList(node, id) {
+                if ("undefined" != typeof window) {
+                    if (getNodeFromCacheList(id)) return;
+                    window.midsceneNodeHashCacheList?.push({
+                        node,
+                        id
+                    });
+                }
+            }
+            function getNodeFromCacheList(id) {
+                if ("undefined" != typeof window) return window.midsceneNodeHashCacheList?.find((item)=>item.id === id)?.node;
+                return null;
+            }
+            function getTopDocument() {
+                const container = document.body || document;
+                return container;
+            }
+            var indexId = 0;
+            function tagNameOfNode(node) {
+                let tagName = "";
+                if (node instanceof HTMLElement) tagName = node.tagName?.toLowerCase();
+                else {
+                    const parentElement = node.parentElement;
+                    if (parentElement && parentElement instanceof HTMLElement) tagName = parentElement.tagName?.toLowerCase();
+                }
+                return tagName ? `<${tagName}>` : "";
+            }
+            function collectElementInfo(node, currentWindow, currentDocument, baseZoom = 1, basePoint = {
                 left: 0,
-                top: 0,
-                width: window.innerWidth,
-                height: window.innerHeight
-            } : target.getBoundingClientRect();
-            if (this.scrollThrottleTimer) clearTimeout(this.scrollThrottleTimer);
-            this.scrollThrottleTimer = window.setTimeout(()=>{
-                if (this.isRecording) {
-                    const elementRect = {
-                        left: isDocument(target) ? 0 : Number(rect.left.toFixed(2)),
-                        top: isDocument(target) ? 0 : Number(rect.top.toFixed(2)),
-                        width: isDocument(target) ? window.innerWidth : Number(rect.width.toFixed(2)),
-                        height: isDocument(target) ? window.innerHeight : Number(rect.height.toFixed(2))
+                top: 0
+            }) {
+                const rect = elementRect(node, currentWindow, currentDocument, baseZoom);
+                if (!rect) return null;
+                if (rect.width < CONTAINER_MINI_WIDTH || rect.height < CONTAINER_MINI_HEIGHT) return null;
+                if (0 !== basePoint.left || 0 !== basePoint.top) {
+                    rect.left += basePoint.left;
+                    rect.top += basePoint.top;
+                }
+                if (rect.height >= window.innerHeight && rect.width >= window.innerWidth) return null;
+                if (isFormElement(node)) {
+                    const attributes = getNodeAttributes(node, currentWindow);
+                    let valueContent = attributes.value || attributes.placeholder || node.textContent || "";
+                    const nodeHashId = midsceneGenerateHash(node, valueContent, rect);
+                    const tagName = node.tagName.toLowerCase();
+                    if ("select" === node.tagName.toLowerCase()) {
+                        const selectedOption = node.options[node.selectedIndex];
+                        valueContent = selectedOption?.textContent || "";
+                    }
+                    if (("input" === node.tagName.toLowerCase() || "textarea" === node.tagName.toLowerCase()) && node.value) valueContent = node.value;
+                    const elementInfo = {
+                        id: nodeHashId,
+                        nodeHashId,
+                        nodeType: "FORM_ITEM Node",
+                        indexId: indexId++,
+                        attributes: {
+                            ...attributes,
+                            htmlTagName: `<${tagName}>`,
+                            nodeType: "FORM_ITEM Node"
+                        },
+                        content: valueContent.trim(),
+                        rect,
+                        center: [
+                            Math.round(rect.left + rect.width / 2),
+                            Math.round(rect.top + rect.height / 2)
+                        ],
+                        zoom: rect.zoom,
+                        isVisible: rect.isVisible
                     };
-                    const scrollEvent = {
-                        type: 'scroll',
-                        elementRect,
-                        pageInfo: {
-                            width: window.innerWidth,
-                            height: window.innerHeight
+                    return elementInfo;
+                }
+                if (isButtonElement(node)) {
+                    const rect2 = mergeElementAndChildrenRects(node, currentWindow, currentDocument, baseZoom);
+                    if (!rect2) return null;
+                    const attributes = getNodeAttributes(node, currentWindow);
+                    const pseudo = getPseudoElementContent(node, currentWindow);
+                    const content = node.innerText || pseudo.before || pseudo.after || "";
+                    const nodeHashId = midsceneGenerateHash(node, content, rect2);
+                    const elementInfo = {
+                        id: nodeHashId,
+                        indexId: indexId++,
+                        nodeHashId,
+                        nodeType: "BUTTON Node",
+                        attributes: {
+                            ...attributes,
+                            htmlTagName: tagNameOfNode(node),
+                            nodeType: "BUTTON Node"
                         },
-                        value: `${scrollXTarget.toFixed(2)},${scrollYTarget.toFixed(2)}`,
-                        timestamp: Date.now(),
-                        hashId: generateHashId('scroll', {
-                            ...elementRect
-                        }),
-                        element: target
+                        content,
+                        rect: rect2,
+                        center: [
+                            Math.round(rect2.left + rect2.width / 2),
+                            Math.round(rect2.top + rect2.height / 2)
+                        ],
+                        zoom: rect2.zoom,
+                        isVisible: rect2.isVisible
                     };
-                    this.eventCallback(scrollEvent);
+                    return elementInfo;
                 }
-                this.scrollThrottleTimer = null;
-            }, this.scrollThrottleDelay);
-        };
-        handleInput = (event)=>{
-            if (!this.isRecording) return;
-            const target = event.target;
-            if ('checkbox' === target.type) return;
-            const rect = target.getBoundingClientRect();
-            const elementRect = {
-                left: Number(rect.left.toFixed(2)),
-                top: Number(rect.top.toFixed(2)),
-                width: Number(rect.width.toFixed(2)),
-                height: Number(rect.height.toFixed(2))
-            };
-            const inputEvent = {
-                type: 'input',
-                value: 'password' !== target.type ? target.value : '*****',
-                timestamp: Date.now(),
-                hashId: generateHashId('input', {
-                    ...elementRect
-                }),
-                element: target,
-                inputType: target.type || 'text',
-                elementRect,
-                pageInfo: {
-                    width: window.innerWidth,
-                    height: window.innerHeight
+                if (isImgElement(node)) {
+                    const attributes = getNodeAttributes(node, currentWindow);
+                    const nodeHashId = midsceneGenerateHash(node, "", rect);
+                    const elementInfo = {
+                        id: nodeHashId,
+                        indexId: indexId++,
+                        nodeHashId,
+                        attributes: {
+                            ...attributes,
+                            ...node.nodeName?.toLowerCase() === "svg" ? {
+                                svgContent: "true"
+                            } : {},
+                            nodeType: "IMG Node",
+                            htmlTagName: tagNameOfNode(node)
+                        },
+                        nodeType: "IMG Node",
+                        content: "",
+                        rect,
+                        center: [
+                            Math.round(rect.left + rect.width / 2),
+                            Math.round(rect.top + rect.height / 2)
+                        ],
+                        zoom: rect.zoom,
+                        isVisible: rect.isVisible
+                    };
+                    return elementInfo;
                 }
-            };
-            this.eventCallback(inputEvent);
-        };
-        checkLabelClick(target) {
-            let isLabelClick = false;
-            let labelInfo;
-            if (target) if ('LABEL' === target.tagName) {
-                isLabelClick = true;
-                labelInfo = {
-                    htmlFor: target.htmlFor,
-                    textContent: target.textContent?.trim()
+                if (isTextElement(node)) {
+                    const text = node.textContent?.trim().replace(/\n+/g, " ");
+                    if (!text) return null;
+                    const attributes = getNodeAttributes(node, currentWindow);
+                    const attributeKeys = Object.keys(attributes);
+                    if (!text.trim() && 0 === attributeKeys.length) return null;
+                    const nodeHashId = midsceneGenerateHash(node, text, rect);
+                    const elementInfo = {
+                        id: nodeHashId,
+                        indexId: indexId++,
+                        nodeHashId,
+                        nodeType: "TEXT Node",
+                        attributes: {
+                            ...attributes,
+                            nodeType: "TEXT Node",
+                            htmlTagName: tagNameOfNode(node)
+                        },
+                        center: [
+                            Math.round(rect.left + rect.width / 2),
+                            Math.round(rect.top + rect.height / 2)
+                        ],
+                        content: text,
+                        rect,
+                        zoom: rect.zoom,
+                        isVisible: rect.isVisible
+                    };
+                    return elementInfo;
+                }
+                if (isAElement(node)) {
+                    const attributes = getNodeAttributes(node, currentWindow);
+                    const pseudo = getPseudoElementContent(node, currentWindow);
+                    const content = node.innerText || pseudo.before || pseudo.after || "";
+                    const nodeHashId = midsceneGenerateHash(node, content, rect);
+                    const elementInfo = {
+                        id: nodeHashId,
+                        indexId: indexId++,
+                        nodeHashId,
+                        nodeType: "Anchor Node",
+                        attributes: {
+                            ...attributes,
+                            htmlTagName: tagNameOfNode(node),
+                            nodeType: "Anchor Node"
+                        },
+                        content,
+                        rect,
+                        center: [
+                            Math.round(rect.left + rect.width / 2),
+                            Math.round(rect.top + rect.height / 2)
+                        ],
+                        zoom: rect.zoom,
+                        isVisible: rect.isVisible
+                    };
+                    return elementInfo;
+                }
+                if (isContainerElement(node)) {
+                    const attributes = getNodeAttributes(node, currentWindow);
+                    const nodeHashId = midsceneGenerateHash(node, "", rect);
+                    const elementInfo = {
+                        id: nodeHashId,
+                        nodeHashId,
+                        indexId: indexId++,
+                        nodeType: "CONTAINER Node",
+                        attributes: {
+                            ...attributes,
+                            nodeType: "CONTAINER Node",
+                            htmlTagName: tagNameOfNode(node)
+                        },
+                        content: "",
+                        rect,
+                        center: [
+                            Math.round(rect.left + rect.width / 2),
+                            Math.round(rect.top + rect.height / 2)
+                        ],
+                        zoom: rect.zoom,
+                        isVisible: rect.isVisible
+                    };
+                    return elementInfo;
+                }
+                return null;
+            }
+            function extractTextWithPosition(initNode, debugMode2 = false) {
+                const elementNode = extractTreeNode(initNode, debugMode2);
+                const elementInfoArray = [];
+                function dfsTopChildren(node) {
+                    if (node.node) elementInfoArray.push(node.node);
+                    for(let i = 0; i < node.children.length; i++)dfsTopChildren(node.children[i]);
+                }
+                dfsTopChildren({
+                    children: elementNode.children,
+                    node: elementNode.node
+                });
+                return elementInfoArray;
+            }
+            function extractTreeNodeAsString(initNode, visibleOnly = false, debugMode2 = false) {
+                const elementNode = extractTreeNode(initNode, debugMode2);
+                return descriptionOfTree(elementNode, void 0, false, visibleOnly);
+            }
+            function extractTreeNode(initNode, debugMode2 = false) {
+                setDebugMode(debugMode2);
+                indexId = 0;
+                const topDocument = getTopDocument();
+                const startNode = initNode || topDocument;
+                const topChildren = [];
+                function dfs(node, currentWindow, currentDocument, baseZoom = 1, basePoint = {
+                    left: 0,
+                    top: 0
+                }) {
+                    if (!node) return null;
+                    if (node.nodeType && 10 === node.nodeType) return null;
+                    const elementInfo = collectElementInfo(node, currentWindow, currentDocument, baseZoom, basePoint);
+                    if (node instanceof currentWindow.HTMLIFrameElement) {
+                        if (node.contentWindow && node.contentWindow) return null;
+                    }
+                    const nodeInfo = {
+                        node: elementInfo,
+                        children: []
+                    };
+                    if (elementInfo?.nodeType === "BUTTON Node" || elementInfo?.nodeType === "IMG Node" || elementInfo?.nodeType === "TEXT Node" || elementInfo?.nodeType === "FORM_ITEM Node" || elementInfo?.nodeType === "CONTAINER Node") return nodeInfo;
+                    const rect = getRect(node, baseZoom, currentWindow);
+                    for(let i = 0; i < node.childNodes.length; i++){
+                        logger("will dfs", node.childNodes[i]);
+                        const childNodeInfo = dfs(node.childNodes[i], currentWindow, currentDocument, rect.zoom, basePoint);
+                        if (Array.isArray(childNodeInfo)) nodeInfo.children.push(...childNodeInfo);
+                        else if (childNodeInfo) nodeInfo.children.push(childNodeInfo);
+                    }
+                    if (null === nodeInfo.node) {
+                        if (0 === nodeInfo.children.length) return null;
+                        return nodeInfo.children;
+                    }
+                    return nodeInfo;
+                }
+                const rootNodeInfo = dfs(startNode, window, document, 1, {
+                    left: 0,
+                    top: 0
+                });
+                if (Array.isArray(rootNodeInfo)) topChildren.push(...rootNodeInfo);
+                else if (rootNodeInfo) topChildren.push(rootNodeInfo);
+                if (startNode === topDocument) {
+                    const iframes = document.querySelectorAll("iframe");
+                    for(let i = 0; i < iframes.length; i++){
+                        const iframe = iframes[i];
+                        if (iframe.contentDocument && iframe.contentWindow) {
+                            const iframeInfo = collectElementInfo(iframe, window, document, 1);
+                            if (iframeInfo) {
+                                const iframeChildren = dfs(iframe.contentDocument.body, iframe.contentWindow, iframe.contentDocument, 1, {
+                                    left: iframeInfo.rect.left,
+                                    top: iframeInfo.rect.top
+                                });
+                                if (Array.isArray(iframeChildren)) topChildren.push(...iframeChildren);
+                                else if (iframeChildren) topChildren.push(iframeChildren);
+                            }
+                        }
+                    }
+                }
+                return {
+                    node: null,
+                    children: topChildren
                 };
-            } else {
-                let parent = target.parentElement;
-                while(parent){
-                    if ('LABEL' === parent.tagName) {
-                        isLabelClick = true;
-                        labelInfo = {
-                            htmlFor: parent.htmlFor,
-                            textContent: parent.textContent?.trim()
-                        };
-                        break;
+            }
+            function mergeElementAndChildrenRects(node, currentWindow, currentDocument, baseZoom = 1) {
+                const selfRect = elementRect(node, currentWindow, currentDocument, baseZoom);
+                if (!selfRect) return null;
+                let minLeft = selfRect.left;
+                let minTop = selfRect.top;
+                let maxRight = selfRect.left + selfRect.width;
+                let maxBottom = selfRect.top + selfRect.height;
+                function traverse(child) {
+                    for(let i = 0; i < child.childNodes.length; i++){
+                        const sub = child.childNodes[i];
+                        if (1 === sub.nodeType) {
+                            const rect = elementRect(sub, currentWindow, currentDocument, baseZoom);
+                            if (rect) {
+                                minLeft = Math.min(minLeft, rect.left);
+                                minTop = Math.min(minTop, rect.top);
+                                maxRight = Math.max(maxRight, rect.left + rect.width);
+                                maxBottom = Math.max(maxBottom, rect.top + rect.height);
+                            }
+                            traverse(sub);
+                        }
                     }
-                    parent = parent.parentElement;
                 }
+                traverse(node);
+                return {
+                    ...selfRect,
+                    left: minLeft,
+                    top: minTop,
+                    width: maxRight - minLeft,
+                    height: maxBottom - minTop
+                };
             }
-            return {
-                isLabelClick,
-                labelInfo
+            var getElementIndex = (element)=>{
+                let index = 1;
+                let prev = element.previousElementSibling;
+                while(prev){
+                    if (prev.nodeName.toLowerCase() === element.nodeName.toLowerCase()) index++;
+                    prev = prev.previousElementSibling;
+                }
+                return index;
             };
-        }
-        isActive() {
-            return this.isRecording;
-        }
-        optimizeEvent(event, events) {
-            const lastEvent = events[events.length - 1];
-            if ('click' === event.type) {
-                const lastEvent = getLastLabelClick(events);
-                if (lastEvent && 'click' === lastEvent.type && lastEvent.isLabelClick && lastEvent.labelInfo?.htmlFor === event.element.id) {
-                    debugLog('Skip input event triggered by label click:', event.element);
-                    return events;
+            var getTextNodeIndex = (textNode)=>{
+                let index = 1;
+                let current = textNode.previousSibling;
+                while(current){
+                    if (current.nodeType === Node.TEXT_NODE) index++;
+                    current = current.previousSibling;
                 }
+                return index;
+            };
+            var createNormalizeSpaceCondition = (textContent)=>`[normalize-space()="${textContent}"]`;
+            var addTextContentToXPath = (el, baseXPath)=>{
+                const textContent = el.textContent?.trim();
+                if (textContent && (isButtonElement(el) || isFormElement(el))) return `${baseXPath}${createNormalizeSpaceCondition(textContent)}`;
+                return baseXPath;
+            };
+            var getElementXPath = (element)=>{
+                if (element.nodeType === Node.TEXT_NODE) {
+                    const parentNode = element.parentNode;
+                    if (parentNode && parentNode.nodeType === Node.ELEMENT_NODE) {
+                        const parentXPath2 = getElementXPath(parentNode);
+                        const textIndex = getTextNodeIndex(element);
+                        const textContent = element.textContent?.trim();
+                        if (textContent) return `${parentXPath2}/text()[${textIndex}]${createNormalizeSpaceCondition(textContent)}`;
+                        return `${parentXPath2}/text()[${textIndex}]`;
+                    }
+                    return "";
+                }
+                if (element.nodeType !== Node.ELEMENT_NODE) return "";
+                const el = element;
+                if (el === document.documentElement) return "/html";
+                if (el === document.body) return "/html/body";
+                const index = getElementIndex(el);
+                const tagName = el.nodeName.toLowerCase();
+                if (!el.parentNode) {
+                    const baseXPath2 = `/${tagName}`;
+                    return addTextContentToXPath(el, baseXPath2);
+                }
+                const parentXPath = getElementXPath(el.parentNode);
+                const baseXPath = `${parentXPath}/${tagName}[${index}]`;
+                return addTextContentToXPath(el, baseXPath);
+            };
+            function generateXPaths(node) {
+                if (!node) return [];
+                const fullXPath = getElementXPath(node);
                 return [
-                    ...events,
-                    event
+                    fullXPath
                 ];
             }
-            if ('input' === event.type) {
-                if (lastEvent && 'click' === lastEvent.type && lastEvent.isLabelClick && lastEvent.labelInfo?.htmlFor === event.targetId) {
-                    debugLog('Skipping input event - triggered by label click:', {
-                        labelHtmlFor: getLastLabelClick(events)?.labelInfo?.htmlFor,
-                        inputId: event.targetId,
-                        element: event.element
+            function getXpathsById(id) {
+                const node = getNodeFromCacheList(id);
+                if (!node) return null;
+                return generateXPaths(node);
+            }
+            function getNodeInfoByXpath(xpath) {
+                const xpathResult = document.evaluate(xpath, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+                if (1 !== xpathResult.snapshotLength) return null;
+                const node = xpathResult.snapshotItem(0);
+                return node;
+            }
+            function getElementInfoByXpath(xpath) {
+                const node = getNodeInfoByXpath(xpath);
+                if (!node) return null;
+                if (node instanceof HTMLElement) {
+                    const rect = getRect(node, 1, window);
+                    const isVisible = isElementPartiallyInViewport(rect, window, document, 1);
+                    if (!isVisible) node.scrollIntoView({
+                        behavior: "instant",
+                        block: "center"
                     });
-                    return events;
                 }
-                if (lastEvent && 'input' === lastEvent.type && isSameInputTarget(lastEvent, event)) {
-                    const oldInputEvent = events[events.length - 1];
-                    const newEvents = [
-                        ...events
-                    ];
-                    newEvents[events.length - 1] = {
-                        value: event.element?.value,
-                        ...event
-                    };
-                    debugLog('Merging input event:', {
-                        oldValue: oldInputEvent.value,
-                        newValue: event.value,
-                        oldTimestamp: oldInputEvent.timestamp,
-                        newTimestamp: event.timestamp,
-                        target: event.targetTagName
+                return collectElementInfo(node, window, document, 1, {
+                    left: 0,
+                    top: 0
+                });
+            }
+        },
+        "?d94c": function() {},
+        "?7342": function() {}
+    };
+    var __webpack_module_cache__ = {};
+    function __webpack_require__(moduleId) {
+        var cachedModule = __webpack_module_cache__[moduleId];
+        if (void 0 !== cachedModule) return cachedModule.exports;
+        var module = __webpack_module_cache__[moduleId] = {
+            exports: {}
+        };
+        __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+        return module.exports;
+    }
+    (()=>{
+        __webpack_require__.g = (()=>{
+            if ('object' == typeof globalThis) return globalThis;
+            try {
+                return this || new Function('return this')();
+            } catch (e) {
+                if ('object' == typeof window) return window;
+            }
+        })();
+    })();
+    (()=>{
+        "use strict";
+        var extractor = __webpack_require__("../shared/dist/lib/extractor.js");
+        const DEBUG = 'true' === localStorage.getItem('DEBUG');
+        function debugLog(...args) {
+            if (DEBUG) console.log('[EventRecorder]', ...args);
+        }
+        function generateHashId(type, elementRect) {
+            const rectStr = elementRect ? `${elementRect.left}_${elementRect.top}_${elementRect.width}_${elementRect.height}${void 0 !== elementRect.x ? `_${elementRect.x}` : ''}${void 0 !== elementRect.y ? `_${elementRect.y}` : ''}` : 'no_rect';
+            const combined = `${type}_${rectStr}`;
+            let hash = 0;
+            for(let i = 0; i < combined.length; i++){
+                const char = combined.charCodeAt(i);
+                hash = (hash << 5) - hash + char;
+                hash &= hash;
+            }
+            return Math.abs(hash).toString(36);
+        }
+        const isSameInputTarget = (event1, event2)=>event1.element === event2.element;
+        const isSameScrollTarget = (event1, event2)=>event1.element === event2.element;
+        const getLastLabelClick = (events)=>{
+            for(let i = events.length - 1; i >= 0; i--){
+                const event = events[i];
+                if ('click' === event.type && event.isLabelClick) return event;
+            }
+        };
+        function getAllScrollableElements() {
+            const elements = [];
+            const all = document.querySelectorAll('body *');
+            all.forEach((el)=>{
+                const style = window.getComputedStyle(el);
+                const overflowY = style.overflowY;
+                const overflowX = style.overflowX;
+                const isScrollableY = ('auto' === overflowY || 'scroll' === overflowY) && el.scrollHeight > el.clientHeight;
+                const isScrollableX = ('auto' === overflowX || 'scroll' === overflowX) && el.scrollWidth > el.clientWidth;
+                if (isScrollableY || isScrollableX) elements.push(el);
+            });
+            return elements;
+        }
+        class EventRecorder {
+            isRecording = false;
+            eventCallback;
+            scrollThrottleTimer = null;
+            scrollThrottleDelay = 200;
+            inputThrottleTimer = null;
+            inputThrottleDelay = 300;
+            lastViewportScroll = null;
+            scrollTargets = [];
+            sessionId;
+            constructor(eventCallback, sessionId){
+                this.eventCallback = eventCallback;
+                this.sessionId = sessionId;
+            }
+            createNavigationEvent(url, title) {
+                return {
+                    type: 'navigation',
+                    url,
+                    title,
+                    pageInfo: {
+                        width: window.innerWidth,
+                        height: window.innerHeight
+                    },
+                    timestamp: Date.now(),
+                    hashId: `navigation_${Date.now()}`
+                };
+            }
+            start() {
+                if (this.isRecording) return void debugLog('Recording already active, ignoring start request');
+                this.isRecording = true;
+                debugLog('Starting event recording');
+                this.scrollTargets = [];
+                if (0 === this.scrollTargets.length) {
+                    this.scrollTargets = getAllScrollableElements();
+                    this.scrollTargets.push(document.body);
+                }
+                debugLog('Added event listeners for', this.scrollTargets.length, 'scroll targets');
+                setTimeout(()=>{
+                    const navigationEvent = this.createNavigationEvent(window.location.href, document.title);
+                    this.eventCallback(navigationEvent);
+                    debugLog('Added final navigation event', navigationEvent);
+                }, 0);
+                document.addEventListener('click', this.handleClick, true);
+                document.addEventListener('input', this.handleInput);
+                document.addEventListener('scroll', this.handleScroll, {
+                    passive: true
+                });
+                this.scrollTargets.forEach((target)=>{
+                    target.addEventListener('scroll', this.handleScroll, {
+                        passive: true
                     });
-                    return newEvents;
+                });
+            }
+            stop() {
+                if (!this.isRecording) return void debugLog('Recording not active, ignoring stop request');
+                this.isRecording = false;
+                debugLog('Stopping event recording');
+                if (this.scrollThrottleTimer) {
+                    clearTimeout(this.scrollThrottleTimer);
+                    this.scrollThrottleTimer = null;
+                }
+                if (this.inputThrottleTimer) {
+                    clearTimeout(this.inputThrottleTimer);
+                    this.inputThrottleTimer = null;
                 }
+                document.removeEventListener('click', this.handleClick);
+                document.removeEventListener('input', this.handleInput);
+                this.scrollTargets.forEach((target)=>{
+                    target.removeEventListener('scroll', this.handleScroll);
+                });
+                debugLog('Removed all event listeners');
             }
-            if ('scroll' === event.type) {
-                if (lastEvent && 'scroll' === lastEvent.type && isSameScrollTarget(lastEvent, event)) {
-                    const oldScrollEvent = events[events.length - 1];
-                    const newEvents = [
-                        ...events
+            handleClick = (event)=>{
+                if (!this.isRecording) return;
+                const target = event.target;
+                const { isLabelClick, labelInfo } = this.checkLabelClick(target);
+                const rect = target.getBoundingClientRect();
+                const elementRect = {
+                    x: Number(event.clientX.toFixed(2)),
+                    y: Number(event.clientY.toFixed(2))
+                };
+                console.log('isNotContainerElement', (0, extractor.isNotContainerElement)(target));
+                if ((0, extractor.isNotContainerElement)(target)) {
+                    elementRect.left = Number(rect.left.toFixed(2));
+                    elementRect.top = Number(rect.top.toFixed(2));
+                    elementRect.width = Number(rect.width.toFixed(2));
+                    elementRect.height = Number(rect.height.toFixed(2));
+                }
+                const clickEvent = {
+                    type: 'click',
+                    elementRect,
+                    pageInfo: {
+                        width: window.innerWidth,
+                        height: window.innerHeight
+                    },
+                    value: '',
+                    timestamp: Date.now(),
+                    hashId: generateHashId('click', {
+                        ...elementRect
+                    }),
+                    element: target,
+                    isLabelClick,
+                    labelInfo,
+                    isTrusted: event.isTrusted,
+                    detail: event.detail
+                };
+                this.eventCallback(clickEvent);
+            };
+            handleScroll = (event)=>{
+                if (!this.isRecording) return;
+                function isDocument(target) {
+                    return target instanceof Document;
+                }
+                const target = event.target;
+                const scrollXTarget = isDocument(target) ? window.scrollX : target.scrollLeft;
+                const scrollYTarget = isDocument(target) ? window.scrollY : target.scrollTop;
+                const rect = isDocument(target) ? {
+                    left: 0,
+                    top: 0,
+                    width: window.innerWidth,
+                    height: window.innerHeight
+                } : target.getBoundingClientRect();
+                if (this.scrollThrottleTimer) clearTimeout(this.scrollThrottleTimer);
+                this.scrollThrottleTimer = window.setTimeout(()=>{
+                    if (this.isRecording) {
+                        const elementRect = {
+                            left: isDocument(target) ? 0 : Number(rect.left.toFixed(2)),
+                            top: isDocument(target) ? 0 : Number(rect.top.toFixed(2)),
+                            width: isDocument(target) ? window.innerWidth : Number(rect.width.toFixed(2)),
+                            height: isDocument(target) ? window.innerHeight : Number(rect.height.toFixed(2))
+                        };
+                        const scrollEvent = {
+                            type: 'scroll',
+                            elementRect,
+                            pageInfo: {
+                                width: window.innerWidth,
+                                height: window.innerHeight
+                            },
+                            value: `${scrollXTarget.toFixed(2)},${scrollYTarget.toFixed(2)}`,
+                            timestamp: Date.now(),
+                            hashId: generateHashId('scroll', {
+                                ...elementRect
+                            }),
+                            element: target
+                        };
+                        this.eventCallback(scrollEvent);
+                    }
+                    this.scrollThrottleTimer = null;
+                }, this.scrollThrottleDelay);
+            };
+            handleInput = (event)=>{
+                if (!this.isRecording) return;
+                const target = event.target;
+                if ('checkbox' === target.type) return;
+                const rect = target.getBoundingClientRect();
+                const elementRect = {
+                    left: Number(rect.left.toFixed(2)),
+                    top: Number(rect.top.toFixed(2)),
+                    width: Number(rect.width.toFixed(2)),
+                    height: Number(rect.height.toFixed(2))
+                };
+                if (this.inputThrottleTimer) clearTimeout(this.inputThrottleTimer);
+                this.inputThrottleTimer = window.setTimeout(()=>{
+                    if (this.isRecording) {
+                        const inputEvent = {
+                            type: 'input',
+                            value: 'password' !== target.type ? target.value : '*****',
+                            timestamp: Date.now(),
+                            hashId: generateHashId('input', {
+                                ...elementRect
+                            }),
+                            element: target,
+                            inputType: target.type || 'text',
+                            elementRect,
+                            pageInfo: {
+                                width: window.innerWidth,
+                                height: window.innerHeight
+                            }
+                        };
+                        debugLog('Throttled input event:', {
+                            value: inputEvent.value,
+                            timestamp: inputEvent.timestamp,
+                            target: target.tagName,
+                            inputType: target.type
+                        });
+                        this.eventCallback(inputEvent);
+                    }
+                    this.inputThrottleTimer = null;
+                }, this.inputThrottleDelay);
+            };
+            checkLabelClick(target) {
+                let isLabelClick = false;
+                let labelInfo;
+                if (target) if ('LABEL' === target.tagName) {
+                    isLabelClick = true;
+                    labelInfo = {
+                        htmlFor: target.htmlFor,
+                        textContent: target.textContent?.trim()
+                    };
+                } else {
+                    let parent = target.parentElement;
+                    while(parent){
+                        if ('LABEL' === parent.tagName) {
+                            isLabelClick = true;
+                            labelInfo = {
+                                htmlFor: parent.htmlFor,
+                                textContent: parent.textContent?.trim()
+                            };
+                            break;
+                        }
+                        parent = parent.parentElement;
+                    }
+                }
+                return {
+                    isLabelClick,
+                    labelInfo
+                };
+            }
+            isActive() {
+                return this.isRecording;
+            }
+            optimizeEvent(event, events) {
+                const lastEvent = events[events.length - 1];
+                if ('click' === event.type) {
+                    const lastEvent = getLastLabelClick(events);
+                    if (lastEvent && 'click' === lastEvent.type && lastEvent.isLabelClick && lastEvent.labelInfo?.htmlFor === event.element.id) {
+                        debugLog('Skip input event triggered by label click:', event.element);
+                        return events;
+                    }
+                    return [
+                        ...events,
+                        event
                     ];
-                    newEvents[events.length - 1] = event;
-                    debugLog('Replacing last scroll event with new scroll event:', {
-                        oldPosition: `${oldScrollEvent.elementRect?.left},${oldScrollEvent.elementRect?.top}`,
-                        newPosition: `${event.elementRect?.left},${event.elementRect?.top}`,
-                        oldTimestamp: oldScrollEvent.timestamp,
-                        newTimestamp: event.timestamp,
-                        target: event.targetTagName
-                    });
-                    return newEvents;
                 }
+                if ('input' === event.type) {
+                    if (lastEvent && 'click' === lastEvent.type && lastEvent.isLabelClick && lastEvent.labelInfo?.htmlFor === event.targetId) {
+                        debugLog('Skipping input event - triggered by label click:', {
+                            labelHtmlFor: getLastLabelClick(events)?.labelInfo?.htmlFor,
+                            inputId: event.targetId,
+                            element: event.element
+                        });
+                        return events;
+                    }
+                    if (lastEvent && 'input' === lastEvent.type && isSameInputTarget(lastEvent, event)) {
+                        const oldInputEvent = events[events.length - 1];
+                        const newEvents = [
+                            ...events
+                        ];
+                        newEvents[events.length - 1] = {
+                            value: event.element?.value,
+                            ...event
+                        };
+                        debugLog('Merging input event:', {
+                            oldValue: oldInputEvent.value,
+                            newValue: event.value,
+                            oldTimestamp: oldInputEvent.timestamp,
+                            newTimestamp: event.timestamp,
+                            target: event.targetTagName
+                        });
+                        return newEvents;
+                    }
+                }
+                if ('scroll' === event.type) {
+                    if (lastEvent && 'scroll' === lastEvent.type && isSameScrollTarget(lastEvent, event)) {
+                        const oldScrollEvent = events[events.length - 1];
+                        const newEvents = [
+                            ...events
+                        ];
+                        newEvents[events.length - 1] = event;
+                        debugLog('Replacing last scroll event with new scroll event:', {
+                            oldPosition: `${oldScrollEvent.elementRect?.left},${oldScrollEvent.elementRect?.top}`,
+                            newPosition: `${event.elementRect?.left},${event.elementRect?.top}`,
+                            oldTimestamp: oldScrollEvent.timestamp,
+                            newTimestamp: event.timestamp,
+                            target: event.targetTagName
+                        });
+                        return newEvents;
+                    }
+                }
+                return [
+                    ...events,
+                    event
+                ];
             }
-            return [
-                ...events,
-                event
-            ];
         }
-    }
-    window.EventRecorder = EventRecorder;
+        window.EventRecorder = EventRecorder;
+    })();
 })();