@letsscrapedata/controller 0.0.51 → 0.0.53

package/dist/index.js

@@ -31,6 +31,32 @@ import { getCurrentUnixTime as getCurrentUnixTime2, sleep } from "@letsscrapedat
 import EventEmitter from "events";
 import { getCurrentUnixTime, unreachable as unreachable2 } from "@letsscrapedata/utils";
 
+// src/utils/common.ts
+function convertDataAttributeName(attr) {
+  if (!attr.startsWith("data-")) {
+    return "";
+  }
+  const parts = attr.split("-");
+  let name = parts[1];
+  for (const part of parts.slice(2)) {
+    if (!part) {
+      continue;
+    }
+    name = `${name}${part[1].toUpperCase()}${part.slice(1).toLowerCase()}`;
+  }
+  return name;
+}
+function getIframeSelector(iframeOption) {
+  const { src = "", id = "", selector = "" } = iframeOption;
+  if (typeof src === "string" && src) {
+    return `iframe[src^="${src}"]`;
+  } else if (typeof id === "string" && id) {
+    return `iframe[id="${id}"]`;
+  } else {
+    return selector;
+  }
+}
+
 // src/playwright/element.ts
 import { unreachable } from "@letsscrapedata/utils";
 var PlaywrightElement = class _PlaywrightElement {
@@ -51,6 +77,29 @@ var PlaywrightElement = class _PlaywrightElement {
     const names = await this.#locator.evaluate((node) => node.getAttributeNames());
     return names;
   }
+  async dataset() {
+    try {
+      const dataset = await this.#locator.evaluate((node) => node.dataset);
+      return dataset;
+    } catch (err) {
+      return {};
+    }
+  }
+  async evaluate(func, args) {
+    try {
+      const frame = this.#frame;
+      ;
+      if (typeof frame.parentFrame === "function") {
+        return await frame.evaluate(func, args);
+      } else {
+        const locator = this.#frame.owner();
+        return await locator.evaluate(func, args);
+      }
+    } catch (err) {
+      logerr(err);
+      return "";
+    }
+  }
   /*
     async #getChildFrame(parentFrame: Frame, iframeOption: IframeOption): Promise<Frame | null> {
       if (!parentFrame) {
@@ -84,22 +133,15 @@ var PlaywrightElement = class _PlaywrightElement {
       return null;
     }
       */
-  #getIframeSelector(iframeOption) {
-    const { src = "", selector = "" } = iframeOption;
-    if (!src && !selector) {
-      throw new Error("Invalid parent frame");
-    }
-    return selector ? selector : `iframe[src^="${src}"]`;
-  }
   async #getChildFrameLocator(parent, iframeOption) {
