@letsscrapedata/controller 0.0.52 → 0.0.53

package/dist/index.cjs

@@ -1650,7 +1650,11 @@ var PlaywrightBrowserContext = class extends import_node_events2.default {
 };
 
 // src/playwright/browser.ts
-var PlaywrightBrowser = class extends import_node_events3.default {
+var PlaywrightBrowser = class _PlaywrightBrowser extends import_node_events3.default {
+  static #supportedBrowserTypes = ["chromium", "firefox", "webkit"];
+  static doesSupport(browserType) {
+    return _PlaywrightBrowser.#supportedBrowserTypes.includes(browserType);
+  }
   #browser;
   #browserIdx;
   #pid;
@@ -1679,7 +1683,7 @@ var PlaywrightBrowser = class extends import_node_events3.default {
     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`);
     }
@@ -1691,7 +1695,10 @@ var PlaywrightBrowser = class extends import_node_events3.default {
     this.#createTime = (0, import_utils5.getCurrentUnixTime)();
     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;
@@ -3331,7 +3338,11 @@ var PuppeteerBrowserContext = class extends import_node_events5.default {
 };
 
 // src/puppeteer/browser.ts
-var PuppeteerBrowser = class extends import_node_events6.default {
+var PuppeteerBrowser = class _PuppeteerBrowser extends import_node_events6.default {
+  static #supportedBrowserTypes = ["chromium"];
+  static doesSupport(browserType) {
+    return _PuppeteerBrowser.#supportedBrowserTypes.includes(browserType);
+  }
   #browser;
   #browserIdx;
   #pid;
@@ -3363,7 +3374,7 @@ var PuppeteerBrowser = class extends import_node_events6.default {
     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`);
     }
@@ -3375,7 +3386,10 @@ var PuppeteerBrowser = class extends import_node_events6.default {
     this.#createTime = (0, import_utils9.getCurrentUnixTime)();
     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;
@@ -3871,148 +3885,1922 @@ var CheerioPage = class extends import_node_events7.default {
 var import_os = __toESM(require("os"), 1);
 var import_puppeteer = __toESM(require("puppeteer"), 1);
 var import_playwright = __toESM(require("playwright"), 1);
-var import_puppeteer_extra = __toESM(require("puppeteer-extra"), 1);
-var playwrightExtra = __toESM(require("playwright-extra"), 1);
-var import_puppeteer_extra_plugin_stealth = __toESM(require("puppeteer-extra-plugin-stealth"), 1);
+var import_patchright = __toESM(require("patchright"), 1);
+
+// src/patchright/browser.ts
+var import_node_events10 = __toESM(require("events"), 1);
+var import_utils13 = require("@letsscrapedata/utils");
+
+// src/patchright/context.ts
+var import_node_events9 = __toESM(require("events"), 1);
+var import_utils12 = require("@letsscrapedata/utils");
+
+// src/patchright/page.ts
+var import_node_events8 = __toESM(require("events"), 1);
+var import_utils11 = require("@letsscrapedata/utils");
+
+// src/patchright/element.ts
 var import_utils10 = require("@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!");
+var PatchrightElement = class _PatchrightElement {
+  #frame;
+  #locator;
+  constructor(locator, frame) {
+    if (!frame.locator || !locator.click) {
+      throw new Error("Invalid paras in new PatchrightElement");
     }
-    this.#puppeteer = import_puppeteer.default;
-    const { chromium: chromium2, firefox: firefox2, webkit: webkit2 } = import_playwright.default;
-    this.#playwrightBrowserTypes = { chromium: chromium2, firefox: firefox2, webkit: webkit2 };
-    this.#osPlatform = import_os.default.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 = import_puppeteer_extra.default.use((0, import_puppeteer_extra_plugin_stealth.default)());
+  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;
+  /*
+    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.chromium = playwrightExtra.chromium.use((0, import_puppeteer_extra_plugin_stealth.default)());
+          // src: RegExp
+          if (url.match(src)) {
+            return childFrame;
+          }
         }
-        break;
-      case "firefox":
-        if (playwrightBrowserType) {
-          this.#playwrightBrowserTypes.firefox = playwrightBrowserType;
-        } else {
-          this.#playwrightBrowserTypes.firefox = playwrightExtra.firefox.use((0, import_puppeteer_extra_plugin_stealth.default)());
+      }
+  
+      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;
-      case "webkit":
-        if (playwrightBrowserType) {
-          this.#playwrightBrowserTypes.webkit = playwrightBrowserType;
+        frameLocator = await this.#getChildFrameLocator(frameLocator, iframeOption);
+      }
+      return frameLocator;
+    } catch (err) {
+      throw new Error(`No child iframe: ${JSON.stringify(iframeOptions)}`);
+    }
+  }
+  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 {
-          this.#playwrightBrowserTypes.webkit = playwrightExtra.webkit.use((0, import_puppeteer_extra_plugin_stealth.default)());
+          locators = [this.#locator];
         }
-        break;
-      default:
-        (0, import_utils10.unreachable)(browserType);
+      }
+      retObj.locators = locators;
+      return retObj;
+    } catch (err) {
+      loginfo(err);
+      return retObj;
     }
-    return true;
   }
-  async launch(browserControllerType, browserType, options) {
-    let {
-      closeFreePagesIntervalSeconds = 300,
-      maxBrowserContextsPerBrowser = 10,
-      maxPagesPerBrowserContext = 20,
-      maxPageFreeSeconds = 900,
-      maxViewportOfNewPage = true,
-      proxy = null,
-      timeout = 3e4,
-      args = [],
-      executablePath = "",
-      maxWindowSize = true,
-      headless = true,
-      minBrowserContexts = 1,
-      // incognito
-      proxyPerBrowserContext = false,
-      userDataDir = "",
-      userAgent = ""
-    } = options ? options : {};
-    let browserPid = 0;
-    const incognito = typeof options?.incognito === "boolean" ? options.incognito : browserControllerType === "puppeteer" ? false : true;
-    const actOptions = { closeFreePagesIntervalSeconds, maxBrowserContextsPerBrowser, maxPagesPerBrowserContext, maxPageFreeSeconds, maxViewportOfNewPage, proxy, timeout, args, executablePath, maxWindowSize, headless, minBrowserContexts, incognito, proxyPerBrowserContext, userDataDir, userAgent };
-    let idx = args.findIndex((arg) => arg.toLowerCase().startsWith("--incoginto"));
-    if (idx >= 0) {
-      logwarn(`Please use options.incognito instead when launching new browser.`);
-      args.splice(idx, 1);
-    }
-    idx = args.findIndex((arg) => arg.toLowerCase().startsWith("--proxy-server"));
-    if (idx >= 0) {
-      logwarn(`Please use options.proxy instead when launching new browser.`);
-      args.splice(idx, 1);
+  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`);
     }
-    idx = args.findIndex((arg) => arg.toLowerCase().startsWith("--user-data-dir"));
-    if (idx >= 0) {
-      logwarn(`Please use options.userDataDir instead when launching new browser.`);
-      args.splice(idx, 1);
+    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;
+      }
     }
-    idx = args.findIndex((arg) => arg.toLowerCase().startsWith("--start-maximized"));
-    if (idx >= 0) {
-      logwarn(`Please use options.maxWindowSize instead when launching new browser.`);
-      args.splice(idx, 1);
+    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`);
     }
-    let lsdBrowser;
-    if (browserControllerType === "playwright") {
-      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" };
+    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;
       }
-      if (browserType === "chromium") {
-        if (incognito) {
-          args.push("--incognito");
-        } else if (userDataDir) {
-          args.push(`--user-data-dir=${userDataDir}`);
+    }
+    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 {
+      (0, import_utils10.unreachable)(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:
+        (0, import_utils10.unreachable)(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 import_node_events8.default {
+  #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 = (0, import_utils11.getCurrentUnixTime)();
+    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:
+          (0, import_utils11.unreachable)(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:
+                  (0, import_utils11.unreachable)(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 import_node_events9.default {
+  #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 = (0, import_utils12.getCurrentUnixTime)();
+    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 = (0, import_utils12.getCurrentUnixTime)();
+    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 = (0, import_utils12.getCurrentUnixTime)();
+        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 = (0, import_utils12.getCurrentUnixTime)();
+      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 (0, import_utils12.sleep)(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 = (0, import_utils12.getCurrentUnixTime)() - 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 (0, import_utils12.sleep)(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 = (0, import_utils12.getCurrentUnixTime)();
+      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 (0, import_utils12.sleep)(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 = (0, import_utils12.getCurrentUnixTime)();
+      return true;
+    } else {
+      return false;
+    }
+  }
+  _origBrowserContext() {
+    return this.#browserContext;
+  }
+};
+
+// src/patchright/browser.ts
+var PatchrightBrowser = class _PatchrightBrowser extends import_node_events10.default {
+  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 = (0, import_utils13.getCurrentUnixTime)();
+    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 (0, import_utils13.getPerformanceOfPidTree)(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
+var import_utils14 = require("@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 = import_puppeteer.default;
+    this.#playwrightBrowserTypes = {
+      chromium: import_playwright.default.chromium,
+      firefox: import_playwright.default.firefox,
+      webkit: import_playwright.default.webkit
+    };
+    this.#patchrightBrowserTypes = {
+      chromium: import_patchright.default.chromium,
+      firefox: import_patchright.default.firefox,
+      webkit: import_patchright.default.webkit
+    };
+    this.#osPlatform = import_os.default.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:
+          (0, import_utils14.unreachable)(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:
+          (0, import_utils14.unreachable)(browserType);
+      }
+    } else {
+      (0, import_utils14.unreachable)(browserControllerType);
+    }
+    return true;
+  }
+  async launch(browserControllerType, browserType, options) {
+    let {
+      closeFreePagesIntervalSeconds = 300,
+      maxBrowserContextsPerBrowser = 10,
+      maxPagesPerBrowserContext = 20,
+      maxPageFreeSeconds = 900,
+      maxViewportOfNewPage = true,
+      proxy = null,
+      timeout = 3e4,
+      args = [],
+      executablePath = "",
+      maxWindowSize = true,
+      headless = true,
+      minBrowserContexts = 1,
+      // incognito
+      proxyPerBrowserContext = false,
+      userDataDir = "",
+      userAgent = ""
+    } = options ? options : {};
+    let browserPid = 0;
+    const incognito = typeof options?.incognito === "boolean" ? options.incognito : browserControllerType === "puppeteer" ? false : true;
+    const actOptions = { closeFreePagesIntervalSeconds, maxBrowserContextsPerBrowser, maxPagesPerBrowserContext, maxPageFreeSeconds, maxViewportOfNewPage, proxy, timeout, args, executablePath, maxWindowSize, headless, minBrowserContexts, incognito, proxyPerBrowserContext, userDataDir, userAgent };
+    let idx = args.findIndex((arg) => arg.toLowerCase().startsWith("--incoginto"));
+    if (idx >= 0) {
+      logwarn(`Please use options.incognito instead when launching new browser.`);
+      args.splice(idx, 1);
+    }
+    idx = args.findIndex((arg) => arg.toLowerCase().startsWith("--proxy-server"));
+    if (idx >= 0) {
+      logwarn(`Please use options.proxy instead when launching new browser.`);
+      args.splice(idx, 1);
+    }
+    idx = args.findIndex((arg) => arg.toLowerCase().startsWith("--user-data-dir"));
+    if (idx >= 0) {
+      logwarn(`Please use options.userDataDir instead when launching new browser.`);
+      args.splice(idx, 1);
+    }
+    idx = args.findIndex((arg) => arg.toLowerCase().startsWith("--start-maximized"));
+    if (idx >= 0) {
+      logwarn(`Please use options.maxWindowSize instead when launching new browser.`);
+      args.splice(idx, 1);
+    }
+    let lsdBrowser;
+    if (browserControllerType === "playwright") {
+      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) {
@@ -4035,6 +5823,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 };
@@ -4100,7 +5929,7 @@ var LsdBrowserController = class _LsdBrowserController {
     }
     const u = new URL(browserUrl);
     const port = u.port ? parseInt(u.port) : 80;
-    const pids = await (0, import_utils10.getPidsListeningOnPort)(port);
+    const pids = await (0, import_utils14.getPidsListeningOnPort)(port);
     let browserPid = 0;
     if (pids.length !== 1) {
       logerr(`##browser pids.length ${pids.length} is not 1 when trying to connect to browserUrl ${browserUrl}`);
@@ -4113,6 +5942,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 });