@midscene/web 0.7.2 → 0.7.3-beta-20241104100519.0

package/dist/es/chrome-extension.js

@@ -0,0 +1,1627 @@
+(function(global, factory) {
+    if (typeof module === "object" && typeof module.exports === "object") factory(exports, require("assert"), require("fs"), require("path"), require("@midscene/shared/constants"), require("@midscene/shared/fs"), require("@midscene/shared/img"), require("@midscene/shared/utils"), require("@midscene/core"), require("@midscene/core/utils"), require("@midscene/shared/browser/img"));
+    else if (typeof define === "function" && define.amd) define([
+        "exports",
+        "assert",
+        "fs",
+        "path",
+        "@midscene/shared/constants",
+        "@midscene/shared/fs",
+        "@midscene/shared/img",
+        "@midscene/shared/utils",
+        "@midscene/core",
+        "@midscene/core/utils",
+        "@midscene/shared/browser/img"
+    ], factory);
+    else if (global = typeof globalThis !== "undefined" ? globalThis : global || self) factory(global.chromeExtension = {}, global.assert, global.fs, global.path, global.constants, global.fs, global.img, global.utils, global.core, global.utils, global.img);
+})(this, function(exports, _assert, _fs, _path, _constants, _fs1, _img, _utils, _core, _utils1, _img1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+        value: true
+    });
+    function _export(target, all) {
+        for(var name in all)Object.defineProperty(target, name, {
+            enumerable: true,
+            get: all[name]
+        });
+    }
+    _export(exports, {
+        ChromeExtensionProxyPage: function() {
+            return ChromeExtensionProxyPage;
+        },
+        ChromeExtensionProxyPageAgent: function() {
+            return ChromeExtensionProxyPageAgent;
+        },
+        ERROR_CODE_NOT_IMPLEMENTED_AS_DESIGNED: function() {
+            return ERROR_CODE_NOT_IMPLEMENTED_AS_DESIGNED;
+        }
+    });
+    _assert = /*#__PURE__*/ _interop_require_default(_assert);
+    _path = /*#__PURE__*/ _interop_require_wildcard(_path);
+    function _interop_require_default(obj) {
+        return obj && obj.__esModule ? obj : {
+            default: obj
+        };
+    }
+    function _getRequireWildcardCache(nodeInterop) {
+        if (typeof WeakMap !== "function") return null;
+        var cacheBabelInterop = new WeakMap();
+        var cacheNodeInterop = new WeakMap();
+        return (_getRequireWildcardCache = function(nodeInterop) {
+            return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+        })(nodeInterop);
+    }
+    function _interop_require_wildcard(obj, nodeInterop) {
+        if (!nodeInterop && obj && obj.__esModule) {
+            return obj;
+        }
+        if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+            return {
+                default: obj
+            };
+        }
+        var cache = _getRequireWildcardCache(nodeInterop);
+        if (cache && cache.has(obj)) {
+            return cache.get(obj);
+        }
+        var newObj = {
+            __proto__: null
+        };
+        var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+        for(var key in obj){
+            if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+                var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+                if (desc && (desc.get || desc.set)) {
+                    Object.defineProperty(newObj, key, desc);
+                } else {
+                    newObj[key] = obj[key];
+                }
+            }
+        }
+        newObj.default = obj;
+        if (cache) {
+            cache.set(obj, newObj);
+        }
+        return newObj;
+    }
+    var __create = Object.create;
+    var __defProp = Object.defineProperty;
+    var __defProps = Object.defineProperties;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+    var __getProtoOf = Object.getPrototypeOf;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __propIsEnum = Object.prototype.propertyIsEnumerable;
+    var __defNormalProp = (obj, key, value)=>key in obj ? __defProp(obj, key, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value
+        }) : obj[key] = value;
+    var __spreadValues = (a, b)=>{
+        for(var prop in b || (b = {}))if (__hasOwnProp.call(b, prop)) __defNormalProp(a, prop, b[prop]);
+        if (__getOwnPropSymbols) for (var prop of __getOwnPropSymbols(b)){
+            if (__propIsEnum.call(b, prop)) __defNormalProp(a, prop, b[prop]);
+        }
+        return a;
+    };
+    var __spreadProps = (a, b)=>__defProps(a, __getOwnPropDescs(b));
+    var __commonJS = (cb, mod)=>function __require() {
+            return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = {
+                exports: {}
+            }).exports, mod), mod.exports;
+        };
+    var __copyProps = (to, from, except, desc)=>{
+        if (from && typeof from === "object" || typeof from === "function") {
+            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 __toESM = (mod, isNodeMode, target)=>(target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(// If the importer is in node compatibility mode or this is not an ESM
+        // file that has been converted to a CommonJS file using a Babel-
+        // compatible transform (i.e. "__esModule" has not been set), then set
+        // "default" to the CommonJS "module.exports" for node compatibility.
+        isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+            value: mod,
+            enumerable: true
+        }) : target, mod));
+    var __async = (__this, __arguments, generator)=>{
+        return new Promise((resolve, reject)=>{
+            var fulfilled = (value)=>{
+                try {
+                    step(generator.next(value));
+                } catch (e) {
+                    reject(e);
+                }
+            };
+            var rejected = (value)=>{
+                try {
+                    step(generator.throw(value));
+                } catch (e) {
+                    reject(e);
+                }
+            };
+            var step = (x)=>x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+            step((generator = generator.apply(__this, __arguments)).next());
+        });
+    };
+    // ../../node_modules/.pnpm/dayjs@1.11.11/node_modules/dayjs/dayjs.min.js
+    var require_dayjs_min = __commonJS({
+        "../../node_modules/.pnpm/dayjs@1.11.11/node_modules/dayjs/dayjs.min.js" (exports, module1) {
+            "use strict";
+            !function(t, e) {
+                "object" == typeof exports && "undefined" != typeof module1 ? module1.exports = e() : "function" == typeof define && define.amd ? define(e) : (t = "undefined" != typeof globalThis ? globalThis : t || self).dayjs = e();
+            }(exports, function() {
+                "use strict";
+                var t = 1e3, e = 6e4, n = 36e5, r = "millisecond", i = "second", s = "minute", u = "hour", a = "day", o = "week", c = "month", f = "quarter", h = "year", d = "date", l = "Invalid Date", $ = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/, y = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g, M = {
+                    name: "en",
+                    weekdays: "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),
+                    months: "January_February_March_April_May_June_July_August_September_October_November_December".split("_"),
+                    ordinal: function(t2) {
+                        var e2 = [
+                            "th",
+                            "st",
+                            "nd",
+                            "rd"
+                        ], n2 = t2 % 100;
+                        return "[" + t2 + (e2[(n2 - 20) % 10] || e2[n2] || e2[0]) + "]";
+                    }
+                }, m = function(t2, e2, n2) {
+                    var r2 = String(t2);
+                    return !r2 || r2.length >= e2 ? t2 : "" + Array(e2 + 1 - r2.length).join(n2) + t2;
+                }, v = {
+                    s: m,
+                    z: function(t2) {
+                        var e2 = -t2.utcOffset(), n2 = Math.abs(e2), r2 = Math.floor(n2 / 60), i2 = n2 % 60;
+                        return (e2 <= 0 ? "+" : "-") + m(r2, 2, "0") + ":" + m(i2, 2, "0");
+                    },
+                    m: function t2(e2, n2) {
+                        if (e2.date() < n2.date()) return -t2(n2, e2);
+                        var r2 = 12 * (n2.year() - e2.year()) + (n2.month() - e2.month()), i2 = e2.clone().add(r2, c), s2 = n2 - i2 < 0, u2 = e2.clone().add(r2 + (s2 ? -1 : 1), c);
+                        return +(-(r2 + (n2 - i2) / (s2 ? i2 - u2 : u2 - i2)) || 0);
+                    },
+                    a: function(t2) {
+                        return t2 < 0 ? Math.ceil(t2) || 0 : Math.floor(t2);
+                    },
+                    p: function(t2) {
+                        return ({
+                            M: c,
+                            y: h,
+                            w: o,
+                            d: a,
+                            D: d,
+                            h: u,
+                            m: s,
+                            s: i,
+                            ms: r,
+                            Q: f
+                        })[t2] || String(t2 || "").toLowerCase().replace(/s$/, "");
+                    },
+                    u: function(t2) {
+                        return void 0 === t2;
+                    }
+                }, g = "en", D = {};
+                D[g] = M;
+                var p = "$isDayjsObject", S = function(t2) {
+                    return t2 instanceof _ || !(!t2 || !t2[p]);
+                }, w = function t2(e2, n2, r2) {
+                    var i2;
+                    if (!e2) return g;
+                    if ("string" == typeof e2) {
+                        var s2 = e2.toLowerCase();
+                        D[s2] && (i2 = s2), n2 && (D[s2] = n2, i2 = s2);
+                        var u2 = e2.split("-");
+                        if (!i2 && u2.length > 1) return t2(u2[0]);
+                    } else {
+                        var a2 = e2.name;
+                        D[a2] = e2, i2 = a2;
+                    }
+                    return !r2 && i2 && (g = i2), i2 || !r2 && g;
+                }, O = function(t2, e2) {
+                    if (S(t2)) return t2.clone();
+                    var n2 = "object" == typeof e2 ? e2 : {};
+                    return n2.date = t2, n2.args = arguments, new _(n2);
+                }, b = v;
+                b.l = w, b.i = S, b.w = function(t2, e2) {
+                    return O(t2, {
+                        locale: e2.$L,
+                        utc: e2.$u,
+                        x: e2.$x,
+                        $offset: e2.$offset
+                    });
+                };
+                var _ = function() {
+                    function M2(t2) {
+                        this.$L = w(t2.locale, null, true), this.parse(t2), this.$x = this.$x || t2.x || {}, this[p] = true;
+                    }
+                    var m2 = M2.prototype;
+                    return m2.parse = function(t2) {
+                        this.$d = function(t3) {
+                            var e2 = t3.date, n2 = t3.utc;
+                            if (null === e2) return /* @__PURE__ */ new Date(NaN);
+                            if (b.u(e2)) return /* @__PURE__ */ new Date();
+                            if (e2 instanceof Date) return new Date(e2);
+                            if ("string" == typeof e2 && !/Z$/i.test(e2)) {
+                                var r2 = e2.match($);
+                                if (r2) {
+                                    var i2 = r2[2] - 1 || 0, s2 = (r2[7] || "0").substring(0, 3);
+                                    return n2 ? new Date(Date.UTC(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s2)) : new Date(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s2);
+                                }
+                            }
+                            return new Date(e2);
+                        }(t2), this.init();
+                    }, m2.init = function() {
+                        var t2 = this.$d;
+                        this.$y = t2.getFullYear(), this.$M = t2.getMonth(), this.$D = t2.getDate(), this.$W = t2.getDay(), this.$H = t2.getHours(), this.$m = t2.getMinutes(), this.$s = t2.getSeconds(), this.$ms = t2.getMilliseconds();
+                    }, m2.$utils = function() {
+                        return b;
+                    }, m2.isValid = function() {
+                        return !(this.$d.toString() === l);
+                    }, m2.isSame = function(t2, e2) {
+                        var n2 = O(t2);
+                        return this.startOf(e2) <= n2 && n2 <= this.endOf(e2);
+                    }, m2.isAfter = function(t2, e2) {
+                        return O(t2) < this.startOf(e2);
+                    }, m2.isBefore = function(t2, e2) {
+                        return this.endOf(e2) < O(t2);
+                    }, m2.$g = function(t2, e2, n2) {
+                        return b.u(t2) ? this[e2] : this.set(n2, t2);
+                    }, m2.unix = function() {
+                        return Math.floor(this.valueOf() / 1e3);
+                    }, m2.valueOf = function() {
+                        return this.$d.getTime();
+                    }, m2.startOf = function(t2, e2) {
+                        var n2 = this, r2 = !!b.u(e2) || e2, f2 = b.p(t2), l2 = function(t3, e3) {
+                            var i2 = b.w(n2.$u ? Date.UTC(n2.$y, e3, t3) : new Date(n2.$y, e3, t3), n2);
+                            return r2 ? i2 : i2.endOf(a);
+                        }, $2 = function(t3, e3) {
+                            return b.w(n2.toDate()[t3].apply(n2.toDate("s"), (r2 ? [
+                                0,
+                                0,
+                                0,
+                                0
+                            ] : [
+                                23,
+                                59,
+                                59,
+                                999
+                            ]).slice(e3)), n2);
+                        }, y2 = this.$W, M3 = this.$M, m3 = this.$D, v2 = "set" + (this.$u ? "UTC" : "");
+                        switch(f2){
+                            case h:
+                                return r2 ? l2(1, 0) : l2(31, 11);
+                            case c:
+                                return r2 ? l2(1, M3) : l2(0, M3 + 1);
+                            case o:
+                                var g2 = this.$locale().weekStart || 0, D2 = (y2 < g2 ? y2 + 7 : y2) - g2;
+                                return l2(r2 ? m3 - D2 : m3 + (6 - D2), M3);
+                            case a:
+                            case d:
+                                return $2(v2 + "Hours", 0);
+                            case u:
+                                return $2(v2 + "Minutes", 1);
+                            case s:
+                                return $2(v2 + "Seconds", 2);
+                            case i:
+                                return $2(v2 + "Milliseconds", 3);
+                            default:
+                                return this.clone();
+                        }
+                    }, m2.endOf = function(t2) {
+                        return this.startOf(t2, false);
+                    }, m2.$set = function(t2, e2) {
+                        var n2, o2 = b.p(t2), f2 = "set" + (this.$u ? "UTC" : ""), l2 = (n2 = {}, n2[a] = f2 + "Date", n2[d] = f2 + "Date", n2[c] = f2 + "Month", n2[h] = f2 + "FullYear", n2[u] = f2 + "Hours", n2[s] = f2 + "Minutes", n2[i] = f2 + "Seconds", n2[r] = f2 + "Milliseconds", n2)[o2], $2 = o2 === a ? this.$D + (e2 - this.$W) : e2;
+                        if (o2 === c || o2 === h) {
+                            var y2 = this.clone().set(d, 1);
+                            y2.$d[l2]($2), y2.init(), this.$d = y2.set(d, Math.min(this.$D, y2.daysInMonth())).$d;
+                        } else l2 && this.$d[l2]($2);
+                        return this.init(), this;
+                    }, m2.set = function(t2, e2) {
+                        return this.clone().$set(t2, e2);
+                    }, m2.get = function(t2) {
+                        return this[b.p(t2)]();
+                    }, m2.add = function(r2, f2) {
+                        var d2, l2 = this;
+                        r2 = Number(r2);
+                        var $2 = b.p(f2), y2 = function(t2) {
+                            var e2 = O(l2);
+                            return b.w(e2.date(e2.date() + Math.round(t2 * r2)), l2);
+                        };
+                        if ($2 === c) return this.set(c, this.$M + r2);
+                        if ($2 === h) return this.set(h, this.$y + r2);
+                        if ($2 === a) return y2(1);
+                        if ($2 === o) return y2(7);
+                        var M3 = (d2 = {}, d2[s] = e, d2[u] = n, d2[i] = t, d2)[$2] || 1, m3 = this.$d.getTime() + r2 * M3;
+                        return b.w(m3, this);
+                    }, m2.subtract = function(t2, e2) {
+                        return this.add(-1 * t2, e2);
+                    }, m2.format = function(t2) {
+                        var e2 = this, n2 = this.$locale();
+                        if (!this.isValid()) return n2.invalidDate || l;
+                        var r2 = t2 || "YYYY-MM-DDTHH:mm:ssZ", i2 = b.z(this), s2 = this.$H, u2 = this.$m, a2 = this.$M, o2 = n2.weekdays, c2 = n2.months, f2 = n2.meridiem, h2 = function(t3, n3, i3, s3) {
+                            return t3 && (t3[n3] || t3(e2, r2)) || i3[n3].slice(0, s3);
+                        }, d2 = function(t3) {
+                            return b.s(s2 % 12 || 12, t3, "0");
+                        }, $2 = f2 || function(t3, e3, n3) {
+                            var r3 = t3 < 12 ? "AM" : "PM";
+                            return n3 ? r3.toLowerCase() : r3;
+                        };
+                        return r2.replace(y, function(t3, r3) {
+                            return r3 || function(t4) {
+                                switch(t4){
+                                    case "YY":
+                                        return String(e2.$y).slice(-2);
+                                    case "YYYY":
+                                        return b.s(e2.$y, 4, "0");
+                                    case "M":
+                                        return a2 + 1;
+                                    case "MM":
+                                        return b.s(a2 + 1, 2, "0");
+                                    case "MMM":
+                                        return h2(n2.monthsShort, a2, c2, 3);
+                                    case "MMMM":
+                                        return h2(c2, a2);
+                                    case "D":
+                                        return e2.$D;
+                                    case "DD":
+                                        return b.s(e2.$D, 2, "0");
+                                    case "d":
+                                        return String(e2.$W);
+                                    case "dd":
+                                        return h2(n2.weekdaysMin, e2.$W, o2, 2);
+                                    case "ddd":
+                                        return h2(n2.weekdaysShort, e2.$W, o2, 3);
+                                    case "dddd":
+                                        return o2[e2.$W];
+                                    case "H":
+                                        return String(s2);
+                                    case "HH":
+                                        return b.s(s2, 2, "0");
+                                    case "h":
+                                        return d2(1);
+                                    case "hh":
+                                        return d2(2);
+                                    case "a":
+                                        return $2(s2, u2, true);
+                                    case "A":
+                                        return $2(s2, u2, false);
+                                    case "m":
+                                        return String(u2);
+                                    case "mm":
+                                        return b.s(u2, 2, "0");
+                                    case "s":
+                                        return String(e2.$s);
+                                    case "ss":
+                                        return b.s(e2.$s, 2, "0");
+                                    case "SSS":
+                                        return b.s(e2.$ms, 3, "0");
+                                    case "Z":
+                                        return i2;
+                                }
+                                return null;
+                            }(t3) || i2.replace(":", "");
+                        });
+                    }, m2.utcOffset = function() {
+                        return 15 * -Math.round(this.$d.getTimezoneOffset() / 15);
+                    }, m2.diff = function(r2, d2, l2) {
+                        var $2, y2 = this, M3 = b.p(d2), m3 = O(r2), v2 = (m3.utcOffset() - this.utcOffset()) * e, g2 = this - m3, D2 = function() {
+                            return b.m(y2, m3);
+                        };
+                        switch(M3){
+                            case h:
+                                $2 = D2() / 12;
+                                break;
+                            case c:
+                                $2 = D2();
+                                break;
+                            case f:
+                                $2 = D2() / 3;
+                                break;
+                            case o:
+                                $2 = (g2 - v2) / 6048e5;
+                                break;
+                            case a:
+                                $2 = (g2 - v2) / 864e5;
+                                break;
+                            case u:
+                                $2 = g2 / n;
+                                break;
+                            case s:
+                                $2 = g2 / e;
+                                break;
+                            case i:
+                                $2 = g2 / t;
+                                break;
+                            default:
+                                $2 = g2;
+                        }
+                        return l2 ? $2 : b.a($2);
+                    }, m2.daysInMonth = function() {
+                        return this.endOf(c).$D;
+                    }, m2.$locale = function() {
+                        return D[this.$L];
+                    }, m2.locale = function(t2, e2) {
+                        if (!t2) return this.$L;
+                        var n2 = this.clone(), r2 = w(t2, e2, true);
+                        return r2 && (n2.$L = r2), n2;
+                    }, m2.clone = function() {
+                        return b.w(this.$d, this);
+                    }, m2.toDate = function() {
+                        return new Date(this.valueOf());
+                    }, m2.toJSON = function() {
+                        return this.isValid() ? this.toISOString() : null;
+                    }, m2.toISOString = function() {
+                        return this.$d.toISOString();
+                    }, m2.toString = function() {
+                        return this.$d.toUTCString();
+                    }, M2;
+                }(), k = _.prototype;
+                return O.prototype = k, [
+                    [
+                        "$ms",
+                        r
+                    ],
+                    [
+                        "$s",
+                        i
+                    ],
+                    [
+                        "$m",
+                        s
+                    ],
+                    [
+                        "$H",
+                        u
+                    ],
+                    [
+                        "$W",
+                        a
+                    ],
+                    [
+                        "$M",
+                        c
+                    ],
+                    [
+                        "$y",
+                        h
+                    ],
+                    [
+                        "$D",
+                        d
+                    ]
+                ].forEach(function(t2) {
+                    k[t2[1]] = function(e2) {
+                        return this.$g(e2, t2[0], t2[1]);
+                    };
+                }), O.extend = function(t2, e2) {
+                    return t2.$i || (t2(e2, _, O), t2.$i = true), O;
+                }, O.locale = w, O.isDayjs = S, O.unix = function(t2) {
+                    return O(1e3 * t2);
+                }, O.en = D[g], O.Ls = D, O.p = {}, O;
+            });
+        }
+    });
+    // src/common/utils.ts
+    var import_dayjs = __toESM(require_dayjs_min());
+    // src/web-element.ts
+    var WebElementInfo = class {
+        constructor({ content, rect, page, locator, id, attributes, indexId }){
+            this.content = content;
+            this.rect = rect;
+            this.center = [
+                Math.floor(rect.left + rect.width / 2),
+                Math.floor(rect.top + rect.height / 2)
+            ];
+            this.page = page;
+            this.locator = locator;
+            this.id = id;
+            this.attributes = attributes;
+            this.indexId = indexId;
+        }
+    };
+    // src/common/utils.ts
+    function parseContextFromWebPage(page, _opt) {
+        return __async(this, null, function*() {
+            (0, _assert.default)(page, "page is required");
+            if (page._forceUsePageContext) {
+                return yield page._forceUsePageContext();
+            }
+            const url = yield page.url();
+            let screenshotBase64;
+            let elementsInfo;
+            yield Promise.all([
+                page.screenshotBase64().then((base64)=>{
+                    screenshotBase64 = base64;
+                }),
+                page.getElementInfos().then((snapshot)=>__async(this, null, function*() {
+                        elementsInfo = yield alignElements(snapshot, page);
+                    }))
+            ]);
+            (0, _assert.default)(screenshotBase64, "screenshotBase64 is required");
+            const elementsPositionInfoWithoutText = elementsInfo.filter((elementInfo)=>{
+                if (elementInfo.attributes.nodeType === _constants.NodeType.TEXT) {
+                    return false;
+                }
+                return true;
+            });
+            const size = yield page.size();
+            const width = size.width;
+            const height = size.height;
+            const screenshotBase64WithElementMarker = (_opt == null ? void 0 : _opt.ignoreMarker) ? void 0 : yield (0, _img.compositeElementInfoImg)({
+                inputImgBase64: screenshotBase64,
+                elementsPositionInfo: elementsPositionInfoWithoutText,
+                size: {
+                    width,
+                    height
+                }
+            });
+            return {
+                content: elementsInfo,
+                size: {
+                    width,
+                    height
+                },
+                screenshotBase64,
+                screenshotBase64WithElementMarker,
+                url
+            };
+        });
+    }
+    var sizeThreshold = 3;
+    function alignElements(elements, page) {
+        return __async(this, null, function*() {
+            const validElements = elements.filter((item)=>{
+                return item.rect.height >= sizeThreshold && item.rect.width >= sizeThreshold;
+            });
+            const textsAligned = [];
+            for (const item of validElements){
+                const { rect, id, content, attributes, locator, indexId } = item;
+                textsAligned.push(new WebElementInfo({
+                    rect,
+                    locator,
+                    id,
+                    content,
+                    attributes,
+                    page,
+                    indexId
+                }));
+            }
+            return textsAligned;
+        });
+    }
+    function reportFileName(tag = "web") {
+        const dateTimeInFileName = (0, import_dayjs.default)().format("YYYY-MM-DD_HH-mm-ss-SSS");
+        return `${tag}-${dateTimeInFileName}`;
+    }
+    function printReportMsg(filepath) {
+        console.log("Midscene - report file updated:", filepath);
+    }
+    function getCurrentExecutionFile(trace) {
+        const error = new Error();
+        const stackTrace = trace || error.stack;
+        const pkgDir = process.cwd() || "";
+        if (stackTrace) {
+            const stackLines = stackTrace.split("\n");
+            for (const line of stackLines){
+                if (line.includes(".spec.") || line.includes(".test.") || line.includes(".ts") || line.includes(".js")) {
+                    const match = line.match(/(?:at\s+)?(.*?\.(?:spec|test)\.[jt]s)/);
+                    if (match == null ? void 0 : match[1]) {
+                        const targetFileName = match[1].replace(pkgDir, "").trim().replace("at ", "");
+                        return targetFileName;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    var testFileIndex = /* @__PURE__ */ new Map();
+    function generateCacheId(fileName) {
+        let taskFile = fileName || getCurrentExecutionFile();
+        if (!taskFile) {
+            taskFile = (0, _utils.uuid)();
+            console.warn("Midscene - using random UUID for cache id. Cache may be invalid.");
+        }
+        if (testFileIndex.has(taskFile)) {
+            const currentIndex = testFileIndex.get(taskFile);
+            if (currentIndex !== void 0) {
+                testFileIndex.set(taskFile, currentIndex + 1);
+            }
+        } else {
+            testFileIndex.set(taskFile, 1);
+        }
+        return `${taskFile}-${testFileIndex.get(taskFile)}`;
+    }
+    var ERROR_CODE_NOT_IMPLEMENTED_AS_DESIGNED = "NOT_IMPLEMENTED_AS_DESIGNED";
+    var TaskCache = class {
+        getCacheGroupByPrompt(aiActionPrompt) {
+            const { aiTasks = [] } = this.cache || {
+                aiTasks: []
+            };
+            const index = aiTasks.findIndex((item)=>item.prompt === aiActionPrompt);
+            const newCacheGroup = [];
+            this.newCache.aiTasks.push({
+                prompt: aiActionPrompt,
+                tasks: newCacheGroup
+            });
+            return {
+                readCache: (pageContext, type, actionPrompt)=>{
+                    if (index === -1) {
+                        return false;
+                    }
+                    if (type === "plan") {
+                        return this.readCache(pageContext, type, actionPrompt, aiTasks[index].tasks);
+                    }
+                    return this.readCache(pageContext, type, actionPrompt, aiTasks[index].tasks);
+                },
+                saveCache: (cache)=>{
+                    newCacheGroup.push(cache);
+                    this.writeCacheToFile();
+                }
+            };
+        }
+        readCache(pageContext, type, userPrompt, cacheGroup) {
+            var _a;
+            if (cacheGroup.length > 0) {
+                const index = cacheGroup.findIndex((item)=>item.prompt === userPrompt);
+                if (index === -1) {
+                    return false;
+                }
+                const taskRes = cacheGroup.splice(index, 1)[0];
+                if ((taskRes == null ? void 0 : taskRes.type) === "locate" && !((_a = taskRes.response) == null ? void 0 : _a.elements.every((element)=>{
+                    const findIndex = pageContext.content.findIndex((contentElement)=>contentElement.id === element.id);
+                    if (findIndex === -1) {
+                        return false;
+                    }
+                    return true;
+                }))) {
+                    return false;
+                }
+                if (taskRes && taskRes.type === type && taskRes.prompt === userPrompt && this.pageContextEqual(taskRes.pageContext, pageContext)) {
+                    return taskRes.response;
+                }
+            }
+            return false;
+        }
+        pageContextEqual(taskPageContext, pageContext) {
+            return taskPageContext.size.width === pageContext.size.width && taskPageContext.size.height === pageContext.size.height;
+        }
+        /**
+   * Generate task cache data.
+   * This method is mainly used to create or obtain some cached data for tasks, and it returns a new cache object.
+   * In the cache object, it may contain task-related information, states, or other necessary data.
+   * It is assumed that the `newCache` property already exists in the current class or object and is a data structure used to store task cache.
+   * @returns {Object} Returns a new cache object, which may include task cache data.
+   */ generateTaskCache() {
+            return this.newCache;
+        }
+        readCacheFromFile() {
+            if (_utils.ifInBrowser) {
+                return void 0;
+            }
+            const cacheFile = (0, _path.join)((0, _utils1.getLogDirByType)("cache"), `${this.cacheId}.json`);
+            if (process.env.MIDSCENE_CACHE === "true" && (0, _fs.existsSync)(cacheFile)) {
+                try {
+                    const data = (0, _fs.readFileSync)(cacheFile, "utf8");
+                    const jsonData = JSON.parse(data);
+                    if (!this.midscenePkgInfo) {
+                        return void 0;
+                    }
+                    if (jsonData.pkgName !== this.midscenePkgInfo.name || jsonData.pkgVersion !== this.midscenePkgInfo.version) {
+                        return void 0;
+                    }
+                    return jsonData;
+                } catch (err) {
+                    return void 0;
+                }
+            }
+            return void 0;
+        }
+        writeCacheToFile() {
+            const midscenePkgInfo = (0, _fs1.getRunningPkgInfo)();
+            if (!midscenePkgInfo) {
+                return;
+            }
+            if (!_utils.ifInBrowser) {
+                (0, _utils1.writeLogFile)({
+                    fileName: `${this.cacheId}`,
+                    fileExt: "json",
+                    fileContent: (0, _utils1.stringifyDumpData)(__spreadValues({
+                        pkgName: midscenePkgInfo.name,
+                        pkgVersion: midscenePkgInfo.version,
+                        cacheId: this.cacheId
+                    }, this.newCache), 2),
+                    type: "cache"
+                });
+            }
+        }
+        constructor(opts){
+            this.midscenePkgInfo = (0, _fs1.getRunningPkgInfo)();
+            this.cacheId = generateCacheId(opts == null ? void 0 : opts.fileName);
+            this.cache = this.readCacheFromFile() || {
+                aiTasks: []
+            };
+            this.newCache = {
+                aiTasks: []
+            };
+        }
+    };
+    // src/common/tasks.ts
+    var PageTaskExecutor = class {
+        recordScreenshot(timing) {
+            return __async(this, null, function*() {
+                const base64 = yield this.page.screenshotBase64();
+                const item = {
+                    type: "screenshot",
+                    ts: Date.now(),
+                    screenshot: base64,
+                    timing
+                };
+                return item;
+            });
+        }
+        wrapExecutorWithScreenshot(taskApply) {
+            const taskWithScreenshot = __spreadProps(__spreadValues({}, taskApply), {
+                executor: (param, context, ...args)=>__async(this, null, function*() {
+                        const recorder = [];
+                        const { task } = context;
+                        task.recorder = recorder;
+                        const shot = yield this.recordScreenshot(`before ${task.type}`);
+                        recorder.push(shot);
+                        const result = yield taskApply.executor(param, context, ...args);
+                        if (taskApply.type === "Action") {
+                            yield (0, _utils1.sleep)(1e3);
+                            const shot2 = yield this.recordScreenshot("after Action");
+                            recorder.push(shot2);
+                        }
+                        return result;
+                    })
+            });
+            return taskWithScreenshot;
+        }
+        convertPlanToExecutable(plans, cacheGroup) {
+            return __async(this, null, function*() {
+                const tasks = plans.map((plan2)=>{
+                    if (plan2.type === "Locate") {
+                        const taskFind = {
+                            type: "Insight",
+                            subType: "Locate",
+                            param: plan2.param,
+                            quickAnswer: plan2.quickAnswer,
+                            executor: (param, taskContext)=>__async(this, null, function*() {
+                                    const { task } = taskContext;
+                                    let insightDump;
+                                    const dumpCollector = (dump)=>{
+                                        insightDump = dump;
+                                    };
+                                    this.insight.onceDumpUpdatedFn = dumpCollector;
+                                    const pageContext = yield this.insight.contextRetrieverFn();
+                                    const locateCache = cacheGroup == null ? void 0 : cacheGroup.readCache(pageContext, "locate", param.prompt);
+                                    let locateResult;
+                                    const callAI = this.insight.aiVendorFn;
+                                    const element = yield this.insight.locate(param.prompt, {
+                                        quickAnswer: task.quickAnswer,
+                                        callAI: (...message)=>__async(this, null, function*() {
+                                                if (locateCache) {
+                                                    locateResult = locateCache;
+                                                    return Promise.resolve(locateCache);
+                                                }
+                                                const aiResult = yield callAI(...message);
+                                                locateResult = (0, _core.transformElementPositionToId)(aiResult, pageContext.content);
+                                                (0, _assert.default)(locateResult);
+                                                return locateResult;
+                                            })
+                                    });
+                                    if (locateResult) {
+                                        cacheGroup == null ? void 0 : cacheGroup.saveCache({
+                                            type: "locate",
+                                            pageContext: {
+                                                url: pageContext.url,
+                                                size: pageContext.size
+                                            },
+                                            prompt: param.prompt,
+                                            response: locateResult
+                                        });
+                                    }
+                                    if (!element) {
+                                        task.log = {
+                                            dump: insightDump
+                                        };
+                                        throw new Error(`Element not found: ${param.prompt}`);
+                                    }
+                                    return {
+                                        output: {
+                                            element
+                                        },
+                                        log: {
+                                            dump: insightDump
+                                        },
+                                        cache: {
+                                            hit: Boolean(locateCache)
+                                        }
+                                    };
+                                })
+                        };
+                        return taskFind;
+                    }
+                    if (plan2.type === "Assert" || plan2.type === "AssertWithoutThrow") {
+                        const assertPlan = plan2;
+                        const taskAssert = {
+                            type: "Insight",
+                            subType: "Assert",
+                            param: assertPlan.param,
+                            executor: (param, taskContext)=>__async(this, null, function*() {
+                                    const { task } = taskContext;
+                                    let insightDump;
+                                    const dumpCollector = (dump)=>{
+                                        insightDump = dump;
+                                    };
+                                    this.insight.onceDumpUpdatedFn = dumpCollector;
+                                    const assertion = yield this.insight.assert(assertPlan.param.assertion);
+                                    if (!assertion.pass) {
+                                        if (plan2.type === "Assert") {
+                                            task.output = assertion;
+                                            task.log = {
+                                                dump: insightDump
+                                            };
+                                            throw new Error(assertion.thought || "Assertion failed without reason");
+                                        }
+                                        task.error = assertion.thought;
+                                    }
+                                    return {
+                                        output: assertion,
+                                        log: {
+                                            dump: insightDump
+                                        }
+                                    };
+                                })
+                        };
+                        return taskAssert;
+                    }
+                    if (plan2.type === "Input") {
+                        const taskActionInput = {
+                            type: "Action",
+                            subType: "Input",
+                            param: plan2.param,
+                            executor: (_0, _1)=>__async(this, [
+                                    _0,
+                                    _1
+                                ], function*(taskParam, { element }) {
+                                    if (element) {
+                                        yield this.page.clearInput(element);
+                                        if (taskParam.value === "") {
+                                            return;
+                                        }
+                                        yield this.page.keyboard.type(taskParam.value);
+                                    }
+                                })
+                        };
+                        return taskActionInput;
+                    }
+                    if (plan2.type === "KeyboardPress") {
+                        const taskActionKeyboardPress = {
+                            type: "Action",
+                            subType: "KeyboardPress",
+                            param: plan2.param,
+                            executor: (taskParam)=>__async(this, null, function*() {
+                                    (0, _assert.default)(taskParam.value, "No key to press");
+                                    yield this.page.keyboard.press(taskParam.value);
+                                })
+                        };
+                        return taskActionKeyboardPress;
+                    }
+                    if (plan2.type === "Tap") {
+                        const taskActionTap = {
+                            type: "Action",
+                            subType: "Tap",
+                            executor: (_0, _1)=>__async(this, [
+                                    _0,
+                                    _1
+                                ], function*(param, { element }) {
+                                    (0, _assert.default)(element, "Element not found, cannot tap");
+                                    yield this.page.mouse.click(element.center[0], element.center[1]);
+                                })
+                        };
+                        return taskActionTap;
+                    }
+                    if (plan2.type === "Hover") {
+                        const taskActionHover = {
+                            type: "Action",
+                            subType: "Hover",
+                            executor: (_0, _1)=>__async(this, [
+                                    _0,
+                                    _1
+                                ], function*(param, { element }) {
+                                    (0, _assert.default)(element, "Element not found, cannot hover");
+                                    yield this.page.mouse.move(element.center[0], element.center[1]);
+                                })
+                        };
+                        return taskActionHover;
+                    }
+                    if (plan2.type === "Scroll") {
+                        const taskActionScroll = {
+                            type: "Action",
+                            subType: "Scroll",
+                            param: plan2.param,
+                            executor: (taskParam)=>__async(this, null, function*() {
+                                    const scrollToEventName = taskParam.scrollType;
+                                    switch(scrollToEventName){
+                                        case "scrollUntilTop":
+                                            yield this.page.scrollUntilTop();
+                                            break;
+                                        case "scrollUntilBottom":
+                                            yield this.page.scrollUntilBottom();
+                                            break;
+                                        case "scrollUpOneScreen":
+                                            yield this.page.scrollUpOneScreen();
+                                            break;
+                                        case "scrollDownOneScreen":
+                                            yield this.page.scrollDownOneScreen();
+                                            break;
+                                        default:
+                                            console.error("Unknown scroll event type:", scrollToEventName);
+                                    }
+                                })
+                        };
+                        return taskActionScroll;
+                    }
+                    if (plan2.type === "Sleep") {
+                        const taskActionSleep = {
+                            type: "Action",
+                            subType: "Sleep",
+                            param: plan2.param,
+                            executor: (taskParam)=>__async(this, null, function*() {
+                                    yield (0, _utils1.sleep)(taskParam.timeMs || 3e3);
+                                })
+                        };
+                        return taskActionSleep;
+                    }
+                    if (plan2.type === "Error") {
+                        const taskActionError = {
+                            type: "Action",
+                            subType: "Error",
+                            param: plan2.param,
+                            executor: (taskParam)=>__async(this, null, function*() {
+                                    (0, _assert.default)(taskParam.thought, "An error occurred, but no thought provided");
+                                    throw new Error(taskParam.thought);
+                                })
+                        };
+                        return taskActionError;
+                    }
+                    throw new Error(`Unknown or Unsupported task type: ${plan2.type}`);
+                }).map((task)=>{
+                    return this.wrapExecutorWithScreenshot(task);
+                });
+                return tasks;
+            });
+        }
+        action(userPrompt) {
+            return __async(this, null, function*() {
+                const taskExecutor = new _core.Executor(userPrompt);
+                const cacheGroup = this.taskCache.getCacheGroupByPrompt(userPrompt);
+                let plans = [];
+                const planningTask = {
+                    type: "Planning",
+                    param: {
+                        userPrompt
+                    },
+                    executor: (param)=>__async(this, null, function*() {
+                            const pageContext = yield this.insight.contextRetrieverFn();
+                            let planResult;
+                            const planCache = cacheGroup.readCache(pageContext, "plan", userPrompt);
+                            if (planCache) {
+                                planResult = planCache;
+                            } else {
+                                planResult = yield (0, _core.plan)(param.userPrompt, {
+                                    context: pageContext
+                                });
+                            }
+                            (0, _assert.default)(planResult.plans.length > 0, "No plans found");
+                            plans = planResult.plans;
+                            cacheGroup.saveCache({
+                                type: "plan",
+                                pageContext: {
+                                    url: pageContext.url,
+                                    size: pageContext.size
+                                },
+                                prompt: userPrompt,
+                                response: planResult
+                            });
+                            return {
+                                output: planResult,
+                                pageContext,
+                                cache: {
+                                    hit: Boolean(planCache)
+                                }
+                            };
+                        })
+                };
+                yield taskExecutor.append(this.wrapExecutorWithScreenshot(planningTask));
+                let output = yield taskExecutor.flush();
+                if (taskExecutor.isInErrorState()) {
+                    return {
+                        output,
+                        executor: taskExecutor
+                    };
+                }
+                const executables = yield this.convertPlanToExecutable(plans, cacheGroup);
+                yield taskExecutor.append(executables);
+                output = yield taskExecutor.flush();
+                return {
+                    output,
+                    executor: taskExecutor
+                };
+            });
+        }
+        query(demand) {
+            return __async(this, null, function*() {
+                const description = typeof demand === "string" ? demand : JSON.stringify(demand);
+                const taskExecutor = new _core.Executor(description);
+                const queryTask = {
+                    type: "Insight",
+                    subType: "Query",
+                    param: {
+                        dataDemand: demand
+                    },
+                    executor: (param)=>__async(this, null, function*() {
+                            let insightDump;
+                            const dumpCollector = (dump)=>{
+                                insightDump = dump;
+                            };
+                            this.insight.onceDumpUpdatedFn = dumpCollector;
+                            const data = yield this.insight.extract(param.dataDemand);
+                            return {
+                                output: data,
+                                log: {
+                                    dump: insightDump
+                                }
+                            };
+                        })
+                };
+                yield taskExecutor.append(this.wrapExecutorWithScreenshot(queryTask));
+                const output = yield taskExecutor.flush();
+                return {
+                    output,
+                    executor: taskExecutor
+                };
+            });
+        }
+        assert(assertion) {
+            return __async(this, null, function*() {
+                const description = `assert: ${assertion}`;
+                const taskExecutor = new _core.Executor(description);
+                const assertionPlan = {
+                    type: "Assert",
+                    param: {
+                        assertion
+                    }
+                };
+                const assertTask = yield this.convertPlanToExecutable([
+                    assertionPlan
+                ]);
+                yield taskExecutor.append(this.wrapExecutorWithScreenshot(assertTask[0]));
+                const output = yield taskExecutor.flush();
+                return {
+                    output,
+                    executor: taskExecutor
+                };
+            });
+        }
+        waitFor(assertion, opt) {
+            return __async(this, null, function*() {
+                const description = `waitFor: ${assertion}`;
+                const taskExecutor = new _core.Executor(description);
+                const { timeoutMs, checkIntervalMs } = opt;
+                (0, _assert.default)(assertion, "No assertion for waitFor");
+                (0, _assert.default)(timeoutMs, "No timeoutMs for waitFor");
+                (0, _assert.default)(checkIntervalMs, "No checkIntervalMs for waitFor");
+                const overallStartTime = Date.now();
+                let startTime = Date.now();
+                let errorThought = "";
+                while(Date.now() - overallStartTime < timeoutMs){
+                    startTime = Date.now();
+                    const assertPlan = {
+                        type: "AssertWithoutThrow",
+                        param: {
+                            assertion
+                        }
+                    };
+                    const assertTask = yield this.convertPlanToExecutable([
+                        assertPlan
+                    ]);
+                    yield taskExecutor.append(this.wrapExecutorWithScreenshot(assertTask[0]));
+                    const output = yield taskExecutor.flush();
+                    if (output == null ? void 0 : output.pass) {
+                        return {
+                            output: void 0,
+                            executor: taskExecutor
+                        };
+                    }
+                    errorThought = (output == null ? void 0 : output.thought) || "unknown error";
+                    const now = Date.now();
+                    if (now - startTime < checkIntervalMs) {
+                        const timeRemaining = checkIntervalMs - (now - startTime);
+                        const sleepPlan = {
+                            type: "Sleep",
+                            param: {
+                                timeMs: timeRemaining
+                            }
+                        };
+                        const sleepTask = yield this.convertPlanToExecutable([
+                            sleepPlan
+                        ]);
+                        yield taskExecutor.append(this.wrapExecutorWithScreenshot(sleepTask[0]));
+                        yield taskExecutor.flush();
+                    }
+                }
+                const errorPlan = {
+                    type: "Error",
+                    param: {
+                        thought: `waitFor timeout: ${errorThought}`
+                    }
+                };
+                const errorTask = yield this.convertPlanToExecutable([
+                    errorPlan
+                ]);
+                yield taskExecutor.append(errorTask[0]);
+                yield taskExecutor.flush();
+                return {
+                    output: void 0,
+                    executor: taskExecutor
+                };
+            });
+        }
+        constructor(page, insight, opts){
+            this.page = page;
+            this.insight = insight;
+            this.taskCache = new TaskCache({
+                fileName: opts == null ? void 0 : opts.cacheId
+            });
+        }
+    };
+    // src/common/agent.ts
+    var PageAgent = class {
+        getUIContext() {
+            return __async(this, null, function*() {
+                return yield parseContextFromWebPage(this.page);
+            });
+        }
+        resetDump() {
+            this.dump = {
+                groupName: this.opts.groupName,
+                groupDescription: this.opts.groupDescription,
+                executions: []
+            };
+            return this.dump;
+        }
+        appendExecutionDump(execution) {
+            const currentDump = this.dump;
+            currentDump.executions.push(execution);
+        }
+        dumpDataString() {
+            this.dump.groupName = this.opts.groupName;
+            this.dump.groupDescription = this.opts.groupDescription;
+            return (0, _utils1.stringifyDumpData)(this.dump);
+        }
+        reportHTMLString() {
+            return (0, _utils1.reportHTMLContent)(this.dumpDataString());
+        }
+        writeOutActionDumps() {
+            const { generateReport, autoPrintReportMsg } = this.opts;
+            this.reportFile = (0, _utils1.writeLogFile)({
+                fileName: this.reportFileName,
+                fileExt: _utils1.groupedActionDumpFileExt,
+                fileContent: this.dumpDataString(),
+                type: "dump",
+                generateReport
+            });
+            if (generateReport && autoPrintReportMsg && this.reportFile) {
+                printReportMsg(this.reportFile);
+            }
+        }
+        aiAction(taskPrompt) {
+            return __async(this, null, function*() {
+                const { executor } = yield this.taskExecutor.action(taskPrompt);
+                this.appendExecutionDump(executor.dump());
+                this.writeOutActionDumps();
+                if (executor.isInErrorState()) {
+                    const errorTask = executor.latestErrorTask();
+                    throw new Error(`${errorTask == null ? void 0 : errorTask.error}
+${errorTask == null ? void 0 : errorTask.errorStack}`);
+                }
+            });
+        }
+        aiQuery(demand) {
+            return __async(this, null, function*() {
+                const { output, executor } = yield this.taskExecutor.query(demand);
+                this.appendExecutionDump(executor.dump());
+                this.writeOutActionDumps();
+                if (executor.isInErrorState()) {
+                    const errorTask = executor.latestErrorTask();
+                    throw new Error(`${errorTask == null ? void 0 : errorTask.error}
+${errorTask == null ? void 0 : errorTask.errorStack}`);
+                }
+                return output;
+            });
+        }
+        aiAssert(assertion, msg, opt) {
+            return __async(this, null, function*() {
+                var _a;
+                const { output, executor } = yield this.taskExecutor.assert(assertion);
+                this.appendExecutionDump(executor.dump());
+                this.writeOutActionDumps();
+                if (output && (opt == null ? void 0 : opt.keepRawResponse)) {
+                    return output;
+                }
+                if (!(output == null ? void 0 : output.pass)) {
+                    const errMsg = msg || `Assertion failed: ${assertion}`;
+                    const reasonMsg = `Reason: ${(output == null ? void 0 : output.thought) || ((_a = executor.latestErrorTask()) == null ? void 0 : _a.error) || "(no_reason)"}`;
+                    throw new Error(`${errMsg}
+${reasonMsg}`);
+                }
+            });
+        }
+        aiWaitFor(assertion, opt) {
+            return __async(this, null, function*() {
+                const { executor } = yield this.taskExecutor.waitFor(assertion, {
+                    timeoutMs: (opt == null ? void 0 : opt.timeoutMs) || 15 * 1e3,
+                    checkIntervalMs: (opt == null ? void 0 : opt.checkIntervalMs) || 3 * 1e3,
+                    assertion
+                });
+                this.appendExecutionDump(executor.dump());
+                this.writeOutActionDumps();
+                if (executor.isInErrorState()) {
+                    const errorTask = executor.latestErrorTask();
+                    throw new Error(`${errorTask == null ? void 0 : errorTask.error}
+${errorTask == null ? void 0 : errorTask.errorStack}`);
+                }
+            });
+        }
+        ai(taskPrompt, type = "action") {
+            return __async(this, null, function*() {
+                if (type === "action") {
+                    return this.aiAction(taskPrompt);
+                }
+                if (type === "query") {
+                    return this.aiQuery(taskPrompt);
+                }
+                if (type === "assert") {
+                    return this.aiAssert(taskPrompt);
+                }
+                throw new Error(`Unknown type: ${type}, only support 'action', 'query', 'assert'`);
+            });
+        }
+        destroy() {
+            return __async(this, null, function*() {
+                yield this.page.destroy();
+            });
+        }
+        constructor(page, opts){
+            /**
+     * If true, the agent will not perform any actions
+     */ this.dryMode = false;
+            this.page = page;
+            this.opts = Object.assign({
+                generateReport: true,
+                autoPrintReportMsg: true,
+                groupName: "Midscene Report",
+                groupDescription: ""
+            }, opts || {});
+            this.insight = new _core.Insight(()=>__async(this, null, function*() {
+                    return this.getUIContext();
+                }), {
+                generateElement: ({ content, rect })=>new WebElementInfo({
+                        content: content || "",
+                        rect,
+                        page,
+                        id: "",
+                        attributes: {
+                            nodeType: _constants.NodeType.CONTAINER
+                        },
+                        indexId: 0
+                    })
+            });
+            this.taskExecutor = new PageTaskExecutor(this.page, this.insight, {
+                cacheId: opts == null ? void 0 : opts.cacheId
+            });
+            this.dump = this.resetDump();
+            this.reportFileName = reportFileName((opts == null ? void 0 : opts.testId) || "web");
+        }
+    };
+    // src/chrome-extension/agent.ts
+    var ChromeExtensionProxyPageAgent = class extends PageAgent {
+        constructor(page){
+            super(page, {});
+        }
+    };
+    var scriptFileToRetrieve = "./lib/htmlElement.js";
+    function getActivePageContent(tabId) {
+        return __async(this, null, function*() {
+            const injectResult = yield chrome.scripting.executeScript({
+                target: {
+                    tabId,
+                    allFrames: true
+                },
+                files: [
+                    scriptFileToRetrieve
+                ]
+            });
+            console.log("injectResult", injectResult);
+            const returnValue = yield chrome.scripting.executeScript({
+                target: {
+                    tabId,
+                    allFrames: true
+                },
+                func: ()=>{
+                    return {
+                        context: window.midscene_element_inspector.webExtractTextWithPosition(),
+                        size: {
+                            width: document.documentElement.clientWidth,
+                            height: document.documentElement.clientHeight,
+                            dpr: window.devicePixelRatio
+                        }
+                    };
+                }
+            });
+            if (!returnValue[0].result) {
+                throw new Error(`Failed to get active page content of tabId: ${tabId}`);
+            }
+            return returnValue[0].result;
+        });
+    }
+    var lastTwoCallTime = [
+        0,
+        0
+    ];
+    var callInterval = 1050;
+    function getScreenshotBase64(windowId) {
+        return __async(this, null, function*() {
+            const activeWindow = yield chrome.windows.getAll({
+                populate: true
+            });
+            if (activeWindow.find((w)=>w.id === windowId) === void 0) {
+                throw new Error(`Window with id ${windowId} is not active`);
+            }
+            const now = Date.now();
+            if (now - lastTwoCallTime[0] < callInterval) {
+                const sleepTime = callInterval - (now - lastTwoCallTime[0]);
+                console.warn(`Sleep for ${sleepTime}ms to avoid too frequent screenshot calls`);
+                yield new Promise((resolve)=>setTimeout(resolve, sleepTime));
+            }
+            const base64 = yield chrome.tabs.captureVisibleTab(windowId, {
+                format: "jpeg",
+                quality: 70
+            });
+            lastTwoCallTime.shift();
+            lastTwoCallTime.push(Date.now());
+            return base64;
+        });
+    }
+    function getScreenInfoOfTab(tabId) {
+        return __async(this, null, function*() {
+            const returnValue = yield chrome.scripting.executeScript({
+                target: {
+                    tabId,
+                    allFrames: false
+                },
+                func: ()=>{
+                    return {
+                        dpr: window.devicePixelRatio,
+                        width: document.documentElement.clientWidth,
+                        height: document.documentElement.clientHeight
+                    };
+                }
+            });
+            return returnValue[0].result;
+        });
+    }
+    var ChromeExtensionProxyPage = class {
+        attachDebugger() {
+            return __async(this, null, function*() {
+                if (this.debuggerAttached) return;
+                yield chrome.debugger.attach({
+                    tabId: this.tabId
+                }, "1.3");
+                this.debuggerAttached = true;
+                chrome.debugger.onEvent.addListener((source, method, params)=>{
+                    console.log("debugger event", source, method, params);
+                    if (method === "Debugger.detached") {
+                        this.debuggerAttached = false;
+                    }
+                });
+            });
+        }
+        detachDebugger() {
+            return __async(this, null, function*() {
+                if (!this.debuggerAttached) return;
+                yield chrome.debugger.detach({
+                    tabId: this.tabId
+                });
+                this.debuggerAttached = false;
+            });
+        }
+        sendCommandToDebugger(command, params) {
+            return __async(this, null, function*() {
+                yield this.attachDebugger();
+                yield chrome.debugger.sendCommand({
+                    tabId: this.tabId
+                }, command, params);
+            });
+        }
+        getElementInfos() {
+            return __async(this, null, function*() {
+                const content = yield getActivePageContent(this.tabId);
+                if (content == null ? void 0 : content.size) {
+                    this.viewportSize = content.size;
+                }
+                return (content == null ? void 0 : content.context) || [];
+            });
+        }
+        size() {
+            return __async(this, null, function*() {
+                if (this.viewportSize) return this.viewportSize;
+                const content = yield getActivePageContent(this.tabId);
+                return content.size;
+            });
+        }
+        screenshotBase64() {
+            return __async(this, null, function*() {
+                const base64 = yield getScreenshotBase64(this.windowId);
+                const screenInfo = yield getScreenInfoOfTab(this.tabId);
+                if (screenInfo.dpr > 1) {
+                    return yield (0, _img1.resizeImgBase64)(base64, {
+                        width: screenInfo.width,
+                        height: screenInfo.height
+                    });
+                }
+                return base64;
+            });
+        }
+        url() {
+            return __async(this, null, function*() {
+                const url = yield chrome.tabs.get(this.tabId).then((tab)=>tab.url);
+                return url || "";
+            });
+        }
+        scrollUntilTop() {
+            return __async(this, null, function*() {
+                return this.mouse.wheel(0, -9999999);
+            });
+        }
+        scrollUntilBottom() {
+            return __async(this, null, function*() {
+                return this.mouse.wheel(0, 9999999);
+            });
+        }
+        scrollUpOneScreen() {
+            return __async(this, null, function*() {
+                yield chrome.scripting.executeScript({
+                    target: {
+                        tabId: this.tabId,
+                        allFrames: true
+                    },
+                    func: ()=>{
+                        window.scrollBy(0, -window.innerHeight * 0.7);
+                    }
+                });
+            });
+        }
+        scrollDownOneScreen() {
+            return __async(this, null, function*() {
+                yield chrome.scripting.executeScript({
+                    target: {
+                        tabId: this.tabId,
+                        allFrames: true
+                    },
+                    func: ()=>{
+                        window.scrollBy(0, window.innerHeight * 0.7);
+                    }
+                });
+            });
+        }
+        clearInput(element) {
+            return __async(this, null, function*() {
+                if (!element) {
+                    console.warn("No element to clear input");
+                    return;
+                }
+                yield this.mouse.click(element.center[0], element.center[1]);
+                yield this.sendCommandToDebugger("Input.dispatchKeyEvent", {
+                    type: "keyDown",
+                    commands: [
+                        "selectAll"
+                    ]
+                });
+                yield this.sendCommandToDebugger("Input.dispatchKeyEvent", {
+                    type: "keyDown",
+                    key: "Backspace",
+                    code: "Backspace"
+                });
+                yield this.sendCommandToDebugger("Input.dispatchKeyEvent", {
+                    type: "keyUp",
+                    key: "Backspace",
+                    code: "Backspace"
+                });
+            });
+        }
+        destroy() {
+            return __async(this, null, function*() {
+                yield this.detachDebugger();
+            });
+        }
+        constructor(tabId, windowId){
+            this.pageType = "chrome-extension-proxy";
+            this.debuggerAttached = false;
+            this.mouse = {
+                click: (x, y)=>__async(this, null, function*() {
+                        yield this.sendCommandToDebugger("Input.dispatchMouseEvent", {
+                            type: "mousePressed",
+                            x,
+                            y,
+                            button: "left",
+                            clickCount: 1
+                        });
+                        yield this.sendCommandToDebugger("Input.dispatchMouseEvent", {
+                            type: "mouseReleased",
+                            x,
+                            y,
+                            button: "left",
+                            clickCount: 1
+                        });
+                    }),
+                wheel: (deltaX, deltaY)=>__async(this, null, function*() {
+                        yield this.sendCommandToDebugger("Input.dispatchMouseEvent", {
+                            type: "mouseWheel",
+                            x: 10,
+                            y: 10,
+                            deltaX,
+                            deltaY
+                        });
+                    }),
+                move: (x, y)=>__async(this, null, function*() {
+                        yield this.sendCommandToDebugger("Input.dispatchMouseEvent", {
+                            type: "mouseMoved",
+                            x,
+                            y
+                        });
+                    })
+            };
+            this.keyboard = {
+                type: (text)=>__async(this, null, function*() {
+                        for (const char of text){
+                            yield this.sendCommandToDebugger("Input.dispatchKeyEvent", {
+                                type: "char",
+                                text: char,
+                                key: char,
+                                unmodifiedText: char
+                            });
+                            yield new Promise((resolve)=>setTimeout(resolve, 50));
+                        }
+                    }),
+                press: (key)=>__async(this, null, function*() {
+                        yield this.sendCommandToDebugger("Input.dispatchKeyEvent", {
+                            type: "rawKeyDown",
+                            code: key,
+                            key
+                        });
+                        yield this.sendCommandToDebugger("Input.dispatchKeyEvent", {
+                            type: "char",
+                            code: key,
+                            key
+                        });
+                        yield this.sendCommandToDebugger("Input.dispatchKeyEvent", {
+                            type: "keyUp",
+                            code: key,
+                            key
+                        });
+                    })
+            };
+            this.tabId = tabId;
+            this.windowId = windowId;
+        }
+    };
+});