-    return parent.frameLocator(this.#getIframeSelector(iframeOption));
+    return parent.frameLocator(getIframeSelector(iframeOption));
   }
   async #getDescendantFrame(parent, iframeOptions) {
     try {
       if (iframeOptions.length <= 0) {
         return null;
       }
-      let frameLocator = parent.frameLocator(this.#getIframeSelector(iframeOptions[0]));
+      let frameLocator = parent.frameLocator(getIframeSelector(iframeOptions[0]));
       for (const iframeOption of iframeOptions.slice(1)) {
         if (!frameLocator) {
           return null;
@@ -116,12 +158,12 @@ var PlaywrightElement = class _PlaywrightElement {
     let frame = this.#frame;
     const retObj = { frame, locators: [] };
     if (iframeOptions.length > 0) {
-      frame = await this.#getDescendantFrame(frame, iframeOptions);
-      if (!frame) {
+      const childFrame = await this.#getDescendantFrame(frame, iframeOptions);
+      if (!childFrame) {
         return retObj;
       }
-      retObj.frame = frame;
-      parent = frame;
+      retObj.frame = childFrame;
+      parent = childFrame;
     }
     try {
       let locators = [];
@@ -306,6 +348,7 @@ var PlaywrightPage = class extends EventEmitter {
   #page;
   #status;
   #pageId;
+  #closeWhenFree;
   #resquestInterceptionOptions;
   #responseInterceptionOptions;
   #client;
@@ -436,29 +479,57 @@ var PlaywrightPage = class extends EventEmitter {
       return null;
     }
     */
-  #getIframeSelector(iframeOption) {
-    const { src = "", selector = "" } = iframeOption;
-    if (!src && !selector) {
-      throw new Error("Invalid parent frame");
+  async #findDescendantFrame(src, id) {
+    if (!this.#page) {
+      throw new Error("No valid page");
     }
-    return selector ? selector : `iframe[src^="${src}"]`;
+    const frames = this.#page.frames();
+    for (const frame of frames) {
+      const url = frame.url();
+      if (typeof src === "string" && src) {
+        if (url.startsWith(src)) {
+          return frame;
+        } else if (url.toLowerCase().startsWith(src)) {
+          return frame;
+        }
+      } else if (src instanceof RegExp) {
+        if (url.match(src)) {
+          return frame;
+        }
+      } else if (id) {
+        const element = await frame.frameElement();
+        if (element) {
+          const frameId = await frame.evaluate(([ele, attr]) => ele.getAttribute(attr), [element, "id"]);
+          if (frameId === id) {
+            return frame;
+          }
+        }
+      }
+    }
+    return null;
   }
   async #getChildFrameLocator(parent, iframeOption) {
-    return parent.frameLocator(this.#getIframeSelector(iframeOption));
+    return parent.frameLocator(getIframeSelector(iframeOption));
   }
-  async #getDescendantFrameLocator(mainFrame, iframeOptions) {
+  async #getDescendantFrame(mainFrame, iframeOptions) {
     try {
       if (iframeOptions.length <= 0) {
         return null;
       }
-      let frameLocator = mainFrame.frameLocator(this.#getIframeSelector(iframeOptions[0]));
-      for (const iframeOption of iframeOptions.slice(1)) {
-        if (!frameLocator) {
-          return null;
+      if (iframeOptions.length === 1 && !iframeOptions[0].selector) {
+        const { src = "", id = "" } = iframeOptions[0];
+        const frame = await this.#findDescendantFrame(src, id);
+        return frame;
+      } else {
+        let frameLocator = mainFrame.frameLocator(getIframeSelector(iframeOptions[0]));
+        for (const iframeOption of iframeOptions.slice(1)) {
+          if (!frameLocator) {
+            return null;
+          }
+          frameLocator = await this.#getChildFrameLocator(frameLocator, iframeOption);
         }
-        frameLocator = await this.#getChildFrameLocator(frameLocator, iframeOption);
+        return frameLocator;
       }
-      return frameLocator;
     } catch (err) {
       throw new Error(`No child iframe: ${JSON.stringify(iframeOptions)}`);
     }
@@ -470,7 +541,7 @@ var PlaywrightPage = class extends EventEmitter {
     let frame = this.#page.mainFrame();
     const retObj = { frame, locators: [] };
     if (iframeOptions.length > 0) {
-      frame = await this.#getDescendantFrameLocator(frame, iframeOptions);
+      frame = await this.#getDescendantFrame(frame, iframeOptions);
       if (!frame) {
         return retObj;
       }
@@ -543,12 +614,32 @@ var PlaywrightPage = class extends EventEmitter {
     const { browserIdx = 0, browserContextIdx = 0, pageIdx = 0, openType = "other", openTime = currentTime, lastStatusUpdateTime = currentTime, taskId = 0, relatedId = 0, misc = {} } = pageInfo ? pageInfo : {};
     this.#page.pageInfo = { browserIdx, browserContextIdx, pageIdx, openType, openTime, lastStatusUpdateTime, taskId, relatedId, misc };
     this.#pageId = `page-${browserIdx}-${browserContextIdx}-${pageIdx}`;
+    this.#closeWhenFree = false;
     this.#resquestInterceptionOptions = [];
     this.#responseInterceptionOptions = [];
     this.#client = null;
     this.#responseCb = null;
     this.#addPageOn();
   }
+  async addPreloadScript(scriptOrFunc, arg) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    if (typeof scriptOrFunc === "string") {
+      await this.#page.addInitScript({ content: scriptOrFunc });
+    } else if (typeof scriptOrFunc === "function") {
+      await this.#page.addInitScript(scriptOrFunc, arg);
+    } else {
+      throw new Error(`Invalid type of scriptOrFunc ${typeof scriptOrFunc}`);
+    }
+    return true;
+  }
+  async addScriptTag(options) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    return this.#page.addScriptTag(options);
+  }
   apiContext() {
     return this.browserContext().apiContext();
   }
@@ -608,7 +699,7 @@ var PlaywrightPage = class extends EventEmitter {
   }
   async close() {
     if (this.#status === "closed") {
-      console.warn(`Page ${this.#pageId} is already closed.`);
+      logwarn(`Page ${this.#pageId} is already closed.`);
       return true;
     } else if (this.#status === "busy") {
       throw new Error(`Page ${this.#pageId} cannot be closed because it is busy.`);
@@ -621,13 +712,16 @@ var PlaywrightPage = class extends EventEmitter {
     this.#status = "closed";
     return true;
   }
+  closeWhenFree() {
+    return this.#closeWhenFree;
+  }
   async content(iframeOptions = []) {
     if (!this.#page) {
       throw new Error("No valid page");
     }
     let content = "";
     if (iframeOptions.length > 0) {
-      const frameLocator = await this.#getDescendantFrameLocator(this.#page.mainFrame(), iframeOptions);
+      const frameLocator = await this.#getDescendantFrame(this.#page.mainFrame(), iframeOptions);
       if (frameLocator) {
         content = await frameLocator.locator(":root").evaluate(() => document.documentElement.outerHTML);
       }
@@ -649,11 +743,18 @@ var PlaywrightPage = class extends EventEmitter {
     const height = await this.#page.evaluate(() => document.documentElement.scrollHeight);
     return height;
   }
-  async evalute(fun, args) {
+  async evaluate(func, args) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    return this.#page.evaluate(func, args);
+  }
+  async exposeFunction(name, callbackFunction) {
     if (!this.#page) {
       throw new Error("No valid page");
     }
-    return this.#page.evaluate(fun, args);
+    await this.#page.exposeFunction(name, callbackFunction);
+    return;
   }
   async findElement(selectorOrXpath, iframeOptions = []) {
     if (!this.#page) {
@@ -691,7 +792,7 @@ var PlaywrightPage = class extends EventEmitter {
   }
   async free() {
     if (this.#status === "free") {
-      console.warn(`Page ${this.#pageId} is already free.`);
+      logwarn(`Page ${this.#pageId} is already free.`);
     }
     this.#status = "free";
     await this.clearRequestInterceptions();
@@ -831,6 +932,10 @@ var PlaywrightPage = class extends EventEmitter {
     }
     return response;
   }
+  setCloseWhenFree(closeWhenFree) {
+    this.#closeWhenFree = closeWhenFree;
+    return true;
+  }
   async setCookies(cookies) {
     if (!this.#page) {
       throw new Error("No valid page");
@@ -1014,7 +1119,7 @@ var PlaywrightPage = class extends EventEmitter {
     }
     const actOptions = Array.isArray(options) ? options : [options];
     if (actOptions.length <= 0) {
-      console.warn("Invalid paras in setResponseInterception");
+      logwarn("Invalid paras in setResponseInterception");
       return false;
     }
     const firstResponseInterception = this.#responseInterceptionOptions.length <= 0;
@@ -1498,7 +1603,11 @@ var PlaywrightBrowserContext = class extends EventEmitter2 {
 };
 
 // src/playwright/browser.ts
-var PlaywrightBrowser = class extends EventEmitter3 {
+var PlaywrightBrowser = class _PlaywrightBrowser extends EventEmitter3 {
+  static #supportedBrowserTypes = ["chromium", "firefox", "webkit"];
+  static doesSupport(browserType) {
+    return _PlaywrightBrowser.#supportedBrowserTypes.includes(browserType);
+  }
   #browser;
   #browserIdx;
   #pid;
@@ -1527,7 +1636,7 @@ var PlaywrightBrowser = class extends EventEmitter3 {
     return this.#options.maxPageFreeSeconds ? this.#options.maxPageFreeSeconds : 900;
   }
   // constructor: called only by LsdBrowserController.launch/connect
-  constructor(browser, browerType, browserCreateMethod, options, browserIdx = 0, pid = 0) {
+  constructor(browser, browserType, browserCreateMethod, options, browserIdx = 0, pid = 0) {
     if (!browser || typeof browser.contexts !== "function") {
       throw new Error(`Invalid playwright browser parameter`);
     }
@@ -1539,7 +1648,10 @@ var PlaywrightBrowser = class extends EventEmitter3 {
     this.#createTime = getCurrentUnixTime3();
     this.#lsdBrowserContexts = [];
     this.#browserControllerType = "playwright";
-    this.#browserType = browerType;
+    this.#browserType = browserType;
+    if (!_PlaywrightBrowser.#supportedBrowserTypes.includes(browserType)) {
+      throw new Error(`Browser controller ${this.#browserControllerType} doesnot support browserType ${browserType}`);
+    }
     this.#browserCreationMethod = browserCreateMethod;
     this.#headless = headless;
     this.#proxy = options?.proxy ? Object.assign({}, options.proxy) : null;
@@ -1716,6 +1828,26 @@ var PuppeteerElement = class _PuppeteerElement {
     const names = await this.#frame.evaluate((ele) => ele.getAttributeNames(), this.#$ele);
     return names;
   }
+  async dataset() {
+    try {
+      const attributeNames = await this.attributeNames();
+      const dataset = {};
+      for (const attributeName of attributeNames) {
+        if (!attributeName.startsWith("data-")) {
+          continue;
+        }
+        const val = await this.attribute(attributeName);
+        const key = convertDataAttributeName(attributeName);
+        dataset[key] = val;
+      }
+      return dataset;
+    } catch (err) {
+      return {};
+    }
+  }
+  async evaluate(func, args) {
+    return await this.#frame.evaluate(func, args);
+  }
   async #getChildFrame(parentFrame, iframeOption) {
     if (!parentFrame) {
       throw new Error("Invalid parent frame");
@@ -1765,13 +1897,13 @@ var PuppeteerElement = class _PuppeteerElement {
     let frame = this.#frame;
     const retObj = { frame, elementHandles: [] };
     if (iframeOptions.length > 0) {
-      frame = await this.#getDescendantFrame(frame, iframeOptions);
-      if (!frame) {
+      const childFrame = await this.#getDescendantFrame(frame, iframeOptions);
+      if (!childFrame) {
         return retObj;
       }
-      retObj.frame = frame;
+      retObj.frame = childFrame;
       absolute = true;
-      parent = frame;
+      parent = childFrame;
     }
     try {
       if (selector.startsWith("./") || selector.startsWith("/") || selector.startsWith("..")) {
@@ -1973,6 +2105,7 @@ var PuppeteerPage = class extends EventEmitter4 {
   #page;
   #status;
   #pageId;
+  #closeWhenFree;
   #requestInterceptionNum;
   #responseInterceptionNum;
   #client;
@@ -2047,15 +2180,41 @@ var PuppeteerPage = class extends EventEmitter4 {
     });
     return true;
   }
+  async #findDescendantFrame(src, id) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    const frames = this.#page.frames();
+    for (const frame of frames) {
+      const url = frame.url();
+      if (typeof src === "string" && src) {
+        if (url.startsWith(src)) {
+          return frame;
+        } else if (url.toLowerCase().startsWith(src)) {
+          return frame;
+        }
+      } else if (src instanceof RegExp) {
+        if (url.match(src)) {
+          return frame;
+        }
+      } else if (id) {
+        const element = await frame.frameElement();
+        if (element) {
+          const frameId = await frame.evaluate((ele, attr) => ele.getAttribute(attr), element, "id");
+          if (frameId === id) {
+            return frame;
+          }
+        }
+      }
+    }
+    return null;
+  }
   async #getChildFrame(parentFrame, iframeOption) {
     if (!parentFrame) {
       throw new Error("Invalid parent frame");
     }
     let iframe = null;
-    let { src = "", selector = "" } = iframeOption;
-    if (!src && !selector) {
-      throw new Error("Invalid IframeOption");
-    }
+    let { src = "" } = iframeOption;
     if (src) {
       const childFrames = parentFrame.childFrames();
       for (const childFrame of childFrames) {
@@ -2073,7 +2232,8 @@ var PuppeteerPage = class extends EventEmitter4 {
         }
       }
     } else {
-      const $eleIframe = await parentFrame.$(selector);
+      const frameSelector = getIframeSelector(iframeOption);
+      const $eleIframe = await parentFrame.$(frameSelector);
       if ($eleIframe) {
         iframe = await $eleIframe.contentFrame();
         return iframe;
@@ -2083,11 +2243,16 @@ var PuppeteerPage = class extends EventEmitter4 {
   }
   async #getDescendantFrame(parentFrame, iframeOptions) {
     let iframe = parentFrame;
-    for (const iframeOption of iframeOptions) {
-      if (!iframe) {
-        return null;
+    if (iframeOptions.length === 1 && !iframeOptions[0].selector) {
+      const { src = "", id = "" } = iframeOptions[0];
+      iframe = await this.#findDescendantFrame(src, id);
+    } else {
+      for (const iframeOption of iframeOptions) {
+        if (!iframe) {
+          return null;
+        }
+        iframe = await this.#getChildFrame(iframe, iframeOption);
       }
-      iframe = await this.#getChildFrame(iframe, iframeOption);
     }
     return iframe;
   }
@@ -2116,7 +2281,7 @@ var PuppeteerPage = class extends EventEmitter4 {
       }
       return retObj;
     } catch (err) {
-      console.log(err);
+      loginfo(err);
       return retObj;
     }
   }
@@ -2169,11 +2334,31 @@ var PuppeteerPage = class extends EventEmitter4 {
     const { browserIdx = 0, browserContextIdx = 0, pageIdx = 0, openType = "other", openTime = currentTime, lastStatusUpdateTime = currentTime, taskId = 0, relatedId = 0, misc = {} } = pageInfo ? pageInfo : {};
     this.#page.pageInfo = { browserIdx, browserContextIdx, pageIdx, openType, openTime, lastStatusUpdateTime, taskId, relatedId, misc };
     this.#pageId = `page-${browserIdx}-${browserContextIdx}-${pageIdx}`;
+    this.#closeWhenFree = false;
     this.#requestInterceptionNum = 0;
     this.#responseInterceptionNum = 0;
     this.#client = null;
     this.#addPageOn();
   }
+  async addPreloadScript(scriptOrFunc, arg) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    if (typeof scriptOrFunc === "string") {
+      await this.#page.evaluateOnNewDocument(scriptOrFunc);
+    } else if (typeof scriptOrFunc === "function") {
+      await this.#page.evaluateOnNewDocument(scriptOrFunc, arg);
+    } else {
+      throw new Error(`Invalid type of scriptOrFunc ${typeof scriptOrFunc}`);
+    }
+    return true;
+  }
+  async addScriptTag(options) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    return this.#page.addScriptTag(options);
+  }
   apiContext() {
     throw new Error("Not supported in PuppeteerPage.");
   }
@@ -2230,7 +2415,7 @@ var PuppeteerPage = class extends EventEmitter4 {
   }
   async close() {
     if (this.#status === "closed") {
-      console.warn(`Page ${this.#pageId} is already closed.`);
+      logwarn(`Page ${this.#pageId} is already closed.`);
       return true;
     } else if (this.#status === "busy") {
       throw new Error(`Page ${this.#pageId} cannot be closed because it is busy.`);
@@ -2243,6 +2428,9 @@ var PuppeteerPage = class extends EventEmitter4 {
     this.#status = "closed";
     return true;
   }
+  closeWhenFree() {
+    return this.#closeWhenFree;
+  }
   async content(iframeOptions = []) {
     if (!this.#page) {
       throw new Error("No valid page");
@@ -2271,11 +2459,18 @@ var PuppeteerPage = class extends EventEmitter4 {
     const height = await this.#page.evaluate(() => document.documentElement.scrollHeight);
     return height;
   }
-  async evalute(fun, args) {
+  async evaluate(func, args) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    return this.#page.evaluate(func, args);
+  }
+  async exposeFunction(name, callbackFunction) {
     if (!this.#page) {
       throw new Error("No valid page");
     }
-    return this.#page.evaluate(fun, args);
+    await this.#page.exposeFunction(name, callbackFunction);
+    return;
   }
   async findElement(selectorOrXpath, iframeOptions = []) {
     if (!this.#page) {
@@ -2313,7 +2508,7 @@ var PuppeteerPage = class extends EventEmitter4 {
   }
   async free() {
     if (this.#status === "free") {
-      console.warn(`Page ${this.#pageId} is already free.`);
+      logwarn(`Page ${this.#pageId} is already free.`);
     }
     this.#status = "free";
     await this.clearRequestInterceptions();
@@ -2456,6 +2651,10 @@ var PuppeteerPage = class extends EventEmitter4 {
     }
     return response;
   }
+  setCloseWhenFree(closeWhenFree) {
+    this.#closeWhenFree = closeWhenFree;
+    return true;
+  }
   async setCookies(cookies) {
     if (!this.#page) {
       throw new Error("No valid page");
@@ -2531,7 +2730,7 @@ var PuppeteerPage = class extends EventEmitter4 {
     }
     const actOptions = Array.isArray(options) ? options : [options];
     if (actOptions.length <= 0) {
-      console.warn("Invalid paras in setRequestInterception");
+      logwarn("Invalid paras in setRequestInterception");
       return false;
     }
     if (this.#requestInterceptionNum <= 0) {
@@ -2567,7 +2766,7 @@ var PuppeteerPage = class extends EventEmitter4 {
         await request.continue();
         return true;
       } catch (err) {
-        console.error(err);
+        logerr(err);
         return false;
       }
     });
@@ -2579,7 +2778,7 @@ var PuppeteerPage = class extends EventEmitter4 {
     }
     const actOptions = Array.isArray(options) ? options : [options];
     if (actOptions.length <= 0) {
-      console.warn("Invalid paras in setResponseInterception");
+      logwarn("Invalid paras in setResponseInterception");
       return false;
     }
     this.#responseInterceptionNum++;
@@ -2634,7 +2833,7 @@ var PuppeteerPage = class extends EventEmitter4 {
         }
         return true;
       } catch (err) {
-        console.error(err);
+        logerr(err);
         return false;
       }
     });
@@ -3092,7 +3291,11 @@ var PuppeteerBrowserContext = class extends EventEmitter5 {
 };
 
 // src/puppeteer/browser.ts
-var PuppeteerBrowser = class extends EventEmitter6 {
+var PuppeteerBrowser = class _PuppeteerBrowser extends EventEmitter6 {
+  static #supportedBrowserTypes = ["chromium"];
+  static doesSupport(browserType) {
+    return _PuppeteerBrowser.#supportedBrowserTypes.includes(browserType);
+  }
   #browser;
   #browserIdx;
   #pid;
@@ -3124,7 +3327,7 @@ var PuppeteerBrowser = class extends EventEmitter6 {
     return this.#options.userAgent ? this.#options.userAgent : "";
   }
   // constructor: called only by LsdBrowserController.launch/connect
-  constructor(browser, browerType, browserCreateMethod, options, browserIdx = 0, pid = 0) {
+  constructor(browser, browserType, browserCreateMethod, options, browserIdx = 0, pid = 0) {
     if (!browser || typeof browser.browserContexts !== "function") {
       throw new Error(`Invalid puppeteer browser parameter`);
     }
@@ -3136,7 +3339,10 @@ var PuppeteerBrowser = class extends EventEmitter6 {
     this.#createTime = getCurrentUnixTime6();
     this.#lsdBrowserContexts = [];
     this.#browserControllerType = "puppeteer";
-    this.#browserType = browerType;
+    this.#browserType = browserType;
+    if (!_PuppeteerBrowser.#supportedBrowserTypes.includes(browserType)) {
+      throw new Error(`Browser controller ${this.#browserControllerType} doesnot support browserType ${browserType}`);
+    }
     this.#browserCreationMethod = browserCreateMethod;
     this.#headless = headless;
     this.#proxy = options?.proxy ? Object.assign({}, options.proxy) : null;
@@ -3294,6 +3500,22 @@ var CheerioElement = class _CheerioElement {
       return Array.from(Object.keys(element.attribs));
     }
   }
+  async dataset() {
+    const attributeNames = await this.attributeNames();
+    const dataset = {};
+    for (const attributeName of attributeNames) {
+      if (!attributeName.startsWith("data-")) {
+        continue;
+      }
+      const val = await this.attribute(attributeName);
+      const key = convertDataAttributeName(attributeName);
+      dataset[key] = val;
+    }
+    return dataset;
+  }
+  async evaluate() {
+    throw new Error("Not supported in CheerioPage.");
+  }
   #findNodes(selector, absolute) {
     if (selector.startsWith("./") || selector.startsWith("/")) {
       throw new Error("Do not support XPath in cheerio.");
@@ -3414,6 +3636,12 @@ var CheerioPage = class extends EventEmitter7 {
   _origPage() {
     throw new Error("Method not implemented.");
   }
+  async addPreloadScript() {
+    throw new Error("Not supported in CheerioPage.");
+  }
+  addScriptTag() {
+    throw new Error("Not supported in CheerioPage.");
+  }
   apiContext() {
     throw new Error("Not supported in CheerioPage.");
   }
@@ -3441,13 +3669,19 @@ var CheerioPage = class extends EventEmitter7 {
   async close() {
     throw new Error("Not supported in CheerioPage.");
   }
+  closeWhenFree() {
+    throw new Error("Not supported in CheerioPage.");
+  }
   async content() {
     throw new Error("Not supported in CheerioPage.");
   }
   async cookies() {
     throw new Error("Not supported in CheerioPage.");
   }
-  async evalute() {
+  async evaluate() {
+    throw new Error("Not supported in CheerioPage.");
+  }
+  exposeFunction() {
     throw new Error("Not supported in CheerioPage.");
   }
   #findNodes(selector) {
@@ -3544,6 +3778,9 @@ var CheerioPage = class extends EventEmitter7 {
   async sendCDPMessage() {
     throw new Error("Method not implemented.");
   }
+  setCloseWhenFree() {
+    throw new Error("Not supported in CheerioPage.");
+  }
   async setCookies() {
     throw new Error("Not supported in CheerioPage.");
   }
@@ -3600,89 +3837,1863 @@ var CheerioPage = class extends EventEmitter7 {
 // src/controller/controller.ts
 import os from "os";
 import puppeteer from "puppeteer";
-import playwright, { request as apiRequest } from "playwright";
-import puppeteerExtra from "puppeteer-extra";
-import * as playwrightExtra from "playwright-extra";
-import StealthPlugin from "puppeteer-extra-plugin-stealth";
-import { getPidsListeningOnPort, unreachable as unreachable5 } from "@letsscrapedata/utils";
-var LsdBrowserController = class _LsdBrowserController {
-  static #forbidConstructor = false;
-  #puppeteer;
-  #playwrightBrowserTypes;
-  #nextBrowserIdx;
-  /**
-   * Possible values are 'aix', 'darwin', 'freebsd','linux', 'openbsd', 'sunos', and 'win32'.
-   */
-  #osPlatform;
-  constructor() {
-    if (_LsdBrowserController.#forbidConstructor) {
-      throw new Error("Only one LsdBrowserController instance can be created!");
+import playwright, { request as apiRequestInPlaywright } from "playwright";
+import patchright from "patchright";
+
+// src/patchright/browser.ts
+import EventEmitter10 from "events";
+import { getCurrentUnixTime as getCurrentUnixTime9, getPerformanceOfPidTree as getPerformanceOfPidTree3 } from "@letsscrapedata/utils";
+
+// src/patchright/context.ts
+import EventEmitter9 from "events";
+import { getCurrentUnixTime as getCurrentUnixTime8, sleep as sleep3 } from "@letsscrapedata/utils";
+
+// src/patchright/page.ts
+import EventEmitter8 from "events";
+import { getCurrentUnixTime as getCurrentUnixTime7, unreachable as unreachable6 } from "@letsscrapedata/utils";
+
+// src/patchright/element.ts
+import { unreachable as unreachable5 } from "@letsscrapedata/utils";
+var PatchrightElement = class _PatchrightElement {
+  #frame;
+  #locator;
+  constructor(locator, frame) {
+    if (!frame.locator || !locator.click) {
+      throw new Error("Invalid paras in new PatchrightElement");
     }
-    this.#puppeteer = puppeteer;
-    const { chromium: chromium2, firefox: firefox2, webkit: webkit2 } = playwright;
-    this.#playwrightBrowserTypes = { chromium: chromium2, firefox: firefox2, webkit: webkit2 };
-    this.#osPlatform = os.platform();
-    this.#nextBrowserIdx = 1;
-    _LsdBrowserController.#forbidConstructor = true;
+    this.#frame = frame;
+    this.#locator = locator;
   }
-  #playwrightBrowserType(browserType, connectFlag = false) {
-    if (browserType === "chromium") {
-      return this.#playwrightBrowserTypes.chromium;
-    } else if (connectFlag) {
-      throw new Error(`playwright only can connect to chromium browser, not support ${browserType} browser`);
-    } else if (browserType === "firefox") {
-      return this.#playwrightBrowserTypes.firefox;
-    } else if (browserType === "webkit") {
-      return this.#playwrightBrowserTypes.webkit;
-    } else {
-      throw new Error(`Invalid playwright browserType ${browserType}`);
-    }
+  async attribute(attributeName) {
+    const attributeValue = await this.#locator.getAttribute(attributeName);
+    return attributeValue ? attributeValue : "";
   }
-  #puppeteerProduct(browserType) {
-    if (browserType === "chromium") {
-      return "chrome";
-    } else {
-      throw new Error(`Invalid puppeteer product ${browserType}`);
+  async attributeNames() {
+    const names = await this.#locator.evaluate((node) => node.getAttributeNames());
+    return names;
+  }
+  async dataset() {
+    try {
+      const dataset = await this.#locator.evaluate((node) => node.dataset);
+      return dataset;
+    } catch (err) {
+      return {};
     }
   }
-  setPuppeteerNode(puppeteer2) {
-    if (puppeteer2) {
-      this.#puppeteer = puppeteer2;
-    } else {
-      this.#puppeteer = puppeteerExtra.use(StealthPlugin());
+  async evaluate(func, args) {
+    try {
+      const frame = this.#frame;
+      ;
+      if (typeof frame.parentFrame === "function") {
+        return await frame.evaluate(func, args);
+      } else {
+        const locator = this.#frame.owner();
+        return await locator.evaluate(func, args);
+      }
+    } catch (err) {
+      logerr(err);
+      return "";
     }
-    return true;
   }
-  setPlaywrightBrowserType(browserType, playwrightBrowserType) {
-    switch (browserType) {
-      case "chromium":
-        if (playwrightBrowserType) {
-          this.#playwrightBrowserTypes.chromium = playwrightBrowserType;
-        } else {
-          this.#playwrightBrowserTypes.chromium = playwrightExtra.chromium.use(StealthPlugin());
-        }
-        break;
-      case "firefox":
-        if (playwrightBrowserType) {
-          this.#playwrightBrowserTypes.firefox = playwrightBrowserType;
+  /*
+    async #getChildFrame(parentFrame: Frame, iframeOption: IframeOption): Promise<Frame | null> {
+      if (!parentFrame) {
+        throw new Error("Invalid parent frame");
+      }
+  
+      let { src = "" } = iframeOption;
+      if (!src) {
+        throw new Error("Invalid src in IframeOption");
+      }
+  
+      // src: use childFrames()
+      const childFrames = parentFrame.childFrames();
+      for (const childFrame of childFrames) {
+        const url = childFrame.url();
+        if (typeof src === "string") {
+          // src: string
+          if (url.startsWith(src)) {
+            return childFrame;
+          } else if (url.toLowerCase().startsWith(src)) {
+            return childFrame;
+          }
         } else {
-          this.#playwrightBrowserTypes.firefox = playwrightExtra.firefox.use(StealthPlugin());
+          // src: RegExp
+          if (url.match(src)) {
+            return childFrame;
+          }
         }
-        break;
-      case "webkit":
-        if (playwrightBrowserType) {
-          this.#playwrightBrowserTypes.webkit = playwrightBrowserType;
-        } else {
-          this.#playwrightBrowserTypes.webkit = playwrightExtra.webkit.use(StealthPlugin());
+      }
+  
+      return null;
+    }
+      */
+  async #getChildFrameLocator(parent, iframeOption) {
+    return parent.frameLocator(getIframeSelector(iframeOption));
+  }
+  async #getDescendantFrame(parent, iframeOptions) {
+    try {
+      if (iframeOptions.length <= 0) {
+        return null;
+      }
+      let frameLocator = parent.frameLocator(getIframeSelector(iframeOptions[0]));
+      for (const iframeOption of iframeOptions.slice(1)) {
+        if (!frameLocator) {
+          return null;
         }
-        break;
-      default:
-        unreachable5(browserType);
+        frameLocator = await this.#getChildFrameLocator(frameLocator, iframeOption);
+      }
+      return frameLocator;
+    } catch (err) {
+      throw new Error(`No child iframe: ${JSON.stringify(iframeOptions)}`);
     }
-    return true;
   }
-  async launch(browserControllerType, browserType, options) {
-    let {
+  async #findElementHandles(selector, absolute = false, iframeOptions = []) {
+    let parent = absolute ? this.#frame : this.#locator;
+    let frame = this.#frame;
+    const retObj = { frame, locators: [] };
+    if (iframeOptions.length > 0) {
+      const childFrame = await this.#getDescendantFrame(frame, iframeOptions);
+      if (!childFrame) {
+        return retObj;
+      }
+      retObj.frame = childFrame;
+      parent = childFrame;
+    }
+    try {
+      let locators = [];
+      if (selector.startsWith("./") || selector.startsWith("/") || selector.startsWith("..")) {
+        locators = await parent.locator(`xpath=${selector}`).all();
+      } else {
+        if (selector !== ".") {
+          locators = await parent.locator(selector).all();
+        } else {
+          locators = [this.#locator];
+        }
+      }
+      retObj.locators = locators;
+      return retObj;
+    } catch (err) {
+      loginfo(err);
+      return retObj;
+    }
+  }
+  async findElement(selectorOrXpath, iframeOptions = [], absolute = false) {
+    const selectors = typeof selectorOrXpath === "string" ? [selectorOrXpath] : selectorOrXpath;
+    if (!Array.isArray(selectors)) {
+      throw new Error(`Invalid selectorOrXpath ${selectorOrXpath} in findElement`);
+    }
+    for (const selector of selectors) {
+      const { frame, locators } = await this.#findElementHandles(selector, absolute, iframeOptions);
+      if (locators.length > 0) {
+        const playwrightElement = new _PatchrightElement(locators[0], frame);
+        return playwrightElement;
+      }
+    }
+    return null;
+  }
+  async findElements(selectorOrXpath, iframeOptions = [], absolute = false) {
+    const selectors = typeof selectorOrXpath === "string" ? [selectorOrXpath] : selectorOrXpath;
+    if (!Array.isArray(selectors)) {
+      throw new Error(`Invalid selectorOrXpath ${selectorOrXpath} in findElements`);
+    }
+    for (const selector of selectors) {
+      const { frame, locators } = await this.#findElementHandles(selector, absolute, iframeOptions);
+      if (locators.length > 0) {
+        const playwrightElements = locators.map((locator) => new _PatchrightElement(locator, frame));
+        return playwrightElements;
+      }
+    }
+    return [];
+  }
+  async hasAttribute(attributeName) {
+    const hasFlag = await this.#locator.evaluate((node, attr) => node.hasAttribute(attr), attributeName);
+    return hasFlag;
+  }
+  async innerHtml() {
+    const html = await this.#locator.innerHTML();
+    return html;
+  }
+  async innerText(onlyChild = false) {
+    let text = "";
+    if (onlyChild) {
+      text = await this.#locator.evaluate((node) => {
+        let child = node.firstChild;
+        let texts = [];
+        while (child) {
+          if (child.nodeType == 3) {
+            texts.push(child.data);
+          }
+          child = child.nextSibling;
+        }
+        return texts.join(" ");
+      });
+    } else {
+      text = await this.#locator.innerText();
+    }
+    return text;
+  }
+  async outerHtml() {
+    const html = await this.#locator.evaluate((node) => node.outerHTML);
+    return html;
+  }
+  async textContent() {
+    const text = await this.#locator.textContent();
+    return text ? text : "";
+  }
+  async click(options = {}) {
+    const { button, clickCount: count, delay, position: offset, clickType = "click" } = options;
+    const actOptions = { button, count, delay, offset };
+    if (clickType === "click") {
+      await this.#locator.click(actOptions);
+    } else if (clickType === "evaluate") {
+      await this.#locator.evaluate(async (ev) => await ev.click());
+    } else {
+      unreachable5(clickType);
+    }
+    return true;
+  }
+  async focus() {
+    await this.#locator.focus();
+    return true;
+  }
+  async hover() {
+    await this.#locator.hover();
+    return true;
+  }
+  async input(value, options = {}) {
+    const { delay = 0, replace = false, enter = false } = options;
+    if (replace) {
+      await this.#locator.click({ button: "left", clickCount: 3 });
+    }
+    if (delay > 0) {
+      await this.#locator.fill(value);
+    } else {
+      await this.#locator.fill(value);
+    }
+    if (enter) {
+      await this.#locator.press("Enter");
+    }
+    return true;
+  }
+  async press(key, options = {}) {
+    await this.#locator.press(key, options);
+    return true;
+  }
+  async screenshot(options) {
+    return await this.#locator.screenshot(options);
+  }
+  async scrollIntoView() {
+    await this.#locator.scrollIntoViewIfNeeded();
+    return true;
+  }
+  async select(options) {
+    const { type, values = [], labels = [], indexes = [] } = options;
+    switch (type) {
+      case "value":
+        if (values.length > 0) {
+          await this.#locator.selectOption(values);
+        }
+        break;
+      case "label":
+        if (labels.length > 0) {
+          await this.#locator.selectOption(labels.map((label) => {
+            return { label };
+          }));
+        }
+        break;
+      case "index":
+        if (indexes.length > 0) {
+          const indexValues = await this.#locator.evaluate(
+            (node, indexes2) => {
+              const options2 = node.options;
+              const len = options2.length;
+              const vals = [];
+              for (const index of indexes2.filter((i) => i >= 0 && i < len)) {
+                vals.push(options2[index].value);
+              }
+              return vals;
+            },
+            indexes
+          );
+          if (indexValues.length > 0) {
+            await this.#locator.selectOption(indexValues);
+          }
+        }
+        break;
+      default:
+        unreachable5(type);
+    }
+    return true;
+  }
+  async setAttribute(attributeName, newValue) {
+    await this.#locator.evaluate((node, argvs) => {
+      node.setAttribute(argvs[0], argvs[1]);
+    }, [attributeName, newValue]);
+    return true;
+  }
+  _origElement() {
+    return this.#locator;
+  }
+};
+
+// src/patchright/page.ts
+var PatchrightPage = class extends EventEmitter8 {
+  #lsdBrowserContext;
+  #page;
+  #status;
+  #pageId;
+  #closeWhenFree;
+  #resquestInterceptionOptions;
+  #responseInterceptionOptions;
+  #client;
+  #responseCb;
+  #hasValidUrl(page) {
+    const url = page.url();
+    return url.toLowerCase().startsWith("http");
+  }
+  async #clearCookies(page) {
+    if (!this.#hasValidUrl(page)) {
+      throw new Error("Please open related url before clearing cookies");
+    }
+    const browserContext = this.#lsdBrowserContext._origBrowserContext();
+    if (!browserContext) {
+      throw new Error(`Invalid LsdBrowserContext`);
+    }
+    const cookieItems = await this.#getCookies(page);
+    const domainSet = new Set(cookieItems.map((c) => c.domain));
+    if (domainSet.size !== 1) {
+      logwarn(`Domains in clearCookies: ${Array.from(domainSet.values())}`);
+    }
+    for (const domain of domainSet.values()) {
+      await browserContext.clearCookies({ domain });
+    }
+    return true;
+  }
+  async #getCookies(page) {
+    if (!this.#hasValidUrl(page)) {
+      throw new Error("Please open related url before getting cookies");
+    }
+    const browserContext = this.#lsdBrowserContext._origBrowserContext();
+    if (!browserContext) {
+      throw new Error(`Invalid LsdBrowserContext`);
+    }
+    const url = page.url();
+    const origCookies = await browserContext.cookies(url);
+    const cookies = origCookies.map((origCookie) => {
+      const { name, value, domain, path, expires, httpOnly, secure, sameSite = "Lax" } = origCookie;
+      return { name, value, domain, path, expires, httpOnly, secure, sameSite };
+    });
+    return cookies;
+  }
+  async #setCookies(page, cookies) {
+    if (!page) {
+      throw new Error("No valid page");
+    }
+    if (Array.isArray(cookies) && cookies.length > 0 && cookies.every((c) => typeof c.name === "string")) {
+      const browserContext = this.#lsdBrowserContext._origBrowserContext();
+      if (!browserContext) {
+        throw new Error(`Invalid LsdBrowserContext`);
+      }
+      await browserContext.addCookies(cookies);
+      return true;
+    } else {
+      return false;
+    }
+  }
+  async #clearLocalStorage(page) {
+    if (!this.#hasValidUrl(page)) {
+      throw new Error("Please open related url before clearing localStorage");
+    }
+    await page.evaluate(() => window.localStorage.clear());
+    return true;
+  }
+  async #getLocalStorage(page) {
+    if (!this.#hasValidUrl(page)) {
+      throw new Error("Please open related url before getting localStorage");
+    }
+    const localStorageStr = await page.evaluate(() => JSON.stringify(window.localStorage));
+    const localStorageObj = JSON.parse(localStorageStr);
+    const localStorageItems = Object.keys(localStorageObj).map((name) => ({ name, value: localStorageObj[name] }));
+    const url = new URL(page.url());
+    return [{ origin: url.origin, localStorage: localStorageItems }];
+  }
+  async #setLocalStorage(page, localStorageItems) {
+    if (!this.#hasValidUrl(page)) {
+      throw new Error("Please open related url before setting localStorage");
+    }
+    await page.evaluate((items) => {
+      for (const item of items) {
+        window.localStorage.setItem(item.name, item.value);
+      }
+    }, localStorageItems);
+    return true;
+  }
+  async #clearIndexedDB(page) {
+    if (!this.#hasValidUrl(page)) {
+      throw new Error("Please open related url before clearing indexedDB");
+    }
+    await page.evaluate(async () => {
+      for (const db of await indexedDB.databases?.() || []) {
+        if (db.name)
+          indexedDB.deleteDatabase(db.name);
+      }
+    });
+    return true;
+  }
+  /*
+    async #getChildFrame(parentFrame: Frame, iframeOption: IframeOption): Promise<Frame | null> {
+      if (!parentFrame) {
+        throw new Error("Invalid parent frame");
+      }
+  
+      let { src = "" } = iframeOption;
+      if (!src) {
+        throw new Error("Invalid src in IframeOption");
+      }
+  
+      // src: use childFrames()
+      const childFrames = parentFrame.childFrames();
+      for (const childFrame of childFrames) {
+        const url = childFrame.url();
+        if (typeof src === "string") {
+          // src: string
+          if (url.startsWith(src)) {
+            return childFrame;
+          } else if (url.toLowerCase().startsWith(src)) {
+            return childFrame;
+          }
+        } else {
+          // src: RegExp
+          if (url.match(src)) {
+            return childFrame;
+          }
+        }
+      }
+  
+      return null;
+    }
+    */
+  async #findDescendantFrame(src, id) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    const frames = this.#page.frames();
+    for (const frame of frames) {
+      const url = frame.url();
+      if (typeof src === "string" && src) {
+        if (url.startsWith(src)) {
+          return frame;
+        } else if (url.toLowerCase().startsWith(src)) {
+          return frame;
+        }
+      } else if (src instanceof RegExp) {
+        if (url.match(src)) {
+          return frame;
+        }
+      } else if (id) {
+        const element = await frame.frameElement();
+        if (element) {
+          const frameId = await frame.evaluate(([ele, attr]) => ele.getAttribute(attr), [element, "id"]);
+          if (frameId === id) {
+            return frame;
+          }
+        }
+      }
+    }
+    return null;
+  }
+  async #getChildFrameLocator(parent, iframeOption) {
+    return parent.frameLocator(getIframeSelector(iframeOption));
+  }
+  async #getDescendantFrame(mainFrame, iframeOptions) {
+    try {
+      if (iframeOptions.length <= 0) {
+        return null;
+      }
+      if (iframeOptions.length === 1 && !iframeOptions[0].selector) {
+        const { src = "", id = "" } = iframeOptions[0];
+        const frame = await this.#findDescendantFrame(src, id);
+        return frame;
+      } else {
+        let frameLocator = mainFrame.frameLocator(getIframeSelector(iframeOptions[0]));
+        for (const iframeOption of iframeOptions.slice(1)) {
+          if (!frameLocator) {
+            return null;
+          }
+          frameLocator = await this.#getChildFrameLocator(frameLocator, iframeOption);
+        }
+        return frameLocator;
+      }
+    } catch (err) {
+      throw new Error(`No child iframe: ${JSON.stringify(iframeOptions)}`);
+    }
+  }
+  async #findElementHandles(selector, iframeOptions = []) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    let frame = this.#page.mainFrame();
+    const retObj = { frame, locators: [] };
+    if (iframeOptions.length > 0) {
+      frame = await this.#getDescendantFrame(frame, iframeOptions);
+      if (!frame) {
+        return retObj;
+      }
+      retObj.frame = frame;
+    }
+    try {
+      let locators = [];
+      if (selector.startsWith("./") || selector.startsWith("/") || selector.startsWith("..")) {
+        locators = await frame.locator(`xpath=${selector}`).all();
+      } else {
+        if (selector !== ".") {
+          locators = await frame.locator(selector).all();
+        } else {
+          throw new Error("Cannot use selector '.' on page");
+        }
+      }
+      retObj.locators = locators;
+      return retObj;
+    } catch (err) {
+      loginfo(err);
+      return retObj;
+    }
+  }
+  #addPageOn() {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    const page = this.#page;
+    const pageId = this.#pageId;
+    page.on("close", async () => {
+      loginfo(`##browser  ${pageId} closed`);
+      if (!page.pageInfo) {
+        logerr(`Logic error in page.on("close")`);
+      }
+      this.emit("pageClose");
+      this.#lsdBrowserContext.emit("pageClose", this);
+    });
+    page.on("popup", (p) => {
+      if (p) {
+        let evtData = null;
+        const pageInfo = p.pageInfo;
+        let popupPageId = "page";
+        if (pageInfo) {
+          const { browserIdx, browserContextIdx, pageIdx } = pageInfo;
+          popupPageId = `page-${browserIdx}-${browserContextIdx}-${pageIdx}`;
+          pageInfo.openType = "popup";
+          evtData = this.browserContext().page(pageIdx);
+          if (evtData && page.pageInfo?.taskId) {
+            pageInfo.relatedId = page.pageInfo.taskId;
+          }
+        } else {
+          logerr(`##browser  ${pageId} has popup without page.pageInfo`);
+        }
+        loginfo(`##browser  ${pageId} has popup ${popupPageId}`);
+        this.emit("pagePopup", evtData);
+      } else {
+        logerr(`##browser  ${pageId} has popup page with null page`);
+      }
+    });
+  }
+  constructor(browserContext, page, pageInfo) {
+    if (!browserContext.pages || !page?.goto) {
+      throw new Error("Invalid paras in new LsdPage");
+    }
+    super();
+    this.#lsdBrowserContext = browserContext;
+    this.#page = page;
+    this.#status = "free";
+    const currentTime = getCurrentUnixTime7();
+    const { browserIdx = 0, browserContextIdx = 0, pageIdx = 0, openType = "other", openTime = currentTime, lastStatusUpdateTime = currentTime, taskId = 0, relatedId = 0, misc = {} } = pageInfo ? pageInfo : {};
+    this.#page.pageInfo = { browserIdx, browserContextIdx, pageIdx, openType, openTime, lastStatusUpdateTime, taskId, relatedId, misc };
+    this.#pageId = `page-${browserIdx}-${browserContextIdx}-${pageIdx}`;
+    this.#closeWhenFree = false;
+    this.#resquestInterceptionOptions = [];
+    this.#responseInterceptionOptions = [];
+    this.#client = null;
+    this.#responseCb = null;
+    this.#addPageOn();
+  }
+  async addPreloadScript(scriptOrFunc, arg) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    if (typeof scriptOrFunc === "string") {
+      await this.#page.addInitScript({ content: scriptOrFunc });
+    } else if (typeof scriptOrFunc === "function") {
+      await this.#page.addInitScript(scriptOrFunc, arg);
+    } else {
+      throw new Error(`Invalid type of scriptOrFunc ${typeof scriptOrFunc}`);
+    }
+    return true;
+  }
+  async addScriptTag(options) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    return this.#page.addScriptTag(options);
+  }
+  apiContext() {
+    return this.browserContext().apiContext();
+  }
+  async bringToFront() {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    await this.#page.bringToFront();
+    return true;
+  }
+  browserContext() {
+    return this.#lsdBrowserContext;
+  }
+  async clearCookies() {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    return await this.#clearCookies(this.#page);
+  }
+  async clearLocalStorage() {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    return await this.#clearLocalStorage(this.#page);
+  }
+  async clearRequestInterceptions() {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    await this.#page.unrouteAll();
+    return true;
+  }
+  async clearResponseInterceptions() {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    try {
+      if (this.#responseInterceptionOptions.length > 0) {
+        if (this.#responseCb) {
+          this.#page.removeListener("response", this.#responseCb);
+        }
+        this.#responseInterceptionOptions = [];
+      }
+      return true;
+    } catch (err) {
+      logerr(err);
+      return false;
+    }
+  }
+  async clearStateData() {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    await this.#clearCookies(this.#page);
+    await this.#clearIndexedDB(this.#page);
+    return await this.#clearLocalStorage(this.#page);
+  }
+  async close() {
+    if (this.#status === "closed") {
+      logwarn(`Page ${this.#pageId} is already closed.`);
+      return true;
+    } else if (this.#status === "busy") {
+      throw new Error(`Page ${this.#pageId} cannot be closed because it is busy.`);
+    }
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    await this.#page.close();
+    this.#page = null;
+    this.#status = "closed";
+    return true;
+  }
+  closeWhenFree() {
+    return this.#closeWhenFree;
+  }
+  async content(iframeOptions = []) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    let content = "";
+    if (iframeOptions.length > 0) {
+      const frameLocator = await this.#getDescendantFrame(this.#page.mainFrame(), iframeOptions);
+      if (frameLocator) {
+        content = await frameLocator.locator(":root").evaluate(() => document.documentElement.outerHTML);
+      }
+    } else {
+      content = await this.#page.content();
+    }
+    return content;
+  }
+  async cookies() {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    return this.#getCookies(this.#page);
+  }
+  async documentHeight() {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    const height = await this.#page.evaluate(() => document.documentElement.scrollHeight);
+    return height;
+  }
+  async evaluate(func, args) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    return this.#page.evaluate(func, args);
+  }
+  async exposeFunction(name, callbackFunction) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    await this.#page.exposeFunction(name, callbackFunction);
+    return;
+  }
+  async findElement(selectorOrXpath, iframeOptions = []) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    const selectors = typeof selectorOrXpath === "string" ? [selectorOrXpath] : selectorOrXpath;
+    if (!Array.isArray(selectors)) {
+      throw new Error(`Invalid selectorOrXpath ${selectorOrXpath} in findElement`);
+    }
+    for (const selector of selectors) {
+      const { frame, locators } = await this.#findElementHandles(selector, iframeOptions);
+      if (locators.length > 0) {
+        const playwrightElement = new PatchrightElement(locators[0], frame);
+        return playwrightElement;
+      }
+    }
+    return null;
+  }
+  async findElements(selectorOrXpath, iframeOptions = []) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    const selectors = typeof selectorOrXpath === "string" ? [selectorOrXpath] : selectorOrXpath;
+    if (!Array.isArray(selectors)) {
+      throw new Error(`Invalid selectorOrXpath ${selectorOrXpath} in findElements`);
+    }
+    for (const selector of selectors) {
+      const { frame, locators } = await this.#findElementHandles(selector, iframeOptions);
+      if (locators.length > 0) {
+        const playwrightElements = locators.map((locator) => new PatchrightElement(locator, frame));
+        return playwrightElements;
+      }
+    }
+    return [];
+  }
+  async free() {
+    if (this.#status === "free") {
+      logwarn(`Page ${this.#pageId} is already free.`);
+    }
+    this.#status = "free";
+    await this.clearRequestInterceptions();
+    await this.clearResponseInterceptions();
+    return true;
+  }
+  #getWaitUntil(origWaitUntil) {
+    if (origWaitUntil === "networkidle0" || origWaitUntil === "networkidle2") {
+      return "networkidle";
+    } else {
+      return origWaitUntil;
+    }
+  }
+  async goto(url, options) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    if (options) {
+      const { referer, timeout, waitUntil = "load" } = options;
+      const newOptions = {};
+      if (referer) {
+        newOptions.referer = referer;
+      }
+      if (timeout) {
+        newOptions.timeout = timeout;
+      }
+      newOptions.waitUntil = this.#getWaitUntil(waitUntil);
+      await this.#page.goto(url, newOptions);
+    } else {
+      await this.#page.goto(url);
+    }
+    return true;
+  }
+  id() {
+    return this.#pageId;
+  }
+  isFree() {
+    return this.#status === "free";
+  }
+  async localStroage() {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    return this.#getLocalStorage(this.#page);
+  }
+  load() {
+    throw new Error("Not supported in PatchrightPage.");
+  }
+  mainFrame() {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    return this.#page.mainFrame();
+  }
+  async maximizeViewport() {
+    const height = await this.pageHeight();
+    const width = await this.pageWidth();
+    return await this.setViewportSize({ height, width });
+  }
+  async pageHeight() {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    const bodyHeight = await this.#page.evaluate(() => document.body.scrollHeight);
+    const documentHeight = await this.#page.evaluate(() => document.documentElement.scrollHeight);
+    const windowHeight = await this.#page.evaluate(() => window.outerHeight);
+    const pageHeight = Math.max(bodyHeight, documentHeight, windowHeight);
+    return pageHeight;
+  }
+  pageInfo() {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    return Object.assign({}, this.#page.pageInfo);
+  }
+  async pageWidth() {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    const offsetWidth = await this.#page.evaluate(() => document.documentElement.offsetWidth);
+    const windowWidth = await this.#page.evaluate(() => window.outerWidth);
+    const pageWidth = Math.max(offsetWidth, windowWidth);
+    return pageWidth;
+  }
+  async pdf(options) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    const buffer = await this.#page.pdf(options);
+    return buffer;
+  }
+  async screenshot(options) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    return await this.#page.screenshot(options);
+  }
+  async scrollBy(x, y) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    await this.#page.evaluate(
+      ([x2, y2]) => {
+        window.scrollBy(x2, y2);
+      },
+      [x, y]
+    );
+    return true;
+  }
+  async scrollTo(x, y) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    await this.#page.evaluate(
+      ([x2, y2]) => {
+        window.scrollTo(x2, y2);
+      },
+      [x, y]
+    );
+    return true;
+  }
+  async sendCDPMessage(method, params = null, detach = true) {
+    if (!this.#client) {
+      const origContext = this.browserContext()._origBrowserContext();
+      if (!origContext) {
+        throw new Error(`Invalid playwright browserContext`);
+      }
+      this.#client = await origContext.newCDPSession(this.#page);
+    }
+    if (!this.#client) {
+      throw new Error("No valid CDP session to send message");
+    }
+    const response = params ? await this.#client.send(method, params) : await this.#client.send(method);
+    if (detach) {
+      await this.#client.detach();
+      this.#client = null;
+    }
+    return response;
+  }
+  setCloseWhenFree(closeWhenFree) {
+    this.#closeWhenFree = closeWhenFree;
+    return true;
+  }
+  async setCookies(cookies) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    return await this.#setCookies(this.#page, cookies);
+  }
+  async setExtraHTTPHeaders(headers) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    await this.#page.setExtraHTTPHeaders(headers);
+    return true;
+  }
+  async setLocalStroage(localStorageItems) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    return await this.#setLocalStorage(this.#page, localStorageItems);
+  }
+  setPageInfo(pageInfo) {
+    if (!this.#page?.pageInfo) {
+      throw new Error("No valid page or pageInfo");
+    }
+    if (!pageInfo) {
+      throw new Error("Invalid paras in setPageInfo");
+    }
+    const actPageInfo = this.#page.pageInfo;
+    const { lastStatusUpdateTime, taskId, relatedId, misc } = pageInfo;
+    if (typeof lastStatusUpdateTime === "number") {
+      actPageInfo.lastStatusUpdateTime = lastStatusUpdateTime;
+    }
+    if (typeof taskId === "number") {
+      actPageInfo.taskId = taskId;
+    }
+    if (typeof relatedId === "number") {
+      actPageInfo.relatedId = relatedId;
+    }
+    if (misc && typeof misc === "object") {
+      for (const key of Object.keys(misc)) {
+        actPageInfo.misc[key] = misc[key];
+      }
+    }
+    return true;
+  }
+  #checkRequestMatch(request, requestMatch) {
+    try {
+      if (!request) {
+        return false;
+      }
+      const { methods, postData, resourceTypes, url } = requestMatch;
+      if (methods && !methods.includes(request.method().toUpperCase())) {
+        return false;
+      }
+      if (resourceTypes && !resourceTypes.includes(request.resourceType())) {
+        return false;
+      }
+      if (url && !request.url().match(url)) {
+        return false;
+      }
+      const origData = request.postData();
+      const data = origData ? origData : "";
+      if (postData && !data.match(postData)) {
+        return false;
+      }
+      return true;
+    } catch (err) {
+      logerr(err);
+      return false;
+    }
+  }
+  async setRequestInterception(options) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    const actOptions = Array.isArray(options) ? options : [options];
+    if (actOptions.length <= 0) {
+      logwarn("Invalid paras in setRequestInterception");
+      return false;
+    }
+    const firstRequestInterception = this.#resquestInterceptionOptions.length <= 0;
+    for (const option of actOptions) {
+      switch (option.action) {
+        case "abort":
+        case "fulfill":
+          this.#resquestInterceptionOptions.push(option);
+          break;
+        default:
+          unreachable6(option.action);
+      }
+    }
+    if (firstRequestInterception && this.#resquestInterceptionOptions.length > 0) {
+      this.#page.route("**", async (route) => {
+        try {
+          for (const option of actOptions) {
+            const { requestMatch, action, fulfill } = option;
+            const request = route.request();
+            const matchedFlag = !requestMatch || this.#checkRequestMatch(request, requestMatch);
+            if (matchedFlag) {
+              switch (action) {
+                case "abort":
+                  await route.abort();
+                  break;
+                case "fulfill":
+                  const body = fulfill ? fulfill : `<html><body><h1>${request.url()}</h1></body></html>`;
+                  route.fulfill({
+                    status: 200,
+                    // contentType: "text/html; charset=utf-8", // "text/plain",
+                    body
+                  });
+                  break;
+                default:
+                  unreachable6(action);
+              }
+              return true;
+            } else {
+            }
+          }
+          await route.continue();
+          return true;
+        } catch (err) {
+          logerr(err);
+          return false;
+        }
+      });
+    }
+    return true;
+  }
+  async #responseListener(response) {
+    try {
+      const pageUrl = this.#page ? this.#page.url() : "";
+      if (!response.ok()) {
+        return;
+      }
+      const request = response.request();
+      if (!request) {
+        return;
+      }
+      for (const option of this.#responseInterceptionOptions) {
+        const { requestMatch, responseMatch, responseItems, handler, handlerOptions = {} } = option;
+        let matchedFlag = !requestMatch || this.#checkRequestMatch(request, requestMatch);
+        if (matchedFlag && responseMatch) {
+          const { minLength, maxLength } = responseMatch;
+          const text = await response.text();
+          const len = text.length;
+          if (minLength && minLength > 0 && len < minLength || maxLength && maxLength > 0 && len > maxLength) {
+            matchedFlag = false;
+          }
+        }
+        if (!matchedFlag) {
+          continue;
+        }
+        if (Array.isArray(responseItems)) {
+          const requestMethod = request.method();
+          const requestUrl = request.url();
+          const reqData2 = request.postData();
+          const requestData = reqData2 ? reqData2 : "";
+          const responseData = await response.text();
+          responseItems.push({
+            pageUrl,
+            requestMethod,
+            requestUrl,
+            requestData,
+            responseData
+          });
+          loginfo(`##browser cache matched response: ${requestUrl}`);
+        }
+        if (typeof handler === "function") {
+          const pageData = { pageUrl, cookies: "" };
+          await handler(response, handlerOptions, pageData);
+        }
+      }
+      return;
+    } catch (err) {
+      logerr(err);
+      return;
+    }
+  }
+  async setResponseInterception(options) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    const actOptions = Array.isArray(options) ? options : [options];
+    if (actOptions.length <= 0) {
+      logwarn("Invalid paras in setResponseInterception");
+      return false;
+    }
+    const firstResponseInterception = this.#responseInterceptionOptions.length <= 0;
+    for (const option of actOptions) {
+      if (option?.responseItems || option?.handler) {
+        this.#responseInterceptionOptions.push(option);
+      } else {
+        throw new Error(`Invalid ResponseInterceptionOption`);
+      }
+    }
+    if (firstResponseInterception && this.#responseInterceptionOptions.length > 0) {
+      this.#responseCb = this.#responseListener.bind(this);
+      this.#page.on("response", this.#responseCb);
+    }
+    return true;
+  }
+  async setStateData(stateData) {
+    return await this.#lsdBrowserContext.setStateData(stateData);
+  }
+  async setUserAgent(userAgent) {
+    if (userAgent) {
+      throw new Error(`Patchright does not support page.setUserAgent by now`);
+    }
+    return false;
+  }
+  async setViewportSize(viewPortSize) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    await this.#page.setViewportSize(viewPortSize);
+    return true;
+  }
+  async stateData() {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    const cookies = await this.#getCookies(this.#page);
+    const localStorage = await this.#getLocalStorage(this.#page);
+    return { cookies, localStorage };
+  }
+  status() {
+    return this.#status;
+  }
+  async title() {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    return await this.#page.title();
+  }
+  url() {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    return this.#page.url();
+  }
+  use() {
+    if (this.#status === "busy") {
+      throw new Error(`Page ${this.#pageId} is already busy!!!`);
+    }
+    this.#status = "busy";
+    return true;
+  }
+  async waitForElement(selector, options = {}) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    const locator = this.#page.locator(selector);
+    const { timeout = 3e4, state = "visible" } = options;
+    await locator.waitFor({ state, timeout });
+    return true;
+  }
+  async waitForNavigation(options) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    const { url = "", timeout = 3e4, waitUntil = "load" } = options;
+    const newWaitUntil = this.#getWaitUntil(waitUntil);
+    if (url) {
+      await this.#page.waitForURL(url, { timeout, waitUntil: newWaitUntil });
+    } else if (newWaitUntil === "commit") {
+      throw new Error("commit is not supported in PatchrightPage.waitForNavigation");
+    } else {
+      await this.#page.waitForLoadState(newWaitUntil, { timeout });
+    }
+    return true;
+  }
+  async windowMember(keys) {
+    if (!this.#page) {
+      throw new Error("No valid page");
+    }
+    if (!this.#page || !Array.isArray(keys) || keys.length <= 0 || keys.length > 20) {
+      return "";
+    }
+    const content = await this.#page.evaluate(
+      (keys2) => {
+        let retObj = window;
+        for (const key of keys2) {
+          if (!key) {
+            break;
+          } else if (typeof retObj !== "object" || !retObj) {
+            return "";
+          } else {
+            retObj = retObj[key];
+          }
+        }
+        if (typeof retObj === "string") {
+          return retObj;
+        } else if (typeof retObj === "number") {
+          return String(retObj);
+        } else if (typeof retObj === "boolean") {
+          return String(Number(retObj));
+        } else if (!retObj) {
+          return "";
+        } else if (typeof retObj === "object") {
+          try {
+            return JSON.stringify(retObj);
+          } catch (err) {
+            return "";
+          }
+        } else if (typeof retObj === "bigint") {
+          return String(retObj);
+        } else {
+          return "";
+        }
+      },
+      keys
+    );
+    return content;
+  }
+  _origPage() {
+    return this.#page;
+  }
+};
+
+// src/patchright/api.ts
+var PatchrightApiContext = class {
+  #apiRequestContext;
+  #status;
+  constructor(apiRequestContext) {
+    this.#apiRequestContext = apiRequestContext;
+    this.#status = "normal";
+  }
+  async fetch(url, options = {}) {
+    if (this.#status !== "normal") {
+      throw new Error(`ApiContext has already been destroyed`);
+    }
+    const apiResponse = await this.#apiRequestContext.fetch(url, options);
+    const headers = apiResponse.headers();
+    const status = apiResponse.status();
+    const statusText = apiResponse.statusText();
+    const text = await apiResponse.text();
+    const responseUrl = apiResponse.url();
+    return { headers, status, statusText, text, url: responseUrl };
+  }
+  async stateData() {
+    if (this.#status !== "normal") {
+      throw new Error(`ApiContext has already been destroyed`);
+    }
+    const storageState = await this.#apiRequestContext.storageState();
+    const { cookies, origins: localStorage } = storageState;
+    return { cookies, localStorage };
+  }
+  async destroy() {
+    await this.#apiRequestContext.dispose();
+    this.#status = "destroyed";
+    return true;
+  }
+};
+
+// src/patchright/context.ts
+var PatchrightBrowserContext = class extends EventEmitter9 {
+  #lsdBrowser;
+  #browserIdx;
+  #browserContextIdx;
+  #browserContext;
+  #browserContextCreationMethod;
+  #apiContext;
+  #createTime;
+  #lastStatusUpdateTime;
+  #status;
+  #incognito;
+  #proxy;
+  #maxPagesPerBrowserContext;
+  #maxPageFreeSeconds;
+  #maxViewportOfNewPage;
+  #lsdPages;
+  #nextPageIdx;
+  #gettingPage;
+  async #initPages() {
+    if (!this.#browserContext) {
+      throw new Error("Invalid browserContext");
+    }
+    const pages = this.#browserContext.pages();
+    const openType = this.#lsdBrowser.browserCreationMethod();
+    const lastStatusUpdateTime = getCurrentUnixTime8();
+    for (const page of pages) {
+      const pageInfo = { browserIdx: this.#browserIdx, browserContextIdx: this.#browserContextIdx, pageIdx: this.#nextPageIdx++, openType, openTime: this.#createTime, lastStatusUpdateTime, taskId: 0, relatedId: 0, misc: {} };
+      const lsdPage = new PatchrightPage(this, page, pageInfo);
+      if (this.#maxViewportOfNewPage) {
+        await lsdPage.maximizeViewport();
+      }
+      this.#lsdPages.push(lsdPage);
+      loginfo(`##browser  ${lsdPage.id()} ${openType}ed`);
+    }
+  }
+  constructor(lsdBrowser, browserContext, browserContextCreationMethod, incognito = false, proxy = null, browserIdx = 0, browserContextIdx = 0, maxPagesPerBrowserContext = 20, maxPageFreeSeconds = 0, maxViewportOfNewPage = true) {
+    if (!lsdBrowser || typeof lsdBrowser.browserContexts !== "function") {
+      throw new Error(`Invalid lsdBrowser parameter`);
+    }
+    if (!browserContext || typeof browserContext.setOffline !== "function") {
+      throw new Error(`Invalid playwright browserContext parameter`);
+    }
+    super();
+    this.#lsdBrowser = lsdBrowser;
+    this.#browserIdx = browserIdx;
+    this.#browserContextIdx = browserContextIdx;
+    this.#browserContext = browserContext;
+    this.#browserContextCreationMethod = browserContextCreationMethod;
+    const apiRequestContext = browserContext.request;
+    this.#apiContext = new PatchrightApiContext(apiRequestContext);
+    const currentTime = getCurrentUnixTime8();
+    this.#createTime = currentTime;
+    this.#lastStatusUpdateTime = currentTime;
+    this.#status = "free";
+    this.#incognito = incognito === false ? false : true;
+    this.#proxy = proxy?.proxyUrl ? proxy : null;
+    this.#maxPagesPerBrowserContext = maxPagesPerBrowserContext;
+    this.#maxPageFreeSeconds = maxPageFreeSeconds;
+    this.#maxViewportOfNewPage = maxViewportOfNewPage;
+    this.#lsdPages = [];
+    this.#nextPageIdx = 1;
+    this.#gettingPage = false;
+    this.#initPages();
+    browserContext.on("page", async (page) => {
+      const pageInfo = page.pageInfo;
+      if (pageInfo) {
+        const { browserIdx: browserIdx2, browserContextIdx: browserContextIdx2, pageIdx } = pageInfo;
+        logwarn(`##browser page-${browserIdx2}-${browserContextIdx2}-${pageIdx} has been already created`);
+      } else {
+        const currentTime2 = getCurrentUnixTime8();
+        const pageInfo2 = { browserIdx: this.#browserIdx, browserContextIdx: this.#browserContextIdx, pageIdx: this.#nextPageIdx++, openType: "other", openTime: currentTime2, lastStatusUpdateTime: currentTime2, taskId: 0, relatedId: 0, misc: {} };
+        const lsdPage = new PatchrightPage(this, page, pageInfo2);
+        if (this.#maxViewportOfNewPage) {
+          await lsdPage.maximizeViewport();
+        }
+        this.#lsdPages.push(lsdPage);
+        loginfo(`##page ${lsdPage.id()} created`);
+      }
+    });
+    browserContext.on("close", (bc) => {
+      if (browserContext !== bc) {
+        logerr(`##browser different browserContext in browserContext.on("close")`);
+      }
+      this.#lsdBrowser.emit("browserContextClose", this);
+    });
+    this.on("pageClose", (lsdPage) => {
+      if (!(lsdPage instanceof PatchrightPage)) {
+        logerr(`Invalid data in LsdBrowserContext.on("pageClose)`);
+        return;
+      }
+      const idx = this.#lsdPages.findIndex((p) => p === lsdPage);
+      if (idx < 0) {
+        logerr(`Invalid lsdPage in LsdBrowserContext.on("pageClose)`);
+        return;
+      }
+      this.#lsdPages.splice(idx, 1);
+      return;
+    });
+  }
+  apiContext() {
+    return this.#apiContext;
+  }
+  browser() {
+    return this.#lsdBrowser;
+  }
+  async close() {
+    if (this.#browserContext) {
+      this.#status = "closed";
+      this.#lastStatusUpdateTime = getCurrentUnixTime8();
+      loginfo(`browserContext ${this.id()} closed at ${this.#lastStatusUpdateTime}`);
+      await this.#browserContext.close();
+    }
+    return true;
+  }
+  async #tryToGetGettingLock() {
+    let i = 0;
+    for (i = 0; i < 50; i++) {
+      if (!this.#gettingPage) {
+        this.#gettingPage = true;
+        return true;
+      } else {
+        await sleep3(200);
+      }
+    }
+    logwarn(`Cannot get the gettingLock.`);
+    return false;
+  }
+  #freeGettingLock() {
+    if (!this.#gettingPage) {
+      logwarn(`Getting lock is already free now.`);
+    }
+    this.#gettingPage = false;
+  }
+  async closeFreePages(maxPageFreeSeconds = 0) {
+    if (maxPageFreeSeconds <= 0) {
+      maxPageFreeSeconds = this.#maxPageFreeSeconds;
+    }
+    if (maxPageFreeSeconds <= 0) {
+      logwarn(`Please set valid maxPageFreeSeconds to close free pages`);
+      return false;
+    }
+    const gotLock = await this.#tryToGetGettingLock();
+    if (!gotLock) {
+      return false;
+    }
+    try {
+      const maxUpdateTime = getCurrentUnixTime8() - this.#maxPageFreeSeconds;
+      let freePages = this.#lsdPages.filter((p) => p.isFree() && p.pageInfo().lastStatusUpdateTime < maxUpdateTime);
+      if (freePages.length === this.#lsdPages.length) {
+        freePages = freePages.slice(1);
+      }
+      for (const lsdPage of freePages) {
+        await lsdPage.close();
+      }
+      this.#freeGettingLock();
+      return true;
+    } catch (err) {
+      logerr(err);
+      this.#freeGettingLock();
+      return false;
+    }
+  }
+  creationMethod() {
+    return this.#browserContextCreationMethod;
+  }
+  doesMeetBrowserContextRequirements(browserContextRequirements) {
+    if (!this.#lsdBrowser.doesMeetBrowserContextRequirements(browserContextRequirements)) {
+      return false;
+    }
+    const { browserIncognitos: incognitos } = browserContextRequirements;
+    return incognitos.length === 0 || incognitos.includes(this.#incognito);
+  }
+  async getPage(always = false) {
+    if (!this.#browserContext) {
+      throw new Error("Invalid browserContext");
+    }
+    const gotLock = await this.#tryToGetGettingLock();
+    if (!gotLock) {
+      return null;
+    }
+    try {
+      let lsdPage = this.#lsdPages.find((p) => p.isFree());
+      if (lsdPage) {
+        lsdPage.use();
+        this.#freeGettingLock();
+        return lsdPage;
+      }
+      if (this.#lsdPages.length >= this.#maxPagesPerBrowserContext && !always) {
+        this.#freeGettingLock();
+        return null;
+      }
+      const page = await this.#browserContext.newPage();
+      await sleep3(2e3);
+      const pageInfo = page.pageInfo;
+      if (!pageInfo) {
+        throw new Error(`Logic error in getPage`);
+      } else {
+        pageInfo.openType = "newpage";
+      }
+      lsdPage = this.#lsdPages.find((p) => p.isFree());
+      if (lsdPage) {
+        lsdPage.use();
+        this.#freeGettingLock();
+        return lsdPage;
+      } else {
+        this.#freeGettingLock();
+        return null;
+      }
+    } catch (err) {
+      logerr(err);
+      this.#freeGettingLock();
+      return null;
+    }
+  }
+  free(clearStateData = false) {
+    if (this.#status === "busy") {
+      this.#status = "free";
+      this.#lastStatusUpdateTime = getCurrentUnixTime8();
+      if (clearStateData) {
+      }
+      return true;
+    } else {
+      return false;
+    }
+  }
+  hasFreePage(pageNum = 1) {
+    if (this.#maxPagesPerBrowserContext - this.#lsdPages.length > pageNum) {
+      return true;
+    } else if (this.#maxPagesPerBrowserContext - this.#lsdPages.filter((p) => !p.isFree()).length > pageNum) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+  id() {
+    return `browserContext-${this.#browserIdx}-${this.#browserContextIdx}`;
+  }
+  isFree() {
+    return this.#status === "free";
+  }
+  isIncognito() {
+    return this.#incognito;
+  }
+  page(pageIdx) {
+    const lsdPage = this.#lsdPages.find((p) => p.pageInfo().pageIdx === pageIdx);
+    return lsdPage ? lsdPage : null;
+  }
+  pages() {
+    return this.#lsdPages;
+  }
+  proxy() {
+    return this.#proxy;
+  }
+  async setStateData(stateData) {
+    if (!this.#browserContext) {
+      throw new Error("No valid browserContext");
+    }
+    try {
+      const { cookies, localStorage: localStorageOrigins } = stateData;
+      const page = await this.getPage();
+      if (!page) {
+        return false;
+      }
+      const origPage = page._origPage();
+      if (cookies.length > 0) {
+        await this.#browserContext.addCookies(cookies);
+      }
+      if (localStorageOrigins.length > 0) {
+        await origPage.route("**/*", async (route) => {
+          const request = route.request();
+          await route.fulfill({
+            status: 200,
+            // contentType: "text/html; charset=utf-8", // "text/plain",
+            body: `<html><body><h1>${request.url()}</h1></body></html>`
+          });
+        });
+        for (const localStorageOrigin of localStorageOrigins) {
+          const { origin, localStorage } = localStorageOrigin;
+          await origPage.goto(origin);
+          await origPage.evaluate((localStorageItems) => {
+            for (const item of localStorageItems) {
+              window.localStorage.setItem(item.name, item.value);
+            }
+          }, localStorage);
+        }
+      }
+      await sleep3(2e3);
+      await origPage.unrouteAll();
+      await page.free();
+      return true;
+    } catch (err) {
+      logerr(err);
+      return false;
+    }
+  }
+  status() {
+    return this.#status;
+  }
+  use() {
+    if (this.#status === "free") {
+      this.#status = "busy";
+      this.#lastStatusUpdateTime = getCurrentUnixTime8();
+      return true;
+    } else {
+      return false;
+    }
+  }
+  _origBrowserContext() {
+    return this.#browserContext;
+  }
+};
+
+// src/patchright/browser.ts
+var PatchrightBrowser = class _PatchrightBrowser extends EventEmitter10 {
+  static #supportedBrowserTypes = ["chromium", "firefox", "webkit"];
+  static doesSupport(browserType) {
+    return _PatchrightBrowser.#supportedBrowserTypes.includes(browserType);
+  }
+  #browser;
+  #browserIdx;
+  #pid;
+  #createTime;
+  #lsdBrowserContexts;
+  #browserControllerType;
+  #browserType;
+  #browserCreationMethod;
+  #headless;
+  #options;
+  #proxy;
+  /**
+   * launch: actual path of executable app
+   * connect: ""
+   */
+  #executablePath;
+  #nextBrowserContextIdx;
+  #closeFreePagesIntervalId;
+  #maxBrowserContextsPerBrowser() {
+    return this.#options.maxBrowserContextsPerBrowser ? this.#options.maxBrowserContextsPerBrowser : 10;
+  }
+  #maxPagesPerBrowserContext() {
+    return this.#options.maxPagesPerBrowserContext ? this.#options.maxPagesPerBrowserContext : 20;
+  }
+  #maxPageFreeSeconds() {
+    return this.#options.maxPageFreeSeconds ? this.#options.maxPageFreeSeconds : 900;
+  }
+  // constructor: called only by LsdBrowserController.launch/connect
+  constructor(browser, browserType, browserCreateMethod, options, browserIdx = 0, pid = 0) {
+    if (!browser || typeof browser.contexts !== "function") {
+      throw new Error(`Invalid playwright browser parameter`);
+    }
+    super();
+    const { closeFreePagesIntervalSeconds = 300, maxPageFreeSeconds = 900, maxViewportOfNewPage = true, headless = false, executablePath = "" } = options;
+    this.#browser = browser;
+    this.#browserIdx = browserIdx;
+    this.#pid = pid;
+    this.#createTime = getCurrentUnixTime9();
+    this.#lsdBrowserContexts = [];
+    this.#browserControllerType = "playwright";
+    this.#browserType = browserType;
+    if (!_PatchrightBrowser.#supportedBrowserTypes.includes(browserType)) {
+      throw new Error(`Browser controller ${this.#browserControllerType} doesnot support browserType ${browserType}`);
+    }
+    this.#browserCreationMethod = browserCreateMethod;
+    this.#headless = headless;
+    this.#proxy = options?.proxy ? Object.assign({}, options.proxy) : null;
+    this.#options = Object.assign({}, options, { closeFreePagesIntervalSeconds, maxPageFreeSeconds, maxViewportOfNewPage, headless, executablePath, proxy: this.#proxy });
+    this.#executablePath = executablePath;
+    this.#nextBrowserContextIdx = 1;
+    this.#closeFreePagesIntervalId = null;
+    loginfo(`##browser ${this.id()} ${this.#browserCreationMethod}ed by ${this.#browserControllerType}`);
+    const browserContexts = browser.contexts();
+    if (browserContexts.length > 0) {
+      logwarn(`There are ${browserContexts.length} new browserContexts when playwright launches new browser`);
+    }
+    const incognito = typeof options?.incognito === "boolean" ? options.incognito : true;
+    for (const browserContext of browserContexts) {
+      const lsdBrowserContext = new PatchrightBrowserContext(this, browserContext, "launch", incognito, this.#proxy, this.#browserIdx, this.#nextBrowserContextIdx++, this.#maxPagesPerBrowserContext(), this.#maxPageFreeSeconds(), maxViewportOfNewPage);
+      this.#lsdBrowserContexts.push(lsdBrowserContext);
+      loginfo(`##browserContext  ${lsdBrowserContext.id()} ${this.#browserCreationMethod}ed`);
+    }
+    browser.on("disconnected", () => {
+      loginfo(`##browser  ${this.id()} disconnected`);
+      if (this.#lsdBrowserContexts.length > 0) {
+        logerr(`${this.id()} has browserContexts when disconnected`);
+      }
+    });
+    this.on("browserContextClose", (lsdBrowserContext) => {
+      if (!(lsdBrowserContext instanceof PatchrightBrowserContext)) {
+        logerr(`Invalid data in LsdBrowser.on("browserContextClose)`);
+        return;
+      }
+      const idx = this.#lsdBrowserContexts.findIndex((bc) => bc === lsdBrowserContext);
+      if (idx < 0) {
+        logerr(`Invalid lsdBrowserContext in LsdBrowser.on("browserContextClose)`);
+        return;
+      }
+      loginfo(`##browserContext  ${lsdBrowserContext.id()} closed
+`);
+      this.#lsdBrowserContexts.splice(idx, 1);
+      if (this.#lsdBrowserContexts.length === 0) {
+        loginfo(`##browser  ${this.id()} has no browserContexts now`);
+      }
+      return;
+    });
+    if (closeFreePagesIntervalSeconds > 0 && maxPageFreeSeconds > 0) {
+      this.#closeFreePagesIntervalId = setInterval(async () => {
+        await this.#closeFreePagesHandler();
+      }, closeFreePagesIntervalSeconds * 1e3);
+    }
+  }
+  async #closeFreePagesHandler() {
+    for (const lsdBrowserContext of this.#lsdBrowserContexts) {
+      await lsdBrowserContext.closeFreePages();
+    }
+  }
+  async newBrowserContext(options) {
+    if (this.#lsdBrowserContexts.length >= this.#maxBrowserContextsPerBrowser()) {
+      logwarn(`##browser ${this.id()} can not create more new browserContext`);
+      return null;
+    }
+    const browserContextOptions = {};
+    if (this.#options.maxWindowSize) {
+      browserContextOptions.viewport = null;
+    }
+    const proxy = options?.proxy ? Object.assign({}, options.proxy) : this.#proxy;
+    if (proxy) {
+      const { proxyUrl: server, username, password } = proxy;
+      browserContextOptions.proxy = { server, username, password };
+    }
+    if (options?.userAgent) {
+      browserContextOptions.userAgent = options.userAgent;
+    }
+    const browserContext = await this.#browser.newContext(browserContextOptions);
+    const { maxViewportOfNewPage = this.#options.maxViewportOfNewPage } = options ? options : {};
+    const lsdBrowserContext = new PatchrightBrowserContext(this, browserContext, "new", true, proxy, this.#browserIdx, this.#nextBrowserContextIdx++, this.#maxPagesPerBrowserContext(), this.#maxPageFreeSeconds(), maxViewportOfNewPage);
+    this.#lsdBrowserContexts.push(lsdBrowserContext);
+    loginfo(`##browser  ${lsdBrowserContext.id()} created`);
+    return lsdBrowserContext;
+  }
+  async close() {
+    if (this.#closeFreePagesIntervalId) {
+      clearInterval(this.#closeFreePagesIntervalId);
+    }
+    for (const lsdBrowserContext of this.#lsdBrowserContexts) {
+      await lsdBrowserContext.close();
+    }
+    await this.#browser.close();
+    return true;
+  }
+  browserContexts() {
+    return this.#lsdBrowserContexts;
+  }
+  browserControllerType() {
+    return this.#browserControllerType;
+  }
+  browserCreationMethod() {
+    return this.#browserCreationMethod;
+  }
+  browserType() {
+    return this.#browserType;
+  }
+  createTime() {
+    return this.#createTime;
+  }
+  doesMeetBrowserContextRequirements(browserContextRequirements) {
+    const { browserControllerTypes, browserTypes, browserHeadlesses } = browserContextRequirements;
+    return (browserControllerTypes.length === 0 || browserControllerTypes.includes(this.#browserControllerType)) && (browserTypes.length === 0 || browserTypes.includes(this.#browserType)) && (browserHeadlesses.length === 0 || browserHeadlesses.includes(this.#headless));
+  }
+  executablePath() {
+    return this.#executablePath;
+  }
+  id() {
+    return `browser-${this.#browserType}-${this.#browserIdx}`;
+  }
+  isConnected() {
+    return this.#browser.isConnected();
+  }
+  isHeadless() {
+    return this.#headless;
+  }
+  options() {
+    return this.#options;
+  }
+  pid() {
+    return this.#pid;
+  }
+  async pidUsage() {
+    if (this.#pid > 0) {
+      const usage = await getPerformanceOfPidTree3(this.#pid, "MB");
+      return usage;
+    } else {
+      return { cpu: 0, memory: 0 };
+    }
+  }
+  proxy() {
+    return this.#proxy;
+  }
+  async version() {
+    const version = await this.#browser.version();
+    return version;
+  }
+  _origBrowser() {
+    return this.#browser;
+  }
+};
+
+// src/controller/controller.ts
+import { getPidsListeningOnPort, unreachable as unreachable7 } from "@letsscrapedata/utils";
+var LsdBrowserController = class _LsdBrowserController {
+  static #forbidConstructor = false;
+  #puppeteer;
+  #playwrightBrowserTypes;
+  #patchrightBrowserTypes;
+  #nextBrowserIdx;
+  /**
+   * Possible values are 'aix', 'darwin', 'freebsd','linux', 'openbsd', 'sunos', and 'win32'.
+   */
+  #osPlatform;
+  constructor() {
+    if (_LsdBrowserController.#forbidConstructor) {
+      throw new Error("Only one LsdBrowserController instance can be created!");
+    }
+    this.#puppeteer = puppeteer;
+    this.#playwrightBrowserTypes = {
+      chromium: playwright.chromium,
+      firefox: playwright.firefox,
+      webkit: playwright.webkit
+    };
+    this.#patchrightBrowserTypes = {
+      chromium: patchright.chromium,
+      firefox: patchright.firefox,
+      webkit: patchright.webkit
+    };
+    this.#osPlatform = os.platform();
+    this.#nextBrowserIdx = 1;
+    _LsdBrowserController.#forbidConstructor = true;
+  }
+  #playwrightBrowserType(browserType, connectFlag = false) {
+    if (browserType === "chromium") {
+      return this.#playwrightBrowserTypes.chromium;
+    } else if (connectFlag) {
+      throw new Error(`playwright only can connect to chromium browser, not support ${browserType} browser`);
+    } else if (browserType === "firefox") {
+      return this.#playwrightBrowserTypes.firefox;
+    } else if (browserType === "webkit") {
+      return this.#playwrightBrowserTypes.webkit;
+    } else {
+      throw new Error(`Invalid playwright browserType ${browserType}`);
+    }
+  }
+  #patchrightBrowserType(browserType, connectFlag = false) {
+    if (browserType === "chromium") {
+      return this.#patchrightBrowserTypes.chromium;
+    } else if (connectFlag) {
+      throw new Error(`patchright only can connect to chromium browser, not support ${browserType} browser`);
+    } else if (browserType === "firefox") {
+      return this.#patchrightBrowserTypes.firefox;
+    } else if (browserType === "webkit") {
+      return this.#patchrightBrowserTypes.webkit;
+    } else {
+      throw new Error(`Invalid patchright browserType ${browserType}`);
+    }
+  }
+  #puppeteerProduct(browserType) {
+    if (browserType === "chromium") {
+      return "chrome";
+    } else {
+      throw new Error(`Invalid puppeteer product ${browserType}`);
+    }
+  }
+  setBrowserPlugin(browserControllerType, browserType, plugin) {
+    if (browserControllerType === "puppeteer") {
+      if (!PuppeteerBrowser.doesSupport(browserType)) {
+        throw new Error(`BrowserControllerType ${browserControllerType} doesnot support browserType ${browserType}`);
+      }
+      this.#puppeteer = plugin;
+    } else if (browserControllerType === "playwright") {
+      if (!PlaywrightBrowser.doesSupport(browserType)) {
+        throw new Error(`BrowserControllerType ${browserControllerType} doesnot support browserType ${browserType}`);
+      }
+      switch (browserType) {
+        case "chromium":
+        case "firefox":
+        case "webkit":
+          this.#playwrightBrowserTypes[browserType] = plugin;
+          break;
+        default:
+          unreachable7(browserType);
+      }
+    } else if (browserControllerType === "patchright") {
+      if (!PatchrightBrowser.doesSupport(browserType)) {
+        throw new Error(`BrowserControllerType ${browserControllerType} doesnot support browserType ${browserType}`);
+      }
+      switch (browserType) {
+        case "chromium":
+        case "firefox":
+        case "webkit":
+          this.#patchrightBrowserTypes[browserType] = plugin;
+          break;
+        default:
+          unreachable7(browserType);
+      }
+    } else {
+      unreachable7(browserControllerType);
+    }
+    return true;
+  }
+  async launch(browserControllerType, browserType, options) {
+    let {
       closeFreePagesIntervalSeconds = 300,
       maxBrowserContextsPerBrowser = 10,
       maxPagesPerBrowserContext = 20,
@@ -3765,6 +5776,47 @@ var LsdBrowserController = class _LsdBrowserController {
         const browser = await playwrightBrowserType.launch(launchOptions);
         lsdBrowser = new PlaywrightBrowser(browser, browserType, "launch", actOptions, this.#nextBrowserIdx++, browserPid);
       }
+    } else if (browserControllerType === "patchright") {
+      const launchOptions = { headless, timeout };
+      if (executablePath) {
+        launchOptions.executablePath = executablePath;
+      }
+      if (maxWindowSize) {
+        args.push("--start-maximized");
+      }
+      if (proxy?.proxyUrl && proxy.proxyUrl !== "local") {
+        const { proxyUrl: server, username, password } = proxy;
+        launchOptions.proxy = { server, username, password };
+      } else if (proxyPerBrowserContext && browserType === "chromium" && this.#osPlatform.startsWith("win")) {
+        launchOptions.proxy = { server: "proxyPerBrowserContext" };
+      }
+      if (browserType === "chromium") {
+        if (incognito) {
+          args.push("--incognito");
+        } else if (userDataDir) {
+          args.push(`--user-data-dir=${userDataDir}`);
+        }
+      }
+      if (args.length > 0) {
+        launchOptions.args = args;
+      }
+      const patchrightBrowserType = this.#patchrightBrowserType(browserType);
+      if (!actOptions.executablePath) {
+        actOptions.executablePath = patchrightBrowserType.executablePath();
+      }
+      if (options.launchMethod === "launchServer") {
+        const browserServer = await patchrightBrowserType.launchServer(launchOptions);
+        const process = browserServer.process();
+        if (process?.pid) {
+          browserPid = process.pid;
+        }
+        const wsEndpoint = browserServer.wsEndpoint();
+        const browser = await patchrightBrowserType.connect(wsEndpoint);
+        lsdBrowser = new PatchrightBrowser(browser, browserType, "launch", actOptions, this.#nextBrowserIdx++, browserPid);
+      } else {
+        const browser = await patchrightBrowserType.launch(launchOptions);
+        lsdBrowser = new PatchrightBrowser(browser, browserType, "launch", actOptions, this.#nextBrowserIdx++, browserPid);
+      }
     } else if (browserControllerType === "puppeteer") {
       const product = this.#puppeteerProduct(browserType);
       const launchOptions = { headless, timeout, product };
@@ -3843,6 +5895,11 @@ var LsdBrowserController = class _LsdBrowserController {
       const browser = await playwrightBrowserType.connectOverCDP(browserUrl);
       const lsdBrowser = new PlaywrightBrowser(browser, browserType, "connect", actOptions, this.#nextBrowserIdx++, browserPid);
       return lsdBrowser;
+    } else if (browserControllerType === "patchright") {
+      const patchrightBrowserType = this.#patchrightBrowserType(browserType, true);
+      const browser = await patchrightBrowserType.connectOverCDP(browserUrl);
+      const lsdBrowser = new PatchrightBrowser(browser, browserType, "connect", actOptions, this.#nextBrowserIdx++, browserPid);
+      return lsdBrowser;
     } else if (browserControllerType === "puppeteer") {
       this.#puppeteerProduct(browserType);
       const browser = await this.#puppeteer.connect({ browserURL: browserUrl });
@@ -3855,7 +5912,7 @@ var LsdBrowserController = class _LsdBrowserController {
   }
   async newApiContext(options = {}) {
     const { proxy, stateData, userAgent, timeout, ignoreHTTPSErrors, extraHTTPHeaders, httpCredentials } = options;
-    const apiRequestContext = await apiRequest.newContext({
+    const apiRequestContext = await apiRequestInPlaywright.newContext({
       proxy: proxy ? { server: proxy.proxyUrl, username: proxy.username, password: proxy.password } : void 0,
       storageState: stateData ? { cookies: stateData.cookies, origins: stateData.localStorage } : void 0,
       userAgent,