@skrillex1224/playwright-toolkit 2.1.285 → 3.0.1

package/dist/index.cjs

@@ -66,7 +66,7 @@ var Device = Object.freeze({
 });
 var Mode = Object.freeze({
   Default: "default",
-  CloakBrowser: "cloakbrowser"
+  Cloak: "cloak"
 });
 var normalizeDevice = (value, fallback = Device.Desktop) => {
   const normalizedFallback = String(fallback || "").trim().toLowerCase() === Device.Mobile ? Device.Mobile : Device.Desktop;
@@ -76,9 +76,9 @@ var normalizeDevice = (value, fallback = Device.Desktop) => {
   return normalizedFallback;
 };
 var normalizeMode = (value, fallback = Mode.Default) => {
-  const normalizedFallback = String(fallback || "").trim().toLowerCase() === Mode.CloakBrowser ? Mode.CloakBrowser : Mode.Default;
+  const normalizedFallback = String(fallback || "").trim().toLowerCase() === Mode.Cloak ? Mode.Cloak : Mode.Default;
   const raw = String(value || "").trim().toLowerCase();
-  if (raw === Mode.CloakBrowser) return Mode.CloakBrowser;
+  if (raw === Mode.Cloak) return Mode.Cloak;
   if (raw === Mode.Default) return Mode.Default;
   return normalizedFallback;
 };
@@ -2509,35 +2509,59 @@ var setToolkitMode = (mode = Mode.Default) => ToolkitContext.setMode(mode);
 var resolveModeStrategy = (strategies = {}, mode = getToolkitMode(), fallbackMode = Mode.Default) => {
   const normalizedStrategies = normalizeStrategies(strategies);
   const normalizedMode = normalizeMode(mode, fallbackMode);
-  const delegate = normalizedStrategies[normalizedMode] ?? normalizedStrategies[fallbackMode] ?? Object.values(normalizedStrategies).find(Boolean) ?? null;
+  const strategy = normalizedStrategies[normalizedMode] ?? normalizedStrategies[fallbackMode] ?? Object.values(normalizedStrategies).find(Boolean) ?? null;
   return {
     mode: normalizedMode,
-    delegate
+    strategy
   };
 };
 
-// src/internals/delegate.js
-var normalizeMethodDefinition = (definition) => typeof definition === "string" ? { name: definition, enumerable: true } : {
-  name: String(definition?.name || "").trim(),
-  enumerable: definition?.enumerable !== false
+// src/internals/reflect.js
+var normalizeStrategies2 = (strategies) => strategies && typeof strategies === "object" ? strategies : {};
+var collectFunctionNames = (strategies = []) => {
+  const names = /* @__PURE__ */ new Set();
+  for (const strategy of strategies) {
+    if (!strategy || typeof strategy !== "object") continue;
+    for (const name of Reflect.ownKeys(strategy)) {
+      if (typeof name === "string" && typeof strategy[name] === "function") {
+        names.add(name);
+      }
+    }
+  }
+  return names;
 };
-var createMethodDescriptor = (namespace, methodName, enumerable, strategies) => ({
-  enumerable,
+var methodDescriptor = (namespace, name, resolveTarget) => ({
+  enumerable: true,
+  configurable: true,
+  writable: true,
   value: (...args) => {
-    const { mode, delegate } = resolveModeStrategy(strategies);
-    if (typeof delegate?.[methodName] !== "function") {
-      throw new Error(`${namespace}.${methodName} is not available in ${mode} mode`);
+    const { mode, strategy } = resolveTarget(args);
+    const method = strategy?.[name];
+    if (typeof method !== "function") {
+      throw new Error(`${namespace}.${name} is not available in ${mode} mode`);
     }
-    return delegate[methodName](...args);
+    return method.apply(strategy, args);
   }
 });
-var createDelegatedFacade = (namespace, strategies = {}, methods = []) => {
-  const descriptors = Object.fromEntries(
-    methods.map(normalizeMethodDefinition).filter((method) => method.name).map((method) => [
-      method.name,
-      createMethodDescriptor(namespace, method.name, method.enumerable, strategies)
-    ])
-  );
+var withModeReflect = (namespace, strategies = {}) => {
+  const normalizedStrategies = normalizeStrategies2(strategies);
+  const baseStrategy = normalizedStrategies.default ?? Object.values(normalizedStrategies).find(Boolean);
+  const names = collectFunctionNames([baseStrategy]);
+  const descriptors = {};
+  for (const name of names) {
+    descriptors[name] = methodDescriptor(namespace, name, () => resolveModeStrategy(normalizedStrategies));
+  }
+  return Object.defineProperties({}, descriptors);
+};
+var withPageReflect = (namespace, resolveStrategy, strategies = []) => {
+  const names = collectFunctionNames(strategies);
+  const descriptors = {};
+  for (const name of names) {
+    descriptors[name] = methodDescriptor(namespace, name, ([page]) => ({
+      mode: "page",
+      strategy: resolveStrategy(page)
+    }));
+  }
   return Object.defineProperties({}, descriptors);
 };
 
@@ -2613,8 +2637,8 @@ var DefaultAntiCheat = {
   }
 };
 
-// src/internals/anti-cheat/cloakbrowser.js
-var CLOAK_BROWSER_BASE_CONFIG = Object.freeze({
+// src/internals/anti-cheat/cloak.js
+var CLOAK_BASE_CONFIG = Object.freeze({
   locale: "",
   acceptLanguage: "",
   timezoneId: "",
@@ -2622,12 +2646,12 @@ var CLOAK_BROWSER_BASE_CONFIG = Object.freeze({
   geolocation: null
 });
 var normalizeHeaders = (headers) => headers && typeof headers === "object" ? headers : {};
-var CloakBrowserAntiCheat = {
+var CloakAntiCheat = {
   /**
-   * CloakBrowser 自身会负责浏览器指纹，toolkit 在该模式下尽量不再注入额外反检测配置。
+   * Cloak 自身会负责浏览器指纹，toolkit 在该模式下尽量不再注入额外反检测配置。
    */
   getBaseConfig() {
-    return { ...CLOAK_BROWSER_BASE_CONFIG };
+    return { ...CLOAK_BASE_CONFIG };
   },
   getFingerprintGeneratorOptions() {
     return {};
@@ -2650,15 +2674,9 @@ var CloakBrowserAntiCheat = {
 // src/anti-cheat.js
 var antiCheatStrategies = {
   [Mode.Default]: DefaultAntiCheat,
-  [Mode.CloakBrowser]: CloakBrowserAntiCheat
-};
-var AntiCheat = createDelegatedFacade("AntiCheat", antiCheatStrategies, [
-  "getBaseConfig",
-  "getFingerprintGeneratorOptions",
-  "getLaunchArgs",
-  "getTlsFingerprintOptions",
-  "applyLocaleHeaders"
-]);
+  [Mode.Cloak]: CloakAntiCheat
+};
+var AntiCheat = withModeReflect("AntiCheat", antiCheatStrategies);
 
 // src/device-input.js
 var resolveDeviceFromPage = (page) => normalizeDevice(page?.[PageRuntimeStateKey]?.device);
@@ -3210,6 +3228,9 @@ var DeviceView = {
   }
 };
 
+// src/internals/humanize/index.js
+var import_delay4 = __toESM(require("delay"), 1);
+
 // src/internals/humanize/desktop.js
 var import_delay2 = __toESM(require("delay"), 1);
 var import_ghost_cursor_playwright = require("ghost-cursor-playwright");
@@ -4679,217 +4700,85 @@ var resolveDeviceFromPage2 = (page) => normalizeDevice(page?.[PageRuntimeStateKe
 var resolveDelegate = (page) => {
   return resolveDeviceFromPage2(page) === Device.Mobile ? MobileHumanize : Humanize;
 };
-var callDelegate = (method, page, args) => {
-  const delegate = resolveDelegate(page);
-  return delegate[method](page, ...args);
-};
-var DefaultHumanize = {
-  jitterMs(base, jitterPercent = 0.3) {
-    return Humanize.jitterMs(base, jitterPercent);
-  },
-  initializeCursor(page) {
-    return callDelegate("initializeCursor", page, []);
-  },
-  humanMove(page, target) {
-    return callDelegate("humanMove", page, [target]);
-  },
-  humanScroll(page, target, options = {}) {
-    return callDelegate("humanScroll", page, [target, options]);
-  },
-  humanClick(page, target, options = {}) {
-    return callDelegate("humanClick", page, [target, options]);
-  },
-  randomSleep(pageOrBaseMs, maybeBaseMs, maybeJitterPercent) {
-    if (pageOrBaseMs && typeof pageOrBaseMs === "object" && typeof pageOrBaseMs.evaluate === "function") {
-      const delegate = resolveDelegate(pageOrBaseMs);
-      return delegate.randomSleep(maybeBaseMs, maybeJitterPercent);
-    }
-    return Humanize.randomSleep(pageOrBaseMs, maybeBaseMs);
-  },
-  simulateGaze(page, baseDurationMs = 2500) {
-    return callDelegate("simulateGaze", page, [baseDurationMs]);
-  },
-  humanType(page, selector, text, options = {}) {
-    return callDelegate("humanType", page, [selector, text, options]);
-  },
-  humanPress(page, targetOrKey, maybeKey, options = {}) {
-    if (typeof maybeKey === "string") {
-      return callDelegate("humanPress", page, [targetOrKey, maybeKey, options]);
-    }
-    return callDelegate("humanPress", page, [targetOrKey, maybeKey || options]);
-  },
-  humanClear(page, selector) {
-    return callDelegate("humanClear", page, [selector]);
-  },
-  warmUpBrowsing(page, baseDuration = 3500) {
-    return callDelegate("warmUpBrowsing", page, [baseDuration]);
-  },
-  naturalScroll(page, direction = "down", distance = 300, baseSteps = 5) {
-    return callDelegate("naturalScroll", page, [direction, distance, baseSteps]);
-  }
-};
+var DefaultHumanizeDevice = withPageReflect(
+  "DefaultHumanize",
+  resolveDelegate,
+  [Humanize, MobileHumanize]
+);
 
-// src/internals/humanize/cloakbrowser.js
-var import_delay4 = __toESM(require("delay"), 1);
-var resolveDeviceFromPage3 = (page) => normalizeDevice(page?.[PageRuntimeStateKey]?.device);
-var isMobilePage = (page) => resolveDeviceFromPage3(page) === Device.Mobile;
-var isPageLike2 = (value) => value && typeof value === "object" && typeof value.evaluate === "function";
-var isPoint2 = (value) => value && typeof value === "object" && Number.isFinite(Number(value.x)) && Number.isFinite(Number(value.y));
-var resolveTarget = (page, target) => typeof target === "string" ? page.locator(target).first() : target;
-var sleep = (base, jitter = 0.3) => (0, import_delay4.default)(jitterMs(base, jitter));
-var FORCE_OPTIONS = Object.freeze({ force: true });
-var DesktopCloakHumanize = {
-  jitterMs(base, jitterPercent = 0.3) {
-    return jitterMs(base, jitterPercent);
-  },
+// src/internals/humanize/cloak.js
+var FORCE_CLICK = Object.freeze({
+  forceClick: true,
+  clickOptions: { force: true }
+});
+var pointOrNull = async (target) => {
+  if (!target || typeof target.boundingBox !== "function") return null;
+  const box = await target.boundingBox().catch(() => null);
+  return box ? { x: box.x + box.width / 2, y: box.y + box.height / 2 } : null;
+};
+var CloakHumanizeInput = {
   async initializeCursor(page) {
     return Boolean(page);
   },
   async humanMove(page, target) {
-    if (target == null) return false;
-    if (isPoint2(target)) {
-      await page.mouse.move(Number(target.x), Number(target.y));
-      return true;
-    }
-    await resolveTarget(page, target).hover(FORCE_OPTIONS);
-    return true;
+    const point = target?.x != null && target?.y != null ? target : await pointOrNull(typeof target === "string" ? page.locator(target).first() : target);
+    return point ? await DeviceInput.move(page, point, { forceMouse: true }) : false;
   },
   async humanScroll(page, target) {
-    const element = resolveTarget(page, target);
+    const element = typeof target === "string" ? page.locator(target).first() : target;
     if (!element) return { element: null, didScroll: false, restore: null };
     await element.scrollIntoViewIfNeeded?.();
     return { element, didScroll: true, restore: null };
   },
   async humanClick(page, target) {
-    if (target == null) {
-      await page.mouse.click(0, 0);
-      return true;
-    }
-    if (isPoint2(target)) {
-      await page.mouse.click(Number(target.x), Number(target.y));
-      return true;
-    }
-    if (typeof target === "string") {
-      await page.click(target, FORCE_OPTIONS);
-      return true;
-    }
-    await target.click(FORCE_OPTIONS);
-    return true;
-  },
-  async randomSleep(baseMs, jitterPercent = 0.3) {
-    await sleep(baseMs, jitterPercent);
-  },
-  async simulateGaze(page, baseDurationMs = 2500) {
-    const durationMs = jitterMs(baseDurationMs, 0.4);
-    const startedAt = Date.now();
-    const viewport = page.viewportSize() || { width: 1365, height: 900 };
-    while (Date.now() - startedAt < durationMs) {
-      await page.mouse.move(
-        100 + Math.random() * Math.max(120, viewport.width - 200),
-        100 + Math.random() * Math.max(120, viewport.height - 200)
-      );
-      await sleep(300, 0.5);
-    }
+    return await DeviceInput.click(page, target, FORCE_CLICK);
   },
   async humanType(page, selector, text) {
-    const target = resolveTarget(page, selector);
-    await target.click(FORCE_OPTIONS);
-    await page.keyboard.type(text);
+    await DeviceInput.click(page, selector, FORCE_CLICK);
+    return await DeviceInput.keyboardType(page, text);
   },
   async humanPress(page, targetOrKey, maybeKey) {
-    if (typeof maybeKey !== "string") {
-      await page.keyboard.press(targetOrKey);
-      return true;
-    }
-    await resolveTarget(page, targetOrKey).click(FORCE_OPTIONS);
-    await page.keyboard.press(maybeKey);
-    return true;
+    return await DeviceInput.press(page, targetOrKey, maybeKey, {
+      clickOptions: FORCE_CLICK,
+      keyboardOptions: {}
+    });
   },
   async humanClear(page, selector) {
-    if (typeof selector === "string") {
-      await page.fill(selector, "", FORCE_OPTIONS);
-      return;
-    }
-    await selector.fill("", FORCE_OPTIONS);
+    return await DeviceInput.fill(page, selector, "", { force: true });
   },
-  async warmUpBrowsing(page, baseDuration = 3500) {
-    await this.simulateGaze(page, Math.min(baseDuration, 900));
+  async simulateGaze(page) {
+    return await DeviceInput.move(page, { x: 0, y: 0 }, { forceMouse: true });
   },
-  async naturalScroll(page, direction = "down", distance = 300, baseSteps = 5) {
-    const steps = Math.max(1, Number(baseSteps) || 1);
-    const delta = (Number(distance) || 0) / steps * (direction === "down" ? 1 : -1);
-    for (let index = 0; index < steps; index += 1) {
-      await page.mouse.wheel(0, delta);
-      await sleep(60 + index * 20, 0.3);
-    }
+  async warmUpBrowsing(page) {
+    return await this.simulateGaze(page);
+  },
+  async naturalScroll(page, direction = "down", distance = 300) {
+    const sign = direction === "down" ? 1 : -1;
+    await page.mouse.wheel(0, Number(distance || 0) * sign);
   }
 };
-var resolveDelegate2 = (page) => isMobilePage(page) ? MobileHumanize : DesktopCloakHumanize;
-var callDelegate2 = (method, page, args) => resolveDelegate2(page)[method](page, ...args);
-var CloakBrowserHumanize = {
+
+// src/internals/humanize/index.js
+var HumanizeCommon = {
   jitterMs(base, jitterPercent = 0.3) {
     return jitterMs(base, jitterPercent);
   },
-  initializeCursor(page) {
-    return callDelegate2("initializeCursor", page, []);
-  },
-  humanMove(page, target) {
-    return callDelegate2("humanMove", page, [target]);
-  },
-  humanScroll(page, target, options = {}) {
-    return callDelegate2("humanScroll", page, [target, options]);
-  },
-  humanClick(page, target, options = {}) {
-    return callDelegate2("humanClick", page, [target, options]);
-  },
-  randomSleep(pageOrBaseMs, maybeBaseMs, maybeJitterPercent) {
-    if (isPageLike2(pageOrBaseMs)) {
-      return resolveDelegate2(pageOrBaseMs).randomSleep(maybeBaseMs, maybeJitterPercent);
-    }
-    return DesktopCloakHumanize.randomSleep(pageOrBaseMs, maybeBaseMs);
-  },
-  simulateGaze(page, baseDurationMs = 2500) {
-    return callDelegate2("simulateGaze", page, [baseDurationMs]);
-  },
-  humanType(page, selector, text, options = {}) {
-    return callDelegate2("humanType", page, [selector, text, options]);
-  },
-  humanPress(page, targetOrKey, maybeKey, options = {}) {
-    if (typeof maybeKey === "string") {
-      return callDelegate2("humanPress", page, [targetOrKey, maybeKey, options]);
-    }
-    return callDelegate2("humanPress", page, [targetOrKey, maybeKey || options]);
-  },
-  humanClear(page, selector) {
-    return callDelegate2("humanClear", page, [selector]);
-  },
-  warmUpBrowsing(page, baseDuration = 3500) {
-    return callDelegate2("warmUpBrowsing", page, [baseDuration]);
-  },
-  naturalScroll(page, direction = "down", distance = 300, baseSteps = 5) {
-    return callDelegate2("naturalScroll", page, [direction, distance, baseSteps]);
+  async randomSleep(pageOrBaseMs, maybeBaseMs, maybeJitterPercent) {
+    const hasPage = pageOrBaseMs && typeof pageOrBaseMs === "object" && typeof pageOrBaseMs.evaluate === "function";
+    const baseMs = hasPage ? maybeBaseMs : pageOrBaseMs;
+    const jitterPercent = hasPage ? maybeJitterPercent : maybeBaseMs;
+    await (0, import_delay4.default)(jitterMs(baseMs, jitterPercent ?? 0.3));
   }
 };
+var DefaultHumanize = Object.assign({}, DefaultHumanizeDevice, HumanizeCommon);
+var CloakHumanize = Object.assign({}, CloakHumanizeInput, HumanizeCommon);
 
 // src/humanize.js
 var humanizeStrategies = {
   [Mode.Default]: DefaultHumanize,
-  [Mode.CloakBrowser]: CloakBrowserHumanize
-};
-var Humanize2 = createDelegatedFacade("Humanize", humanizeStrategies, [
-  "jitterMs",
-  "initializeCursor",
-  "humanMove",
-  "humanScroll",
-  "humanClick",
-  "randomSleep",
-  "simulateGaze",
-  "humanType",
-  "humanPress",
-  "humanClear",
-  "warmUpBrowsing",
-  "naturalScroll"
-]);
+  [Mode.Cloak]: CloakHumanize
+};
+var Humanize2 = withModeReflect("Humanize", humanizeStrategies);
 
 // src/internals/launch/default.js
 var import_node_child_process = require("node:child_process");
@@ -5327,10 +5216,10 @@ var DefaultLaunch = {
   }
 };
 
-// src/internals/launch/cloakbrowser.js
+// src/internals/launch/cloak.js
 var import_node_child_process2 = require("node:child_process");
 var import_node_util = require("node:util");
-var logger8 = createInternalLogger("CloakBrowser");
+var logger8 = createInternalLogger("Cloak");
 var execFileAsync = (0, import_node_util.promisify)(import_node_child_process2.execFile);
 var DEFAULT_CLOAK_CRAWLER_BASE_OPTIONS = Object.freeze({
   maxConcurrency: 1,
@@ -5344,21 +5233,21 @@ var DEFAULT_CLOAK_HUMANIZE_OPTIONS = Object.freeze({
 var DEFAULT_CLOAK_GOTO_OPTIONS = Object.freeze({
   waitUntil: "commit"
 });
-var cachedCloakBrowserModulePromise = null;
+var cachedCloakModulePromise = null;
 var hasOwn = (target, key) => Object.prototype.hasOwnProperty.call(target, key);
-var loadCloakBrowserModule = async () => {
-  if (!cachedCloakBrowserModulePromise) {
-    cachedCloakBrowserModulePromise = import("cloakbrowser").catch((error) => {
-      cachedCloakBrowserModulePromise = null;
-      throw new Error("cloakbrowser \u6A21\u5757\u52A0\u8F7D\u5931\u8D25\uFF0C\u8BF7\u786E\u8BA4\u5F53\u524D\u8FD0\u884C\u73AF\u5883\u5DF2\u5B89\u88C5 cloakbrowser\u3002", {
+var loadCloakModule = async () => {
+  if (!cachedCloakModulePromise) {
+    cachedCloakModulePromise = import("cloakbrowser").catch((error) => {
+      cachedCloakModulePromise = null;
+      throw new Error("Cloak \u6A21\u5757\u52A0\u8F7D\u5931\u8D25\uFF0C\u8BF7\u786E\u8BA4\u5F53\u524D\u8FD0\u884C\u73AF\u5883\u5DF2\u5B89\u88C5 cloakbrowser\u3002", {
         cause: error
       });
     });
   }
-  return cachedCloakBrowserModulePromise;
+  return cachedCloakModulePromise;
 };
 var buildCloakLaunchOptions = async (options = {}) => {
-  const { buildLaunchOptions } = await loadCloakBrowserModule();
+  const { buildLaunchOptions } = await loadCloakModule();
   return await buildLaunchOptions(normalizeObject(options));
 };
 var normalizeObject = (value) => {
@@ -5373,7 +5262,7 @@ var normalizeStringArray = (value) => {
   }
   return value.map((item) => String(item || "").trim()).filter(Boolean);
 };
-var resolveCloakBrowserProxy = (proxyConfiguration = {}) => {
+var resolveCloakProxy = (proxyConfiguration = {}) => {
   const config = normalizeObject(proxyConfiguration);
   const proxyUrl = String(config.proxy_url || "").trim();
   const enableProxy = typeof config.enable_proxy === "boolean" ? config.enable_proxy : proxyUrl !== "";
@@ -5407,7 +5296,7 @@ var createStableGotoHook = (recommendedGotoOptions = DEFAULT_CLOAK_GOTO_OPTIONS)
     }
   };
 };
-var attachCloakBrowserHumanizeHook = ({
+var attachCloakHumanizeHook = ({
   browserPoolOptions = {},
   activeBrowsers,
   patchedBrowsers,
@@ -5438,7 +5327,7 @@ var attachCloakBrowserHumanizeHook = ({
         if (!shouldHumanize || patchedBrowsers.has(browser)) {
           return;
         }
-        const { humanizeBrowser } = await loadCloakBrowserModule();
+        const { humanizeBrowser } = await loadCloakModule();
         await humanizeBrowser(browser, normalizedHumanizeOptions);
         patchedBrowsers.add(browser);
       }
@@ -5466,12 +5355,12 @@ var forceTerminateBrowsersByFingerprintArg = async (fingerprintArg) => {
     if (error?.code === 1 || error?.code === "ENOENT") {
       return;
     }
-    logger8.info(`\u5F3A\u5236\u5173\u95ED CloakBrowser \u8FDB\u7A0B\u5931\u8D25\uFF08\u5FFD\u7565\uFF09: ${error?.message || String(error)}`);
+    logger8.info(`\u5F3A\u5236\u5173\u95ED Cloak \u8FDB\u7A0B\u5931\u8D25\uFF08\u5FFD\u7565\uFF09: ${error?.message || String(error)}`);
   });
 };
-var CloakBrowserLaunch = {
+var CloakLaunch = {
   resolveProxyConfiguration(proxyConfiguration = {}) {
-    return resolveCloakBrowserProxy(proxyConfiguration);
+    return resolveCloakProxy(proxyConfiguration);
   },
   extractFingerprintArg(launchOptions = {}) {
     return extractFingerprintArg(launchOptions);
@@ -5480,7 +5369,7 @@ var CloakBrowserLaunch = {
     return createStableGotoHook(recommendedGotoOptions);
   },
   async getPlaywrightCrawlerOptions(options = {}) {
-    const runtime2 = await CloakBrowserLaunch.createPlaywrightCrawlerRuntime(options);
+    const runtime2 = await CloakLaunch.createPlaywrightCrawlerRuntime(options);
     return Object.defineProperties(runtime2.crawlerOptions, {
       cleanup: {
         enumerable: false,
@@ -5520,7 +5409,7 @@ var CloakBrowserLaunch = {
     const patchedBrowsers = /* @__PURE__ */ new WeakSet();
     const defaultArgs = isRunningOnApify ? ["--no-sandbox", "--disable-setuid-sandbox"] : [];
     const extraArgs = normalizeStringArray(normalizedCloakOptions.args);
-    const proxy = hasOwn(normalizedCloakOptions, "proxy") ? normalizedCloakOptions.proxy : resolveCloakBrowserProxy(proxyConfiguration);
+    const proxy = hasOwn(normalizedCloakOptions, "proxy") ? normalizedCloakOptions.proxy : resolveCloakProxy(proxyConfiguration);
     const headless = hasOwn(normalizedCloakOptions, "headless") ? normalizedCloakOptions.headless : !runInHeadfulMode || isRunningOnApify;
     const mergedCloakOptions = {
       ...normalizedCloakOptions,
@@ -5543,7 +5432,7 @@ var CloakBrowserLaunch = {
         ...launcher ? { launcher } : {},
         launchOptions
       },
-      browserPoolOptions: attachCloakBrowserHumanizeHook({
+      browserPoolOptions: attachCloakHumanizeHook({
         browserPoolOptions,
         activeBrowsers,
         patchedBrowsers,
@@ -5577,11 +5466,9 @@ var CloakBrowserLaunch = {
 // src/launch.js
 var launchStrategies = {
   [Mode.Default]: DefaultLaunch,
-  [Mode.CloakBrowser]: CloakBrowserLaunch
+  [Mode.Cloak]: CloakLaunch
 };
-var Launch = createDelegatedFacade("Launch", launchStrategies, [
-  "getPlaywrightCrawlerOptions"
-]);
+var Launch = withModeReflect("Launch", launchStrategies);
 
 // src/live-view.js
 var import_express = __toESM(require("express"), 1);
@@ -6670,7 +6557,7 @@ var Mutation = {
     const overallTimeout = options.timeout ?? 180 * 1e3;
     const onMutation = options.onMutation;
     const pollInterval = 500;
-    const sleep2 = (ms) => new Promise((resolve) => {
+    const sleep = (ms) => new Promise((resolve) => {
       setTimeout(resolve, ms);
     });
     const truncate = (value, max = 800) => {
@@ -6862,7 +6749,7 @@ var Mutation = {
     const deadline = Date.now() + overallTimeout;
     let lastState = state2;
     while (Date.now() < deadline) {
-      await sleep2(pollInterval);
+      await sleep(pollInterval);
       lastState = await buildState();
       if (!lastState?.hasMatched) {
         continue;
@@ -8447,7 +8334,7 @@ var buildWatermarkifyRenderHtml = ({ imageSrc, overlaySvg, width, height, imageH
     `;
 };
 var normalizeWatermarkifyRenderMode = (value) => {
-  return String(value || "default").trim().toLowerCase() === "cloakbrowser" ? "cloakbrowser" : "default";
+  return String(value || "default").trim().toLowerCase() === "cloak" ? "cloak" : "default";
 };
 var composeScreenshotBufferWithBrowser = async (page, buffer, overlaySvg, imageInfo = {}, options = {}) => {
   if (!page || typeof page.context !== "function") {
@@ -8474,7 +8361,7 @@ var composeScreenshotBufferWithBrowser = async (page, buffer, overlaySvg, imageI
     }).catch(() => {
     });
     const renderMode = normalizeWatermarkifyRenderMode(options.mode);
-    if (renderMode === "cloakbrowser") {
+    if (renderMode === "cloak") {
       const renderHtml = buildWatermarkifyRenderHtml({
         imageSrc: `data:${imageInfo.mimeType || "image/png"};base64,${buffer.toString("base64")}`,
         overlaySvg,
@@ -10055,7 +9942,7 @@ var Share = {
    * @param {number} [options.maxBytes] 默认 5MiB，返回 base64 超过后会压缩
    * @param {'jpeg'|'jpg'} [options.type] 压缩输出格式，默认 jpeg
    * @param {boolean|Object} [options.compression] 传 false 可关闭压缩
-   * @param {'default'|'cloakbrowser'} [options.mode] 截图水印合成模式，默认 default
+   * @param {'default'|'cloak'} [options.mode] 截图水印合成模式，默认 default
    * @returns {Promise<string>} base64 image
    */
   async captureScreen(page, options = {}) {
@@ -10077,7 +9964,7 @@ var Share = {
         capturedAt
       });
       outputBuffer = await watermarkifyScreenshotBuffer(rawBuffer, watermarkifyMeta, page, {
-        mode: options.mode === "cloakbrowser" ? "cloakbrowser" : "default"
+        mode: options.mode
       });
     }
     return await compressImageBufferToBase64(outputBuffer, compression);