@skrillex1224/playwright-toolkit 2.1.224 → 2.1.225

package/dist/index.js

@@ -12,8 +12,10 @@ var constants_exports = {};
 __export(constants_exports, {
   ActorInfo: () => ActorInfo,
   Code: () => Code,
+  Device: () => Device,
   PresetOfLiveViewKey: () => PresetOfLiveViewKey,
-  Status: () => Status
+  Status: () => Status,
+  normalizeDevice: () => normalizeDevice
 });
 var Code = {
   Success: 0,
@@ -29,6 +31,17 @@ var Status = {
   Failed: "FAILED"
 };
 var PresetOfLiveViewKey = "LIVE_VIEW_SCREENSHOT";
+var Device = Object.freeze({
+  Desktop: "desktop",
+  Mobile: "mobile"
+});
+var normalizeDevice = (value, fallback = Device.Desktop) => {
+  const normalizedFallback = String(fallback || "").trim().toLowerCase() === Device.Mobile ? Device.Mobile : Device.Desktop;
+  const raw = String(value || "").trim().toLowerCase();
+  if (raw === Device.Mobile) return Device.Mobile;
+  if (raw === Device.Desktop) return Device.Desktop;
+  return normalizedFallback;
+};
 var createActorInfo = (info) => {
   const normalizeDomain = (value) => {
     if (!value) return "";
@@ -106,12 +119,14 @@ var createActorInfo = (info) => {
   const domain = normalizeDomain(info.domain);
   const path2 = normalizePath(info.path);
   const share = normalizeShare2(info.share);
+  const device = normalizeDevice(info.device);
   return {
     ...info,
     protocol,
     domain,
     path: path2,
     share,
+    device,
     get icon() {
       if (info.icon) return info.icon;
       return buildIcon(this);
@@ -163,6 +178,7 @@ var ActorInfo = {
     name: "\u8C46\u5305",
     domain: "www.doubao.com",
     path: "/",
+    device: Device.Mobile,
     share: {
       mode: "response",
       prefix: "https://www.doubao.com/thread/",
@@ -178,6 +194,7 @@ var ActorInfo = {
     name: "DeepSeek",
     domain: "chat.deepseek.com",
     path: "/",
+    device: Device.Mobile,
     share: {
       mode: "response",
       prefix: "https://chat.deepseek.com/share/",
@@ -334,18 +351,18 @@ var fallbackLog = {
   error: (...args) => console.error(...args),
   debug: (...args) => console.debug ? console.debug(...args) : console.log(...args)
 };
-var resolveLogMethod = (logger15, name) => {
-  if (logger15 && typeof logger15[name] === "function") {
-    return logger15[name].bind(logger15);
+var resolveLogMethod = (logger16, name) => {
+  if (logger16 && typeof logger16[name] === "function") {
+    return logger16[name].bind(logger16);
   }
-  if (name === "warning" && logger15 && typeof logger15.warn === "function") {
-    return logger15.warn.bind(logger15);
+  if (name === "warning" && logger16 && typeof logger16.warn === "function") {
+    return logger16.warn.bind(logger16);
   }
   return fallbackLog[name];
 };
 var defaultLogger = null;
-var setDefaultLogger = (logger15) => {
-  defaultLogger = logger15;
+var setDefaultLogger = (logger16) => {
+  defaultLogger = logger16;
 };
 var resolveLogger = (explicitLogger) => {
   if (explicitLogger && typeof explicitLogger.info === "function") {
@@ -372,8 +389,8 @@ var colorize = (text, color) => {
 var createBaseLogger = (prefix = "", explicitLogger) => {
   const name = prefix ? String(prefix) : "";
   const dispatch = (methodName, icon, message, color) => {
-    const logger15 = resolveLogger(explicitLogger);
-    const logFn = resolveLogMethod(logger15, methodName);
+    const logger16 = resolveLogger(explicitLogger);
+    const logFn = resolveLogMethod(logger16, methodName);
     const timestamp = colorize(`[${formatTimestamp()}]`, ANSI.gray);
     const line = formatLine(name, icon, message);
     const coloredLine = colorize(line, color);
@@ -972,6 +989,12 @@ var PageRuntimeStateKey = "__playwright_toolkit_runtime_state__";
 var BROWSER_PROFILE_SCHEMA_VERSION = 1;
 var rememberedRuntimeState = null;
 var isPlainObject = (value) => value && typeof value === "object" && !Array.isArray(value);
+var normalizeKnownDevice = (value) => {
+  const raw = String(value || "").trim().toLowerCase();
+  if (raw === Device.Mobile) return Device.Mobile;
+  if (raw === Device.Desktop) return Device.Desktop;
+  return "";
+};
 var deepClone = (value) => {
   if (value == null) return value;
   try {
@@ -1323,6 +1346,10 @@ var normalizeObservedBrowserProfile = (value) => {
 var normalizeBrowserProfileCore = (value) => {
   const source = isPlainObject(value) ? value : {};
   const profile = {};
+  const device = normalizeKnownDevice(source.device);
+  if (device) {
+    profile.device = device;
+  }
   if (isPlainObject(source.fingerprint) && Object.keys(source.fingerprint).length > 0) {
     profile.fingerprint = deepClone(source.fingerprint);
   }
@@ -1380,9 +1407,11 @@ var mergeBrowserProfilePayload = (target = {}, source = {}) => {
   if (Object.keys(mergedCore).length === 0 && Object.keys(incomingCore).length > 0) {
     mergedCore = incomingCore;
   } else if (Object.keys(incomingCore).length > 0) {
+    const currentDevice = normalizeKnownDevice(currentCore.device);
+    const incomingDevice = normalizeKnownDevice(incomingCore.device);
     const currentVersion = Number(currentCore.browser_major_version || 0);
     const incomingVersion = Number(incomingCore.browser_major_version || 0);
-    if (currentVersion > 0 && incomingVersion > 0 && currentVersion !== incomingVersion) {
+    if (incomingDevice && currentDevice !== incomingDevice || currentVersion > 0 && incomingVersion > 0 && currentVersion !== incomingVersion) {
       mergedCore = incomingCore;
     }
   }
@@ -1433,8 +1462,13 @@ var normalizeRuntimeState = (source = {}, actor = "") => {
   }
   return RuntimeEnv.parseInput(source, actor);
 };
+var resolveInputDevice = (input = {}, runtime2 = {}, actor = "") => {
+  const actorDevice = ActorInfo?.[actor]?.device;
+  return normalizeDevice(actorDevice ?? input?.device ?? runtime2?.device);
+};
 var RuntimeEnv = {
   tryParseJSON,
+  normalizeDevice,
   normalizeCookies,
   normalizeLocalStorage,
   normalizeSessionStorage,
@@ -1460,6 +1494,7 @@ var RuntimeEnv = {
   parseInput(input = {}, actor = "") {
     const runtime2 = tryParseJSON(input?.runtime) || {};
     const resolvedActor = String(actor || input?.actor || "").trim();
+    const device = resolveInputDevice(input, runtime2, resolvedActor);
     const query = String(input?.query || "").trim();
     const cookies = normalizeCookies(runtime2?.cookies);
     const cookieMap = buildCookieMap(cookies);
@@ -1479,6 +1514,7 @@ var RuntimeEnv = {
     }
     const state = {
       actor: resolvedActor,
+      device,
       runtime: normalizedRuntime,
       envId,
       query,
@@ -1524,7 +1560,10 @@ var RuntimeEnv = {
   },
   setBrowserProfileCore(source = {}, core = {}, actor = "") {
     const state = normalizeRuntimeState(source, actor);
-    const normalizedCore = normalizeBrowserProfileCore(core);
+    const normalizedCore = normalizeBrowserProfileCore({
+      ...core,
+      device: normalizeKnownDevice(core?.device) || state.device
+    });
     state.browserProfileCore = normalizedCore;
     state.browserProfile = buildBrowserProfilePayload(normalizedCore, state.browserProfileObserved);
     if (Object.keys(state.browserProfile).length > 0) {
@@ -1999,15 +2038,25 @@ var DEFAULT_LAUNCH_ARGS = [
   "--disable-setuid-sandbox",
   "--window-position=0,0"
 ];
-function buildFingerprintOptions({ locale = BASE_CONFIG.locale, browserMajorVersion = 0 } = {}) {
+function buildFingerprintOptions({ locale = BASE_CONFIG.locale, browserMajorVersion = 0, device = Device.Desktop } = {}) {
+  const resolvedDevice = normalizeDevice(device);
   const normalizedBrowserMajorVersion = Number(browserMajorVersion || 0);
   const browserDescriptor = normalizedBrowserMajorVersion > 0 ? [{ name: "chrome", minVersion: normalizedBrowserMajorVersion, maxVersion: normalizedBrowserMajorVersion }] : [{ name: "chrome", minVersion: 110 }];
-  return {
+  const options = {
     browsers: browserDescriptor,
-    devices: ["desktop"],
-    operatingSystems: ["windows", "macos", "linux"],
+    devices: [resolvedDevice],
+    operatingSystems: resolvedDevice === Device.Mobile ? ["android"] : ["windows", "macos", "linux"],
     locales: [locale]
   };
+  if (resolvedDevice === Device.Mobile) {
+    options.screen = {
+      minWidth: 320,
+      maxWidth: 480,
+      minHeight: 640,
+      maxHeight: 1100
+    };
+  }
+  return options;
 }
 var AntiCheat = {
   /**
@@ -2017,7 +2066,7 @@ var AntiCheat = {
     return { ...BASE_CONFIG };
   },
   /**
-   * 用于 Crawlee fingerprint generator 的统一配置（桌面端）。
+   * 用于 Crawlee fingerprint generator 的统一配置。
    */
   getFingerprintGeneratorOptions(options = {}) {
     return buildFingerprintOptions(options);
@@ -2030,10 +2079,10 @@ var AntiCheat = {
     return [...DEFAULT_LAUNCH_ARGS, `--lang=${locale}`];
   },
   /**
-   * 为 got-scraping 生成与浏览器一致的 TLS 指纹配置（桌面端）。
+   * 为 got-scraping 生成与浏览器一致的 TLS 指纹配置。
    */
-  getTlsFingerprintOptions(userAgent = "", acceptLanguage = "") {
-    return buildFingerprintOptions();
+  getTlsFingerprintOptions(userAgent = "", acceptLanguage = "", options = {}) {
+    return buildFingerprintOptions(options);
   },
   /**
    * 规范化请求头
@@ -2046,7 +2095,7 @@ var AntiCheat = {
   }
 };
 
-// src/humanize.js
+// src/internals/humanize/desktop.js
 import delay from "delay";
 import { createCursor } from "ghost-cursor-playwright";
 var logger6 = createInternalLogger("Humanize");
@@ -2351,7 +2400,9 @@ var Humanize = {
       const y = box.y + box.height / 2 + (Math.random() - 0.5) * box.height * 0.3;
       await cursor.actions.move({ x, y });
       await delay(this.jitterMs(reactionDelay, 0.4));
-      await cursor.actions.click();
+      await page.mouse.click(x, y, {
+        delay: this.jitterMs(45, 0.45)
+      });
       await restoreOnce();
       logger6.success("humanClick");
       return true;
@@ -2524,6 +2575,379 @@ var Humanize = {
   }
 };
 
+// src/internals/humanize/shared.js
+import delay2 from "delay";
+var jitterMs = (base, jitterPercent = 0.3) => {
+  const jitter = Number(base || 0) * Number(jitterPercent || 0) * (Math.random() * 2 - 1);
+  return Math.max(10, Math.round(Number(base || 0) + jitter));
+};
+var randomPointInBox = (box, paddingRatio = 0.24) => {
+  const safePaddingX = Math.max(2, Math.min(box.width * paddingRatio, box.width / 2));
+  const safePaddingY = Math.max(2, Math.min(box.height * paddingRatio, box.height / 2));
+  const x = box.x + safePaddingX + Math.random() * Math.max(1, box.width - safePaddingX * 2);
+  const y = box.y + safePaddingY + Math.random() * Math.max(1, box.height - safePaddingY * 2);
+  return { x, y };
+};
+var resolveElement = async (page, target, { throwOnMissing = true } = {}) => {
+  if (target == null) return null;
+  let element = target;
+  if (typeof target === "string") {
+    element = await page.$(target);
+  }
+  if (!element) {
+    if (throwOnMissing) {
+      throw new Error(`\u627E\u4E0D\u5230\u5143\u7D20 ${String(target)}`);
+    }
+    return null;
+  }
+  return element;
+};
+var waitJitter = (base, jitterPercent = 0.3) => delay2(jitterMs(base, jitterPercent));
+
+// src/internals/humanize/mobile.js
+var logger7 = createInternalLogger("Humanize.Mobile");
+var initializedPages = /* @__PURE__ */ new WeakSet();
+var clamp = (value, min, max) => Math.min(max, Math.max(min, value));
+var resolveViewport = (page) => page?.viewportSize?.() || { width: 390, height: 844 };
+var checkElementVisibility = async (element) => {
+  return element.evaluate((el) => {
+    const rect = el.getBoundingClientRect();
+    if (!rect || rect.width <= 0 || rect.height <= 0) {
+      return { code: "ZERO_DIMENSIONS", direction: "down" };
+    }
+    const viewW = window.innerWidth;
+    const viewH = window.innerHeight;
+    const cx = rect.left + rect.width / 2;
+    const cy = rect.top + rect.height / 2;
+    let isFixed = false;
+    for (let node = el; node && node !== document.body; node = node.parentElement) {
+      const style = window.getComputedStyle(node);
+      if (style && (style.position === "fixed" || style.position === "sticky")) {
+        isFixed = true;
+        break;
+      }
+    }
+    if ((isFixed ? cy < 0 || cy > viewH : cy < 12 || cy > viewH - 12) || cx < 0 || cx > viewW) {
+      return {
+        code: "OUT_OF_VIEWPORT",
+        direction: cy < viewH / 2 ? "up" : "down",
+        cy,
+        viewH,
+        isFixed
+      };
+    }
+    const pointElement = document.elementFromPoint(cx, cy);
+    if (pointElement && !el.contains(pointElement) && !pointElement.contains(el)) {
+      return {
+        code: "OBSTRUCTED",
+        direction: cy > viewH / 2 ? "down" : "up",
+        cy,
+        viewH,
+        isFixed
+      };
+    }
+    return { code: "VISIBLE", isFixed };
+  });
+};
+var dispatchTouchSwipe = async (page, deltaY, options = {}) => {
+  const viewport = resolveViewport(page);
+  const distance = clamp(Math.abs(deltaY), 80, Math.max(120, viewport.height * 0.72));
+  const direction = deltaY >= 0 ? 1 : -1;
+  const startX = clamp(
+    viewport.width * (0.45 + Math.random() * 0.1),
+    24,
+    viewport.width - 24
+  );
+  const startY = direction > 0 ? clamp(viewport.height * (0.72 + Math.random() * 0.1), 80, viewport.height - 32) : clamp(viewport.height * (0.28 + Math.random() * 0.1), 32, viewport.height - 80);
+  const endY = clamp(startY - direction * distance, 24, viewport.height - 24);
+  const steps = Math.max(4, Math.round(Number(options.steps || 6)));
+  const durationMs = jitterMs(options.durationMs || 320, 0.35);
+  let client = null;
+  const scrollBefore = await page.evaluate(() => ({ x: window.scrollX, y: window.scrollY })).catch(() => null);
+  try {
+    if (page.context && typeof page.context().newCDPSession === "function") {
+      client = await page.context().newCDPSession(page);
+    }
+    if (!client) throw new Error("CDP session unavailable");
+    await client.send("Input.synthesizeScrollGesture", {
+      x: startX,
+      y: startY,
+      yDistance: -direction * distance,
+      xOverscroll: (Math.random() - 0.5) * 4,
+      yOverscroll: (Math.random() - 0.5) * 8,
+      speed: 700 + Math.round(Math.random() * 350),
+      gestureSourceType: "touch"
+    });
+    await waitJitter(160, 0.35);
+    const scrollAfterSynth = await page.evaluate(() => ({ x: window.scrollX, y: window.scrollY })).catch(() => null);
+    if (scrollBefore && scrollAfterSynth && (Math.abs(scrollAfterSynth.y - scrollBefore.y) > 2 || Math.abs(scrollAfterSynth.x - scrollBefore.x) > 2)) {
+      return true;
+    }
+    await client.send("Input.dispatchTouchEvent", {
+      type: "touchStart",
+      touchPoints: [{ x: startX, y: startY, id: 1 }]
+    });
+    for (let i = 1; i <= steps; i += 1) {
+      const progress = i / steps;
+      const eased = 1 - Math.pow(1 - progress, 2);
+      const x = startX + (Math.random() - 0.5) * 3;
+      const y = startY + (endY - startY) * eased + (Math.random() - 0.5) * 5;
+      await waitJitter(durationMs / steps, 0.25);
+      await client.send("Input.dispatchTouchEvent", {
+        type: "touchMove",
+        touchPoints: [{ x, y, id: 1 }]
+      });
+    }
+    await client.send("Input.dispatchTouchEvent", {
+      type: "touchEnd",
+      touchPoints: []
+    });
+    await waitJitter(120, 0.35);
+    const scrollAfterTouch = await page.evaluate(() => ({ x: window.scrollX, y: window.scrollY })).catch(() => null);
+    if (scrollBefore && scrollAfterTouch && Math.abs(scrollAfterTouch.y - scrollBefore.y) <= 2 && Math.abs(scrollAfterTouch.x - scrollBefore.x) <= 2) {
+      await page.evaluate((amount) => window.scrollBy(0, amount), deltaY);
+      await waitJitter(120, 0.35);
+    }
+    return true;
+  } catch (error) {
+    logger7.debug(`touch swipe fallback: ${error?.message || error}`);
+    try {
+      await page.evaluate((amount) => window.scrollBy(0, amount), deltaY);
+      await waitJitter(120, 0.35);
+      return true;
+    } catch {
+      await page.mouse.wheel(0, deltaY);
+      await waitJitter(120, 0.35);
+      return true;
+    }
+  } finally {
+    if (client && typeof client.detach === "function") {
+      try {
+        await client.detach();
+      } catch {
+      }
+    }
+  }
+};
+var tapPoint = async (page, point) => {
+  if (page.touchscreen && typeof page.touchscreen.tap === "function") {
+    await page.touchscreen.tap(point.x, point.y);
+    return;
+  }
+  await page.mouse.click(point.x, point.y);
+};
+var MobileHumanize = {
+  jitterMs,
+  async initializeCursor(page) {
+    if (initializedPages.has(page)) return;
+    initializedPages.add(page);
+    logger7.debug("initializeCursor: mobile mode uses touch gestures, cursor init skipped");
+  },
+  async humanMove(page, target) {
+    logger7.debug(`humanMove: mobile no-op target=${typeof target === "string" ? target : "element/coords"}`);
+    if (typeof target === "string" || target && typeof target.boundingBox === "function") {
+      const element = await resolveElement(page, target, { throwOnMissing: false });
+      if (!element) {
+        return false;
+      }
+    }
+    await waitJitter(80, 0.4);
+    return true;
+  },
+  async humanScroll(page, target, options = {}) {
+    const {
+      maxSteps = 12,
+      minStep = 180,
+      maxStep = 520,
+      maxDurationMs = maxSteps * 280 + 1200,
+      throwOnMissing = false
+    } = options;
+    const element = await resolveElement(page, target, { throwOnMissing });
+    if (!element) {
+      return { element: null, didScroll: false, restore: null };
+    }
+    const startTime = Date.now();
+    let didScroll = false;
+    for (let i = 0; i < maxSteps; i += 1) {
+      const status = await checkElementVisibility(element);
+      if (status.code === "VISIBLE") {
+        return { element, didScroll, restore: null };
+      }
+      if (Date.now() - startTime > maxDurationMs) {
+        logger7.warn(`humanScroll | mobile timeout (${maxDurationMs}ms)`);
+        return { element, didScroll, restore: null };
+      }
+      const distance = minStep + Math.random() * Math.max(1, maxStep - minStep);
+      const deltaY = status.direction === "up" ? -distance : distance;
+      await dispatchTouchSwipe(page, deltaY);
+      didScroll = true;
+    }
+    return { element, didScroll, restore: null };
+  },
+  async humanClick(page, target, options = {}) {
+    const {
+      reactionDelay = 220,
+      throwOnMissing = true,
+      scrollIfNeeded = true
+    } = options;
+    if (target == null) {
+      const viewport = resolveViewport(page);
+      await waitJitter(reactionDelay, 0.45);
+      await tapPoint(page, {
+        x: viewport.width * (0.45 + Math.random() * 0.1),
+        y: viewport.height * (0.48 + Math.random() * 0.12)
+      });
+      return true;
+    }
+    const element = await resolveElement(page, target, { throwOnMissing });
+    if (!element) return false;
+    if (scrollIfNeeded) {
+      await MobileHumanize.humanScroll(page, element, { throwOnMissing });
+    }
+    const box = await element.boundingBox();
+    if (!box) {
+      if (throwOnMissing) throw new Error("\u65E0\u6CD5\u83B7\u53D6\u5143\u7D20\u4F4D\u7F6E");
+      return false;
+    }
+    await waitJitter(reactionDelay, 0.45);
+    await tapPoint(page, randomPointInBox(box, 0.2));
+    await waitJitter(120, 0.35);
+    return true;
+  },
+  async randomSleep(baseMs, jitterPercent = 0.3) {
+    await waitJitter(baseMs, jitterPercent);
+  },
+  async simulateGaze(page, baseDurationMs = 2500) {
+    const durationMs = jitterMs(baseDurationMs, 0.4);
+    const startTime = Date.now();
+    while (Date.now() - startTime < durationMs) {
+      if (Math.random() < 0.28) {
+        const distance = 70 + Math.random() * 120;
+        await dispatchTouchSwipe(page, Math.random() < 0.7 ? distance : -distance, {
+          durationMs: 180,
+          steps: 4
+        });
+      } else {
+        await waitJitter(420, 0.55);
+      }
+    }
+  },
+  async humanType(page, selector, text, options = {}) {
+    const {
+      baseDelay = 160,
+      pauseProbability = 0.08,
+      pauseBase = 700
+    } = options;
+    await MobileHumanize.humanClick(page, selector, { scrollIfNeeded: true });
+    await waitJitter(220, 0.45);
+    for (let i = 0; i < String(text).length; i += 1) {
+      const char = String(text)[i];
+      const charDelay = /[,.!?;:，。！？；：]/.test(char) ? jitterMs(baseDelay * 1.45, 0.4) : jitterMs(char === " " ? baseDelay * 0.65 : baseDelay, 0.4);
+      await page.keyboard.type(char);
+      await waitJitter(charDelay, 0.15);
+      if (Math.random() < pauseProbability && i < String(text).length - 1) {
+        await waitJitter(pauseBase, 0.5);
+      }
+    }
+  },
+  async humanClear(page, selector) {
+    const locator = page.locator(selector);
+    await MobileHumanize.humanClick(page, locator, { scrollIfNeeded: true });
+    await waitJitter(160, 0.4);
+    await locator.evaluate((el) => {
+      if ("value" in el) {
+        el.value = "";
+        el.dispatchEvent(new Event("input", { bubbles: true }));
+        el.dispatchEvent(new Event("change", { bubbles: true }));
+        return;
+      }
+      el.textContent = "";
+      el.dispatchEvent(new Event("input", { bubbles: true }));
+    });
+  },
+  async warmUpBrowsing(page, baseDuration = 3500) {
+    const durationMs = jitterMs(baseDuration, 0.4);
+    const startTime = Date.now();
+    while (Date.now() - startTime < durationMs) {
+      const action = Math.random();
+      if (action < 0.5) {
+        await dispatchTouchSwipe(page, 120 + Math.random() * 220, {
+          durationMs: 240,
+          steps: 5
+        });
+      } else if (action < 0.7) {
+        await dispatchTouchSwipe(page, -(80 + Math.random() * 160), {
+          durationMs: 220,
+          steps: 4
+        });
+      } else {
+        await waitJitter(560, 0.55);
+      }
+    }
+  },
+  async naturalScroll(page, direction = "down", distance = 300, baseSteps = 5) {
+    const steps = Math.max(3, baseSteps + Math.floor(Math.random() * 3) - 1);
+    const actualDistance = jitterMs(distance, 0.15);
+    const sign = direction === "down" ? 1 : -1;
+    for (let i = 0; i < steps; i += 1) {
+      const factor = 1 - i / steps * 0.45;
+      await dispatchTouchSwipe(page, actualDistance / steps * factor * sign, {
+        durationMs: 150 + i * 20,
+        steps: 4
+      });
+    }
+  }
+};
+
+// src/humanize.js
+var resolveDeviceFromPage = (page) => normalizeDevice(page?.[PageRuntimeStateKey]?.device);
+var resolveDelegate = (page) => {
+  return resolveDeviceFromPage(page) === Device.Mobile ? MobileHumanize : Humanize;
+};
+var callDelegate = (method, page, args) => {
+  const delegate = resolveDelegate(page);
+  return delegate[method](page, ...args);
+};
+var Humanize2 = {
+  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]);
+  },
+  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]);
+  }
+};
+
 // src/launch.js
 import { execFileSync } from "node:child_process";
 import { FingerprintGenerator } from "fingerprint-generator";
@@ -2610,7 +3034,7 @@ var ByPass = {
 };
 
 // src/launch.js
-var logger7 = createInternalLogger("Launch");
+var logger8 = createInternalLogger("Launch");
 var REQUEST_HOOK_FLAG = Symbol("playwright-toolkit-request-hook");
 var injectedContexts = /* @__PURE__ */ new WeakSet();
 var browserMajorVersionCache = /* @__PURE__ */ new Map();
@@ -2662,20 +3086,29 @@ var detectBrowserMajorVersion = (launcher) => {
     });
     detectedVersion = parseChromeMajorVersion(rawVersion);
   } catch (error) {
-    logger7.warn(`\u8BFB\u53D6\u6D4F\u89C8\u5668\u7248\u672C\u5931\u8D25: ${error?.message || error}`);
+    logger8.warn(`\u8BFB\u53D6\u6D4F\u89C8\u5668\u7248\u672C\u5931\u8D25: ${error?.message || error}`);
   }
   browserMajorVersionCache.set(executablePath, detectedVersion);
   return detectedVersion;
 };
-var buildFingerprintGenerator = ({ locale, browserMajorVersion }) => {
+var resolveRuntimeDevice = (runtimeState = {}) => normalizeDevice(runtimeState?.device);
+var resolveCoreDevice = (core = {}) => {
+  const raw = String(core?.device || "").trim().toLowerCase();
+  if (raw === Device.Mobile) return Device.Mobile;
+  if (raw === Device.Desktop) return Device.Desktop;
+  return "";
+};
+var buildFingerprintGenerator = ({ locale, browserMajorVersion, device }) => {
   return new FingerprintGenerator(
     AntiCheat.getFingerprintGeneratorOptions({
       locale,
-      browserMajorVersion
+      browserMajorVersion,
+      device
     })
   );
 };
 var buildReplayableBrowserProfile = (runtimeState, launcher) => {
+  const device = resolveRuntimeDevice(runtimeState);
   if (!runtimeState || !RuntimeEnv.hasLoginState(runtimeState)) {
     return { runtimeState, browserProfileCore: null };
   }
@@ -2685,29 +3118,34 @@ var buildReplayableBrowserProfile = (runtimeState, launcher) => {
   const locale = DEFAULT_LOCALE;
   const currentBrowserMajorVersion = detectBrowserMajorVersion(launcher);
   const storedBrowserMajorVersion = Number(browserProfileCore?.browser_major_version || 0);
-  const needsRebuild = !browserProfileCore?.fingerprint || Object.keys(browserProfileCore.fingerprint || {}).length === 0 || currentBrowserMajorVersion > 0 && storedBrowserMajorVersion > 0 && storedBrowserMajorVersion !== currentBrowserMajorVersion;
+  const storedDevice = resolveCoreDevice(browserProfileCore);
+  const needsDeviceRebuild = storedDevice ? storedDevice !== device : device === Device.Mobile;
+  const needsRebuild = !browserProfileCore?.fingerprint || Object.keys(browserProfileCore.fingerprint || {}).length === 0 || needsDeviceRebuild || currentBrowserMajorVersion > 0 && storedBrowserMajorVersion > 0 && storedBrowserMajorVersion !== currentBrowserMajorVersion;
   if (needsRebuild) {
     const generator = buildFingerprintGenerator({
       locale,
-      browserMajorVersion: currentBrowserMajorVersion
+      browserMajorVersion: currentBrowserMajorVersion,
+      device
     });
     const fingerprint = generator.getFingerprint();
     const fingerprintBrowserMajorVersion = parseChromeMajorVersion(fingerprint?.fingerprint?.navigator?.userAgent || "");
     browserProfileCore = {
       fingerprint,
+      device,
       timezone_id: timezoneId,
       locale,
       browser_major_version: currentBrowserMajorVersion > 0 ? currentBrowserMajorVersion : fingerprintBrowserMajorVersion,
       schema_version: DEFAULT_BROWSER_PROFILE_SCHEMA_VERSION
     };
     nextState = RuntimeEnv.setBrowserProfileCore(nextState, browserProfileCore);
-    logger7.info(
-      `\u5DF2\u751F\u6210\u6D4F\u89C8\u5668\u6307\u7EB9\u771F\u6E90 | env=${String(nextState.envId || "-")} | version=${browserProfileCore.browser_major_version || "-"} | timezone=${timezoneId}`
+    logger8.info(
+      `\u5DF2\u751F\u6210\u6D4F\u89C8\u5668\u6307\u7EB9\u771F\u6E90 | env=${String(nextState.envId || "-")} | device=${device} | version=${browserProfileCore.browser_major_version || "-"} | timezone=${timezoneId}`
     );
     return { runtimeState: nextState, browserProfileCore };
   }
   const normalizedBrowserProfileCore = {
     ...browserProfileCore,
+    device,
     timezone_id: timezoneId,
     locale,
     schema_version: Number(browserProfileCore.schema_version || 0) > 0 ? Number(browserProfileCore.schema_version || 0) : DEFAULT_BROWSER_PROFILE_SCHEMA_VERSION,
@@ -2723,6 +3161,35 @@ var buildReplayableBrowserProfile = (runtimeState, launcher) => {
     browserProfileCore: normalizedBrowserProfileCore
   };
 };
+var applyDevicePageOptions = (pageOptions = {}, { device = Device.Desktop, fingerprint = null } = {}) => {
+  if (!pageOptions || typeof pageOptions !== "object") return;
+  const resolvedDevice = normalizeDevice(device);
+  const screen = fingerprint?.screen || {};
+  const dpr = Number(screen.devicePixelRatio || 0);
+  if (resolvedDevice === Device.Mobile) {
+    pageOptions.isMobile = true;
+    pageOptions.hasTouch = true;
+    pageOptions.deviceScaleFactor = dpr > 0 ? dpr : 2;
+    if (!pageOptions.viewport) {
+      pageOptions.viewport = {
+        width: Number(screen.width || 390),
+        height: Number(screen.height || 844)
+      };
+    }
+    if (!pageOptions.screen) {
+      pageOptions.screen = {
+        width: Number(screen.width || pageOptions.viewport.width || 390),
+        height: Number(screen.height || pageOptions.viewport.height || 844)
+      };
+    }
+    return;
+  }
+  pageOptions.isMobile = false;
+  pageOptions.hasTouch = false;
+  if (!pageOptions.deviceScaleFactor) {
+    pageOptions.deviceScaleFactor = dpr > 0 ? dpr : 1;
+  }
+};
 var buildReplayBrowserPoolOptions = (browserProfileCore) => {
   const fingerprintWithHeaders = browserProfileCore?.fingerprint;
   const fingerprint = fingerprintWithHeaders?.fingerprint;
@@ -2755,6 +3222,10 @@ var buildReplayBrowserPoolOptions = (browserProfileCore) => {
         if (browserProfileCore.timezone_id) {
           pageOptions.timezoneId = browserProfileCore.timezone_id;
         }
+        applyDevicePageOptions(pageOptions, {
+          device: browserProfileCore.device,
+          fingerprint
+        });
       }
     ],
     postPageCreateHooks: [
@@ -2784,6 +3255,7 @@ var Launch = {
       postNavigationHooks = [],
       runtimeState = null
     } = normalizedOptions;
+    const device = resolveRuntimeDevice(runtimeState);
     const { byPassDomains, enableProxy, proxyUrl } = resolveProxyLaunchOptions(proxyConfiguration);
     const byPassRules = ByPass.buildByPassDomainRules(byPassDomains);
     const proxyMeter = enableProxy && proxyUrl ? ProxyMeterRuntime.startProxyMeter({ proxyUrl, debugMode }) : null;
@@ -2812,18 +3284,18 @@ var Launch = {
         upstreamLabel = `${parsedProxyUrl.protocol}//${parsedProxyUrl.host}`;
       } catch {
       }
-      logger7.info(
+      logger8.info(
         `[\u4EE3\u7406\u5DF2\u542F\u7528] \u672C\u5730=${launchProxy.server} \u4E0A\u6E38=${upstreamLabel || "-"} \u76F4\u8FDE\u57DF\u540D=${(byPassDomains || []).join(",")}`
       );
-      logger7.info(`[\u6D41\u91CF\u89C2\u6D4B] \u9010\u8BF7\u6C42\u8C03\u8BD5=${Boolean(debugMode) ? "\u5F00\u542F" : "\u5173\u95ED"}\uFF08\u6C47\u603B\u59CB\u7EC8\u5F00\u542F\uFF09`);
+      logger8.info(`[\u6D41\u91CF\u89C2\u6D4B] \u9010\u8BF7\u6C42\u8C03\u8BD5=${Boolean(debugMode) ? "\u5F00\u542F" : "\u5173\u95ED"}\uFF08\u6C47\u603B\u59CB\u7EC8\u5F00\u542F\uFF09`);
     } else if (enableByPassLogger && enableProxy && !launchProxy) {
-      logger7.info("[\u4EE3\u7406\u672A\u542F\u7528] enable_proxy=true \u4F46 proxy_url \u4E3A\u7A7A");
-      logger7.info(`[\u6D41\u91CF\u89C2\u6D4B] \u9010\u8BF7\u6C42\u8C03\u8BD5=${Boolean(debugMode) ? "\u5F00\u542F" : "\u5173\u95ED"}\uFF08\u6C47\u603B\u59CB\u7EC8\u5F00\u542F\uFF09`);
+      logger8.info("[\u4EE3\u7406\u672A\u542F\u7528] enable_proxy=true \u4F46 proxy_url \u4E3A\u7A7A");
+      logger8.info(`[\u6D41\u91CF\u89C2\u6D4B] \u9010\u8BF7\u6C42\u8C03\u8BD5=${Boolean(debugMode) ? "\u5F00\u542F" : "\u5173\u95ED"}\uFF08\u6C47\u603B\u59CB\u7EC8\u5F00\u542F\uFF09`);
     } else if (enableByPassLogger && !enableProxy && proxyUrl) {
-      logger7.info("[\u4EE3\u7406\u672A\u542F\u7528] enable_proxy=false \u4E14 proxy_url \u5DF2\u914D\u7F6E");
-      logger7.info(`[\u6D41\u91CF\u89C2\u6D4B] \u9010\u8BF7\u6C42\u8C03\u8BD5=${Boolean(debugMode) ? "\u5F00\u542F" : "\u5173\u95ED"}\uFF08\u6C47\u603B\u59CB\u7EC8\u5F00\u542F\uFF09`);
+      logger8.info("[\u4EE3\u7406\u672A\u542F\u7528] enable_proxy=false \u4E14 proxy_url \u5DF2\u914D\u7F6E");
+      logger8.info(`[\u6D41\u91CF\u89C2\u6D4B] \u9010\u8BF7\u6C42\u8C03\u8BD5=${Boolean(debugMode) ? "\u5F00\u542F" : "\u5173\u95ED"}\uFF08\u6C47\u603B\u59CB\u7EC8\u5F00\u542F\uFF09`);
     } else if (enableByPassLogger) {
-      logger7.info(`[\u6D41\u91CF\u89C2\u6D4B] \u9010\u8BF7\u6C42\u8C03\u8BD5=${Boolean(debugMode) ? "\u5F00\u542F" : "\u5173\u95ED"}\uFF08\u6C47\u603B\u59CB\u7EC8\u5F00\u542F\uFF09`);
+      logger8.info(`[\u6D41\u91CF\u89C2\u6D4B] \u9010\u8BF7\u6C42\u8C03\u8BD5=${Boolean(debugMode) ? "\u5F00\u542F" : "\u5173\u95ED"}\uFF08\u6C47\u603B\u59CB\u7EC8\u5F00\u542F\uFF09`);
     }
     const onPageCreated = (page) => {
       const recommendedGotoOptions = {
@@ -2845,7 +3317,7 @@ var Launch = {
         }
         if (!enableByPassLogger || byPassDomains.length === 0) return;
         if (!matched || !matched.rule) return;
-        logger7.info(`[\u76F4\u8FDE\u547D\u4E2D] \u89C4\u5219=${matched.rule.pattern} \u57DF\u540D=${matched.hostname} \u8D44\u6E90\u7C7B\u578B=${resourceType} \u65B9\u6CD5=${req.method()} \u5730\u5740=${requestUrl}`);
+        logger8.info(`[\u76F4\u8FDE\u547D\u4E2D] \u89C4\u5219=${matched.rule.pattern} \u57DF\u540D=${matched.hostname} \u8D44\u6E90\u7C7B\u578B=${resourceType} \u65B9\u6CD5=${req.method()} \u5730\u5740=${requestUrl}`);
       };
       page.on("request", requestHandler);
       return recommendedGotoOptions;
@@ -2864,8 +3336,23 @@ var Launch = {
       browserPoolOptions: replayBrowserPoolOptions || {
         useFingerprints: true,
         fingerprintOptions: {
-          fingerprintGeneratorOptions: AntiCheat.getFingerprintGeneratorOptions()
-        }
+          fingerprintGeneratorOptions: AntiCheat.getFingerprintGeneratorOptions({
+            locale: launchLocale,
+            device
+          })
+        },
+        prePageCreateHooks: [
+          (_pageId, _browserController, pageOptions = {}) => {
+            applyDevicePageOptions(pageOptions, { device });
+            if (launchLocale) {
+              pageOptions.locale = launchLocale;
+            }
+            const timezoneId = AntiCheat.getBaseConfig().timezoneId;
+            if (timezoneId) {
+              pageOptions.timezoneId = timezoneId;
+            }
+          }
+        ]
       },
       launchContext
     };
@@ -2888,7 +3375,7 @@ var Launch = {
 // src/live-view.js
 import express from "express";
 import { Actor } from "apify";
-var logger8 = createInternalLogger("LiveView");
+var logger9 = createInternalLogger("LiveView");
 async function startLiveViewServer(liveViewKey) {
   const app = express();
   app.get("/", async (req, res) => {
@@ -2913,13 +3400,13 @@ async function startLiveViewServer(liveViewKey) {
                 </html>
             `);
     } catch (error) {
-      logger8.fail("Live View Server", error);
+      logger9.fail("Live View Server", error);
       res.status(500).send(`\u65E0\u6CD5\u52A0\u8F7D\u5C4F\u5E55\u622A\u56FE: ${error.message}`);
     }
   });
   const port = process.env.APIFY_CONTAINER_PORT || 4321;
   app.listen(port, () => {
-    logger8.success("startLiveViewServer", `\u76D1\u542C\u7AEF\u53E3 ${port}`);
+    logger9.success("startLiveViewServer", `\u76D1\u542C\u7AEF\u53E3 ${port}`);
   });
 }
 async function takeLiveScreenshot(liveViewKey, page, logMessage) {
@@ -2927,10 +3414,10 @@ async function takeLiveScreenshot(liveViewKey, page, logMessage) {
     const buffer = await capturePageScreenshot(page, { type: "png" });
     await Actor.setValue(liveViewKey, buffer, { contentType: "image/png" });
     if (logMessage) {
-      logger8.info(`(\u622A\u56FE): ${logMessage}`);
+      logger9.info(`(\u622A\u56FE): ${logMessage}`);
     }
   } catch (e) {
-    logger8.warn(`\u65E0\u6CD5\u6355\u83B7 Live View \u5C4F\u5E55\u622A\u56FE: ${e.message}`);
+    logger9.warn(`\u65E0\u6CD5\u6355\u83B7 Live View \u5C4F\u5E55\u622A\u56FE: ${e.message}`);
   }
 }
 var useLiveView = (liveViewKey = PresetOfLiveViewKey) => {
@@ -3030,7 +3517,7 @@ var dragCaptchaWithMouse = async (page, sourceLocator, targetLocator) => {
 };
 
 // src/internals/captcha/bytedance.js
-var logger9 = createInternalLogger("Captcha");
+var logger10 = createInternalLogger("Captcha");
 var DEFAULT_BYTEDANCE_CAPTCHA_OPTIONS = Object.freeze({
   apiType: "31234",
   maxRetries: 3,
@@ -3097,14 +3584,14 @@ var getVerifycenterCaptchaContext = async (page, options) => {
   if (!isContainerVisible) {
     return null;
   }
-  logger9.info("\u68C0\u6D4B\u5230\u9A8C\u8BC1\u7801\u5BB9\u5668\uFF0C\u5F00\u59CB\u7B49\u5F85 iframe \u52A0\u8F7D\u3002");
+  logger10.info("\u68C0\u6D4B\u5230\u9A8C\u8BC1\u7801\u5BB9\u5668\uFF0C\u5F00\u59CB\u7B49\u5F85 iframe \u52A0\u8F7D\u3002");
   let iframeLocator = page.locator(options.iframeSelector).first();
   let isIframeVisible = await waitForVisible(
     iframeLocator,
     options.iframeVisibleTimeoutMs
   );
   if (!isIframeVisible) {
-    logger9.warn("\u672A\u5728\u9884\u671F\u9009\u62E9\u5668\u4E2D\u627E\u5230 verifycenter iframe\uFF0C\u5C1D\u8BD5\u5BB9\u5668\u5185\u4EFB\u610F iframe\u3002");
+    logger10.warn("\u672A\u5728\u9884\u671F\u9009\u62E9\u5668\u4E2D\u627E\u5230 verifycenter iframe\uFF0C\u5C1D\u8BD5\u5BB9\u5668\u5185\u4EFB\u610F iframe\u3002");
     iframeLocator = captchaContainer.locator(options.iframeFallbackSelector).first();
     isIframeVisible = await waitForVisible(
       iframeLocator,
@@ -3114,7 +3601,7 @@ var getVerifycenterCaptchaContext = async (page, options) => {
   if (!isIframeVisible) {
     throw new Error("verifycenter iframe not found inside captcha container.");
   }
-  logger9.info("\u9A8C\u8BC1\u7801 iframe \u5DF2\u53EF\u89C1\uFF0C\u5F00\u59CB\u89E3\u6790\u5185\u5BB9 frame\u3002");
+  logger10.info("\u9A8C\u8BC1\u7801 iframe \u5DF2\u53EF\u89C1\uFF0C\u5F00\u59CB\u89E3\u6790\u5185\u5BB9 frame\u3002");
   const frame = await resolveContentFrame(page, iframeLocator, options);
   if (!frame) {
     throw new Error("Failed to resolve verifycenter iframe content frame.");
@@ -3124,7 +3611,7 @@ var getVerifycenterCaptchaContext = async (page, options) => {
 var refreshCaptcha = async (page, frame, options) => {
   const clicked = await clickCaptchaAction(frame, options.refreshTexts, options).catch(() => false);
   if (!clicked) {
-    logger9.warn("Refresh button not found.");
+    logger10.warn("Refresh button not found.");
     return false;
   }
   await page.waitForTimeout(options.refreshWaitMs);
@@ -3165,18 +3652,18 @@ var waitForCaptchaChallengeReady = async (page, frame, options) => {
     const imageCount = await sourceImages.count().catch(() => 0);
     const hasVisibleSourceImage = imageCount > 0 ? await sourceImages.first().isVisible({ timeout: options.loadingIndicatorVisibleTimeoutMs }).catch(() => false) : false;
     if (!isLoadingVisible && hasVisibleSourceImage) {
-      logger9.info(hasSeenLoading ? "\u9A8C\u8BC1\u7801\u56FE\u7247\u5DF2\u52A0\u8F7D\u5B8C\u6210\u3002" : "\u9A8C\u8BC1\u7801\u56FE\u7247\u5DF2\u5C31\u7EEA\u3002");
+      logger10.info(hasSeenLoading ? "\u9A8C\u8BC1\u7801\u56FE\u7247\u5DF2\u52A0\u8F7D\u5B8C\u6210\u3002" : "\u9A8C\u8BC1\u7801\u56FE\u7247\u5DF2\u5C31\u7EEA\u3002");
       return;
     }
     if (hasErrorTextVisible) {
-      logger9.warn("\u9A8C\u8BC1\u7801\u9762\u677F\u51FA\u73B0\u7F51\u7EDC\u5F02\u5E38\u6587\u6848\uFF0C\u5C1D\u8BD5\u7ACB\u5373\u5237\u65B0\u9898\u76EE\u3002");
+      logger10.warn("\u9A8C\u8BC1\u7801\u9762\u677F\u51FA\u73B0\u7F51\u7EDC\u5F02\u5E38\u6587\u6848\uFF0C\u5C1D\u8BD5\u7ACB\u5373\u5237\u65B0\u9898\u76EE\u3002");
       await refreshCaptcha(page, frame, options);
       refreshDeadline = Date.now() + options.challengeReadyRefreshTimeoutMs;
       hasSeenLoading = false;
       continue;
     }
     if (!hasVisibleSourceImage && Date.now() >= refreshDeadline) {
-      logger9.warn(`\u9A8C\u8BC1\u7801\u56FE\u7247\u8D85\u8FC7 ${options.challengeReadyRefreshTimeoutMs}ms \u4ECD\u672A\u51FA\u73B0\uFF0C\u5C1D\u8BD5\u5237\u65B0\u9898\u76EE\u3002`);
+      logger10.warn(`\u9A8C\u8BC1\u7801\u56FE\u7247\u8D85\u8FC7 ${options.challengeReadyRefreshTimeoutMs}ms \u4ECD\u672A\u51FA\u73B0\uFF0C\u5C1D\u8BD5\u5237\u65B0\u9898\u76EE\u3002`);
       await refreshCaptcha(page, frame, options);
       refreshDeadline = Date.now() + options.challengeReadyRefreshTimeoutMs;
       hasSeenLoading = false;
@@ -3196,16 +3683,16 @@ async function solveCaptcha(page, options = {}, dependencies = {}) {
     ...options
   };
   if (!config.token) {
-    logger9.warn("\u7F3A\u5C11\u9A8C\u8BC1\u7801 token\uFF0C\u8DF3\u8FC7\u81EA\u52A8\u8BC6\u522B\u3002");
+    logger10.warn("\u7F3A\u5C11\u9A8C\u8BC1\u7801 token\uFF0C\u8DF3\u8FC7\u81EA\u52A8\u8BC6\u522B\u3002");
     return false;
   }
-  logger9.info("\u5F53\u524D\u4F7F\u7528\u672Ctool\u2014\u2014\u6D4B\u8BD5\u7248\u672C");
+  logger10.info("\u5F53\u524D\u4F7F\u7528\u672Ctool\u2014\u2014\u6D4B\u8BD5\u7248\u672C");
   for (let attempt = 1; attempt <= config.maxRetries; attempt++) {
-    logger9.info(`\u5F00\u59CB\u7B2C ${attempt}/${config.maxRetries} \u6B21 verifycenter \u9A8C\u8BC1\u7801\u8BC6\u522B\u3002`);
+    logger10.info(`\u5F00\u59CB\u7B2C ${attempt}/${config.maxRetries} \u6B21 verifycenter \u9A8C\u8BC1\u7801\u8BC6\u522B\u3002`);
     try {
       const captchaContext = await getVerifycenterCaptchaContext(page, config);
       if (!captchaContext) {
-        logger9.info("Captcha container is not visible anymore.");
+        logger10.info("Captcha container is not visible anymore.");
         return true;
       }
       const { iframeLocator, frame } = captchaContext;
@@ -3220,16 +3707,16 @@ async function solveCaptcha(page, options = {}, dependencies = {}) {
       });
       const serialNumbers = extractCaptchaSerialNumbers(apiResponse);
       if (apiResponse?.code !== config.recognitionSuccessCode || serialNumbers.length === 0) {
-        logger9.warn(
+        logger10.warn(
           `\u9A8C\u8BC1\u7801\u8BC6\u522B\u5931\u8D25\u3002code=${apiResponse?.code}, msg=${apiResponse?.msg || "unknown"}`
         );
         await refreshCaptcha(page, frame, config);
         continue;
       }
-      logger9.info(`\u9A8C\u8BC1\u7801\u8BC6\u522B\u6210\u529F\uFF0C\u5E8F\u53F7\uFF1A${serialNumbers.join(", ")}`);
+      logger10.info(`\u9A8C\u8BC1\u7801\u8BC6\u522B\u6210\u529F\uFF0C\u5E8F\u53F7\uFF1A${serialNumbers.join(", ")}`);
       const dropTarget = await findCaptchaDropTarget(frame, config);
       if (!dropTarget) {
-        logger9.warn("\u672A\u627E\u5230\u9A8C\u8BC1\u7801\u62D6\u62FD\u76EE\u6807\u533A\u57DF\u3002");
+        logger10.warn("\u672A\u627E\u5230\u9A8C\u8BC1\u7801\u62D6\u62FD\u76EE\u6807\u533A\u57DF\u3002");
         await refreshCaptcha(page, frame, config);
         continue;
       }
@@ -3252,31 +3739,31 @@ async function solveCaptcha(page, options = {}, dependencies = {}) {
       }
       const submitted = await clickCaptchaAction(frame, config.submitTexts, config).catch(() => false);
       if (!submitted) {
-        logger9.warn("\u672A\u627E\u5230\u63D0\u4EA4\u6309\u94AE\uFF0C\u53EF\u80FD\u4F1A\u81EA\u52A8\u63D0\u4EA4\u3002");
+        logger10.warn("\u672A\u627E\u5230\u63D0\u4EA4\u6309\u94AE\uFF0C\u53EF\u80FD\u4F1A\u81EA\u52A8\u63D0\u4EA4\u3002");
       }
       await page.waitForTimeout(config.submitWaitMs);
       const stillVisible = await iframeLocator.isVisible({ timeout: config.containerVisibleTimeoutMs }).catch(() => false);
       if (!stillVisible) {
-        logger9.info("\u9A8C\u8BC1\u7801\u8BC6\u522B\u5E76\u63D0\u4EA4\u6210\u529F\u3002");
+        logger10.info("\u9A8C\u8BC1\u7801\u8BC6\u522B\u5E76\u63D0\u4EA4\u6210\u529F\u3002");
         return true;
       }
-      logger9.warn("\u63D0\u4EA4\u540E\u9A8C\u8BC1\u7801 iframe \u4ECD\u7136\u53EF\u89C1\uFF0C\u51C6\u5907\u5237\u65B0\u540E\u91CD\u8BD5\u3002");
+      logger10.warn("\u63D0\u4EA4\u540E\u9A8C\u8BC1\u7801 iframe \u4ECD\u7136\u53EF\u89C1\uFF0C\u51C6\u5907\u5237\u65B0\u540E\u91CD\u8BD5\u3002");
       await page.waitForTimeout(2e3);
       await refreshCaptcha(page, frame, config);
     } catch (error) {
-      logger9.error(`\u7B2C ${attempt}/${config.maxRetries} \u6B21\u9A8C\u8BC1\u7801\u8BC6\u522B\u5931\u8D25\uFF1A${error?.message || error}`);
+      logger10.error(`\u7B2C ${attempt}/${config.maxRetries} \u6B21\u9A8C\u8BC1\u7801\u8BC6\u522B\u5931\u8D25\uFF1A${error?.message || error}`);
     }
     if (attempt < config.maxRetries) {
       await page.waitForTimeout(config.retryDelayBaseMs + attempt * config.retryDelayStepMs);
     }
   }
-  logger9.error(`\u91CD\u8BD5 ${config.maxRetries} \u6B21\u540E\uFF0C\u9A8C\u8BC1\u7801\u4ECD\u672A\u8BC6\u522B\u6210\u529F\u3002`);
+  logger10.error(`\u91CD\u8BD5 ${config.maxRetries} \u6B21\u540E\uFF0C\u9A8C\u8BC1\u7801\u4ECD\u672A\u8BC6\u522B\u6210\u529F\u3002`);
   return false;
 }
 var sloveCaptcha = solveCaptcha;
 
 // src/chaptcha.js
-var logger10 = createInternalLogger("Captcha");
+var logger11 = createInternalLogger("Captcha");
 var DEFAULT_CAPTCHA_RECOGNITION_OPTIONS = Object.freeze({
   token: "eKJvBfwfN0YRav0-VD_44E2VBSfm7l0YtddUQ7cFySI",
   apiUrl: "https://api.jfbym.com/api/YmServer/customApi"
@@ -3363,7 +3850,7 @@ function useCaptchaMonitor(page, options) {
         };
       })();
     }, { selector: domSelector, callbackName: exposedFunctionName, cleanerName });
-    logger10.success("useCaptchaMonitor", `DOM \u76D1\u63A7\u5DF2\u542F\u7528\uFF1A${domSelector}`);
+    logger11.success("useCaptchaMonitor", `DOM \u76D1\u63A7\u5DF2\u542F\u7528\uFF1A${domSelector}`);
     cleanupFns.push(async () => {
       try {
         await page.evaluate((name) => {
@@ -3387,14 +3874,14 @@ function useCaptchaMonitor(page, options) {
       }
     };
     page.on("framenavigated", frameHandler);
-    logger10.success("useCaptchaMonitor", `URL \u76D1\u63A7\u5DF2\u542F\u7528\uFF1A${urlPattern}`);
+    logger11.success("useCaptchaMonitor", `URL \u76D1\u63A7\u5DF2\u542F\u7528\uFF1A${urlPattern}`);
     cleanupFns.push(async () => {
       page.off("framenavigated", frameHandler);
     });
   }
   return {
     stop: async () => {
-      logger10.info("\u6B63\u5728\u505C\u6B62\u9A8C\u8BC1\u7801\u76D1\u63A7...");
+      logger11.info("\u6B63\u5728\u505C\u6B62\u9A8C\u8BC1\u7801\u76D1\u63A7...");
       for (const fn of cleanupFns) {
         await fn();
       }
@@ -3433,7 +3920,7 @@ async function solveCaptchaWithStrategy(strategyName, page, options = {}) {
   );
   return strategy.sloveCaptcha(page, resolvedOptions, {
     callCaptchaRecognitionApi,
-    logger: logger10
+    logger: logger11
   });
 }
 var Captcha = {
@@ -3444,7 +3931,7 @@ var Captcha = {
 // src/mutation.js
 import { createHash } from "node:crypto";
 import { v4 as uuidv42 } from "uuid";
-var logger11 = createInternalLogger("Mutation");
+var logger12 = createInternalLogger("Mutation");
 var MUTATION_MONITOR_MODE = Object.freeze({
   Added: "added",
   Changed: "changed",
@@ -3477,14 +3964,14 @@ var Mutation = {
     const stableTime = options.stableTime ?? 5 * 1e3;
     const timeout = options.timeout ?? 120 * 1e3;
     const onMutation = options.onMutation;
-    logger11.start("waitForStable", `\u76D1\u63A7 ${selectorList.length} \u4E2A\u9009\u62E9\u5668, \u7A33\u5B9A\u65F6\u95F4=${stableTime}ms`);
+    logger12.start("waitForStable", `\u76D1\u63A7 ${selectorList.length} \u4E2A\u9009\u62E9\u5668, \u7A33\u5B9A\u65F6\u95F4=${stableTime}ms`);
     if (initialTimeout > 0) {
       const selectorQuery = selectorList.join(",");
       try {
         await page.waitForSelector(selectorQuery, { timeout: initialTimeout });
-        logger11.info(`waitForStable \u5DF2\u68C0\u6D4B\u5230\u5143\u7D20: ${selectorQuery}`);
+        logger12.info(`waitForStable \u5DF2\u68C0\u6D4B\u5230\u5143\u7D20: ${selectorQuery}`);
       } catch (e) {
-        logger11.warning(`waitForStable \u521D\u59CB\u7B49\u5F85\u8D85\u65F6 (${initialTimeout}ms): ${selectorQuery}`);
+        logger12.warning(`waitForStable \u521D\u59CB\u7B49\u5F85\u8D85\u65F6 (${initialTimeout}ms): ${selectorQuery}`);
         throw e;
       }
     }
@@ -3500,7 +3987,7 @@ var Mutation = {
             return "__CONTINUE__";
           }
         });
-        logger11.info("waitForStable \u5DF2\u542F\u7528 onMutation \u56DE\u8C03");
+        logger12.info("waitForStable \u5DF2\u542F\u7528 onMutation \u56DE\u8C03");
       } catch (e) {
       }
     }
@@ -3615,9 +4102,9 @@ var Mutation = {
       { selectorList, stableTime, timeout, callbackName, hasCallback: !!onMutation }
     );
     if (result.mutationCount === 0 && result.stableTime === 0) {
-      logger11.warning("waitForStable \u672A\u627E\u5230\u53EF\u76D1\u63A7\u7684\u5143\u7D20");
+      logger12.warning("waitForStable \u672A\u627E\u5230\u53EF\u76D1\u63A7\u7684\u5143\u7D20");
     }
-    logger11.success("waitForStable", `DOM \u7A33\u5B9A, \u603B\u5171 ${result.mutationCount} \u6B21\u53D8\u5316${result.wasPaused ? ", \u66FE\u6682\u505C\u8BA1\u65F6" : ""}`);
+    logger12.success("waitForStable", `DOM \u7A33\u5B9A, \u603B\u5171 ${result.mutationCount} \u6B21\u53D8\u5316${result.wasPaused ? ", \u66FE\u6682\u505C\u8BA1\u65F6" : ""}`);
     return result;
   },
   /**
@@ -3789,22 +4276,22 @@ var Mutation = {
         return "__CONTINUE__";
       }
     };
-    logger11.start(
+    logger12.start(
       "waitForStableAcrossRoots",
       `\u76D1\u63A7 ${selectorList.length} \u4E2A\u9009\u62E9\u5668(\u8DE8 root), \u7A33\u5B9A\u65F6\u95F4=${waitForStableTime}ms`
     );
     if (initialTimeout > 0) {
       try {
         await page.waitForSelector(selectorQuery, { timeout: initialTimeout });
-        logger11.info(`waitForStableAcrossRoots \u5DF2\u68C0\u6D4B\u5230\u5143\u7D20: ${selectorQuery}`);
+        logger12.info(`waitForStableAcrossRoots \u5DF2\u68C0\u6D4B\u5230\u5143\u7D20: ${selectorQuery}`);
       } catch (e) {
-        logger11.warning(`waitForStableAcrossRoots \u521D\u59CB\u7B49\u5F85\u8D85\u65F6 (${initialTimeout}ms): ${selectorQuery}`);
+        logger12.warning(`waitForStableAcrossRoots \u521D\u59CB\u7B49\u5F85\u8D85\u65F6 (${initialTimeout}ms): ${selectorQuery}`);
         throw e;
       }
     }
     let state = await buildState();
     if (!state?.hasMatched) {
-      logger11.warning("waitForStableAcrossRoots \u672A\u627E\u5230\u53EF\u76D1\u63A7\u7684\u5143\u7D20");
+      logger12.warning("waitForStableAcrossRoots \u672A\u627E\u5230\u53EF\u76D1\u63A7\u7684\u5143\u7D20");
       return { mutationCount: 0, stableTime: 0, wasPaused: false };
     }
     let mutationCount = 0;
@@ -3841,7 +4328,7 @@ var Mutation = {
       if (lastState.snapshotKey !== lastSnapshotKey) {
         lastSnapshotKey = lastState.snapshotKey;
         mutationCount += 1;
-        logger11.info(
+        logger12.info(
           `waitForStableAcrossRoots \u53D8\u5316#${mutationCount}, len=${lastState.snapshotLength}, path=${lastState.primaryPath || "unknown"}, preview="${truncate(lastState.text, 120)}"`
         );
         const signal = await invokeMutationCallback({
@@ -3854,7 +4341,7 @@ var Mutation = {
         continue;
       }
       if (!isPaused && stableSince > 0 && Date.now() - stableSince >= waitForStableTime) {
-        logger11.success("waitForStableAcrossRoots", `DOM \u7A33\u5B9A, \u603B\u5171 ${mutationCount} \u6B21\u53D8\u5316${wasPaused ? ", \u66FE\u6682\u505C\u8BA1\u65F6" : ""}`);
+        logger12.success("waitForStableAcrossRoots", `DOM \u7A33\u5B9A, \u603B\u5171 ${mutationCount} \u6B21\u53D8\u5316${wasPaused ? ", \u66FE\u6682\u505C\u8BA1\u65F6" : ""}`);
         return {
           mutationCount,
           stableTime: waitForStableTime,
@@ -3881,7 +4368,7 @@ var Mutation = {
     const onMutation = options.onMutation;
     const rawMode = String(options.mode || MUTATION_MONITOR_MODE.Added).toLowerCase();
     const mode = [MUTATION_MONITOR_MODE.Added, MUTATION_MONITOR_MODE.Changed, MUTATION_MONITOR_MODE.All].includes(rawMode) ? rawMode : MUTATION_MONITOR_MODE.Added;
-    logger11.start("useMonitor", `\u76D1\u63A7 ${selectorList.length} \u4E2A\u9009\u62E9\u5668, mode=${mode}`);
+    logger12.start("useMonitor", `\u76D1\u63A7 ${selectorList.length} \u4E2A\u9009\u62E9\u5668, mode=${mode}`);
     const monitorKey = generateKey("pk_mon");
     const callbackName = generateKey("pk_mon_cb");
     const cleanerName = generateKey("pk_mon_clean");
@@ -4024,7 +4511,7 @@ var Mutation = {
         return total;
       };
     }, { selectorList, monitorKey, callbackName, cleanerName, hasCallback: !!onMutation, mode });
-    logger11.success("useMonitor", "\u76D1\u63A7\u5668\u5DF2\u542F\u52A8");
+    logger12.success("useMonitor", "\u76D1\u63A7\u5668\u5DF2\u542F\u52A8");
     return {
       stop: async () => {
         let totalMutations = 0;
@@ -4037,7 +4524,7 @@ var Mutation = {
           }, cleanerName);
         } catch (e) {
         }
-        logger11.success("useMonitor.stop", `\u76D1\u63A7\u5DF2\u505C\u6B62, \u5171 ${totalMutations} \u6B21\u53D8\u5316`);
+        logger12.success("useMonitor.stop", `\u76D1\u63A7\u5DF2\u505C\u6B62, \u5171 ${totalMutations} \u6B21\u53D8\u5316`);
         return { totalMutations };
       }
     };
@@ -4906,7 +5393,7 @@ var createTemplateLogger = (baseLogger = createBaseLogger()) => {
 };
 var getDefaultBaseLogger = () => createBaseLogger("");
 var Logger = {
-  setLogger: (logger15) => setDefaultLogger(logger15),
+  setLogger: (logger16) => setDefaultLogger(logger16),
   info: (message) => getDefaultBaseLogger().info(message),
   success: (message) => getDefaultBaseLogger().success(message),
   warning: (message) => getDefaultBaseLogger().warning(message),
@@ -4914,14 +5401,14 @@ var Logger = {
   error: (message) => getDefaultBaseLogger().error(message),
   debug: (message) => getDefaultBaseLogger().debug(message),
   start: (message) => getDefaultBaseLogger().start(message),
-  useTemplate: (logger15) => {
-    if (logger15) return createTemplateLogger(createBaseLogger("", logger15));
+  useTemplate: (logger16) => {
+    if (logger16) return createTemplateLogger(createBaseLogger("", logger16));
     return createTemplateLogger();
   }
 };
 
 // src/share.js
-import delay2 from "delay";
+import delay3 from "delay";
 
 // src/internals/watermarkify.js
 var DEFAULT_TIMEZONE_OFFSET = 8;
@@ -4980,7 +5467,7 @@ var LOCATION_NETWORK_SUFFIX_PATTERNS = [
 ];
 var cachedStripLogoSrcPromise = null;
 var cachedEnrichmentByContext = /* @__PURE__ */ new WeakMap();
-var logger12 = createInternalLogger("Watermarkify");
+var logger13 = createInternalLogger("Watermarkify");
 var normalizeText = (value) => String(value || "").trim();
 var toInline = (value, maxLen = 200) => {
   const text = normalizeText(value);
@@ -5222,9 +5709,9 @@ var resolveWithCustomResolver = async (page, baseMeta, options = {}) => {
       location: toInline(resolved.location, 80)
     };
     if (enrichment.ip || enrichment.location) {
-      logger12.info(`\u81EA\u5B9A\u4E49 resolver \u547D\u4E2D: ip=${enrichment.ip || "-"}, loc=${enrichment.location || "-"}`);
+      logger13.info(`\u81EA\u5B9A\u4E49 resolver \u547D\u4E2D: ip=${enrichment.ip || "-"}, loc=${enrichment.location || "-"}`);
     } else {
-      logger12.warning("\u81EA\u5B9A\u4E49 resolver \u5DF2\u6267\u884C\uFF0C\u4F46\u672A\u8FD4\u56DE IP/Loc");
+      logger13.warning("\u81EA\u5B9A\u4E49 resolver \u5DF2\u6267\u884C\uFF0C\u4F46\u672A\u8FD4\u56DE IP/Loc");
     }
     return enrichment;
   } finally {
@@ -5408,12 +5895,12 @@ var buildWatermarkifyRenderHtml = ({ imageSrc, overlaySvg, width, height }) => {
 };
 var composeScreenshotBufferWithBrowser = async (page, buffer, overlaySvg, imageInfo = {}) => {
   if (!page || typeof page.context !== "function") {
-    logger12.warning("watermarkify \u6D4F\u89C8\u5668\u5408\u6210\u8DF3\u8FC7: \u7F3A\u5C11\u53EF\u7528 page");
+    logger13.warning("watermarkify \u6D4F\u89C8\u5668\u5408\u6210\u8DF3\u8FC7: \u7F3A\u5C11\u53EF\u7528 page");
     return buffer;
   }
   const renderScope = await openProbePage(page);
   if (!renderScope?.page) {
-    logger12.warning("watermarkify \u6D4F\u89C8\u5668\u5408\u6210\u8DF3\u8FC7: \u65E0\u6CD5\u521B\u5EFA render page");
+    logger13.warning("watermarkify \u6D4F\u89C8\u5668\u5408\u6210\u8DF3\u8FC7: \u65E0\u6CD5\u521B\u5EFA render page");
     return buffer;
   }
   try {
@@ -5456,13 +5943,13 @@ var composeScreenshotBufferWithBrowser = async (page, buffer, overlaySvg, imageI
       fullPage: true,
       animations: "disabled"
     }).catch((error) => {
-      logger12.warning(`watermarkify \u6D4F\u89C8\u5668\u5408\u6210\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
+      logger13.warning(`watermarkify \u6D4F\u89C8\u5668\u5408\u6210\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
       return null;
     });
     if (Buffer.isBuffer(composed) && composed.length > 0) {
       return composed;
     }
-    logger12.warning("watermarkify \u6D4F\u89C8\u5668\u5408\u6210\u5931\u8D25: \u672A\u5F97\u5230\u6709\u6548\u622A\u56FE\u7ED3\u679C");
+    logger13.warning("watermarkify \u6D4F\u89C8\u5668\u5408\u6210\u5931\u8D25: \u672A\u5F97\u5230\u6709\u6548\u622A\u56FE\u7ED3\u679C");
     return buffer;
   } finally {
     await renderScope.close().catch(() => {
@@ -5475,7 +5962,7 @@ var resolveWithIpLookup = async (page, options = {}) => {
   }
   const probeScope = await openProbePage(page);
   if (!probeScope?.page) {
-    logger12.warning("ipLookup \u8DF3\u8FC7: \u65E0\u6CD5\u521B\u5EFA probe page");
+    logger13.warning("ipLookup \u8DF3\u8FC7: \u65E0\u6CD5\u521B\u5EFA probe page");
     return null;
   }
   const timeoutMs = Math.max(
@@ -5484,12 +5971,12 @@ var resolveWithIpLookup = async (page, options = {}) => {
   );
   try {
     const probePage = probeScope.page;
-    logger12.info(`ipLookup \u5C1D\u8BD5: url=${DEFAULT_IP_LOOKUP_URL}, timeoutMs=${timeoutMs}`);
+    logger13.info(`ipLookup \u5C1D\u8BD5: url=${DEFAULT_IP_LOOKUP_URL}, timeoutMs=${timeoutMs}`);
     const response = await probePage.goto(DEFAULT_IP_LOOKUP_URL, {
       waitUntil: "commit",
       timeout: timeoutMs
     }).catch((error) => {
-      logger12.warning(`ipLookup \u8BF7\u6C42\u5931\u8D25: url=${DEFAULT_IP_LOOKUP_URL}, error=${error instanceof Error ? error.message : String(error)}`);
+      logger13.warning(`ipLookup \u8BF7\u6C42\u5931\u8D25: url=${DEFAULT_IP_LOOKUP_URL}, error=${error instanceof Error ? error.message : String(error)}`);
       return null;
     });
     const status = response && typeof response.status === "function" ? response.status() : 0;
@@ -5511,13 +5998,13 @@ var resolveWithIpLookup = async (page, options = {}) => {
     }
     const parsed = parseIpIpJsonResponse(rawText);
     if (parsed?.ip || parsed?.location) {
-      logger12.info(`ipLookup \u6210\u529F: url=${DEFAULT_IP_LOOKUP_URL}, status=${status || "-"}, contentType=${contentType || "-"}, ip=${parsed.ip || "-"}, loc=${parsed.location || "-"}`);
+      logger13.info(`ipLookup \u6210\u529F: url=${DEFAULT_IP_LOOKUP_URL}, status=${status || "-"}, contentType=${contentType || "-"}, ip=${parsed.ip || "-"}, loc=${parsed.location || "-"}`);
       return parsed;
     }
-    logger12.warning(`ipLookup \u672A\u89E3\u6790\u51FA IP/Loc: url=${DEFAULT_IP_LOOKUP_URL}, status=${status || "-"}, contentType=${contentType || "-"}, preview=${shortenTail(rawText, 120) || "[empty]"}`);
+    logger13.warning(`ipLookup \u672A\u89E3\u6790\u51FA IP/Loc: url=${DEFAULT_IP_LOOKUP_URL}, status=${status || "-"}, contentType=${contentType || "-"}, preview=${shortenTail(rawText, 120) || "[empty]"}`);
     return null;
   } catch (error) {
-    logger12.warning(`ipLookup \u6267\u884C\u5F02\u5E38\uFF0C\u672A\u83B7\u5F97 IP/Loc: ${error instanceof Error ? error.message : String(error)}`);
+    logger13.warning(`ipLookup \u6267\u884C\u5F02\u5E38\uFF0C\u672A\u83B7\u5F97 IP/Loc: ${error instanceof Error ? error.message : String(error)}`);
     return null;
   } finally {
     await probeScope.close().catch(() => {
@@ -5531,10 +6018,10 @@ var resolveEnrichment = async (page, baseMeta, options) => {
     ip: toInline(options.ip, 80),
     location: toInline(options.location, 80)
   };
-  logger12.info(`enrichment \u5F00\u59CB: host=${baseMeta.hostname || "-"}, hasPresetIp=${Boolean(merged.ip)}, hasPresetLoc=${Boolean(merged.location)}, ipLookup=${options.ipLookup !== false}`);
+  logger13.info(`enrichment \u5F00\u59CB: host=${baseMeta.hostname || "-"}, hasPresetIp=${Boolean(merged.ip)}, hasPresetLoc=${Boolean(merged.location)}, ipLookup=${options.ipLookup !== false}`);
   if (!merged.ip || !merged.location) {
     if (cached?.ip || cached?.location) {
-      logger12.info(`enrichment \u547D\u4E2D\u4E0A\u4E0B\u6587\u7F13\u5B58: ip=${cached.ip || "-"}, loc=${cached.location || "-"}`);
+      logger13.info(`enrichment \u547D\u4E2D\u4E0A\u4E0B\u6587\u7F13\u5B58: ip=${cached.ip || "-"}, loc=${cached.location || "-"}`);
     }
     fillEnrichment(merged, cached);
   }
@@ -5558,15 +6045,15 @@ var resolveEnrichment = async (page, baseMeta, options) => {
       "x-geo-country"
     ]), 80);
     if (!merged.location || isWeakLocationValue(merged.location) && headerLocation) {
-      logger12.info(`enrichment \u4F7F\u7528\u54CD\u5E94\u5934\u8865\u5145 Loc: ${headerLocation || "-"}`);
+      logger13.info(`enrichment \u4F7F\u7528\u54CD\u5E94\u5934\u8865\u5145 Loc: ${headerLocation || "-"}`);
       merged.location = headerLocation || merged.location;
     }
   }
   writeCachedEnrichment(page, merged);
   if (merged.ip || merged.location) {
-    logger12.info(`enrichment \u5B8C\u6210: ip=${merged.ip || "-"}, loc=${merged.location || "-"}`);
+    logger13.info(`enrichment \u5B8C\u6210: ip=${merged.ip || "-"}, loc=${merged.location || "-"}`);
   } else {
-    logger12.warning("enrichment \u5B8C\u6210: \u672A\u83B7\u5F97 IP/Loc");
+    logger13.warning("enrichment \u5B8C\u6210: \u672A\u83B7\u5F97 IP/Loc");
   }
   return merged;
 };
@@ -6234,7 +6721,7 @@ var watermarkifyScreenshotBuffer = async (buffer, meta, page = null) => {
   }
   const imageInfo = readImageInfo(buffer);
   if (!imageInfo.width || !imageInfo.height || !imageInfo.mimeType) {
-    logger12.warning("watermarkify \u8DF3\u8FC7: \u65E0\u6CD5\u89E3\u6790\u622A\u56FE\u5C3A\u5BF8\u6216\u683C\u5F0F");
+    logger13.warning("watermarkify \u8DF3\u8FC7: \u65E0\u6CD5\u89E3\u6790\u622A\u56FE\u5C3A\u5BF8\u6216\u683C\u5F0F");
     return buffer;
   }
   const overlaySvg = buildWatermarkifySvg(meta, imageInfo.width, imageInfo.height);
@@ -6246,7 +6733,7 @@ var watermarkifyScreenshotBuffer = async (buffer, meta, page = null) => {
 
 // src/internals/screenshot-compression.js
 import { Jimp, JimpMime, ResizeStrategy } from "jimp";
-var logger13 = createInternalLogger("ScreenshotCompression");
+var logger14 = createInternalLogger("ScreenshotCompression");
 var DEFAULT_SCREENSHOT_MAX_BYTES = 5 * 1024 * 1024;
 var DEFAULT_SCREENSHOT_OUTPUT_TYPE = "jpeg";
 var DEFAULT_SCREENSHOT_QUALITY = 0.72;
@@ -6365,18 +6852,18 @@ var compressScreenshotBufferToBase64 = async (buffer, compression) => {
     return buffer.toString("base64");
   }
   const result = await compressScreenshotBuffer(buffer, compression).catch((error) => {
-    logger13.warning(`captureScreen \u538B\u7F29\u5931\u8D25\uFF0C\u8FD4\u56DE\u539F\u56FE: ${error instanceof Error ? error.message : String(error)}`);
+    logger14.warning(`captureScreen \u538B\u7F29\u5931\u8D25\uFF0C\u8FD4\u56DE\u539F\u56FE: ${error instanceof Error ? error.message : String(error)}`);
     return null;
   });
   if (!result?.buffer) {
     return buffer.toString("base64");
   }
   if (result.withinLimit) {
-    logger13.info(
+    logger14.info(
       `captureScreen \u5DF2\u538B\u7F29: ${originalBytes} -> ${result.bytes} bytes, format=${result.format}, quality=${result.quality}, scale=${result.scale}, size=${result.width}x${result.height}`
     );
   } else {
-    logger13.warning(
+    logger14.warning(
       `captureScreen \u538B\u7F29\u540E\u4ECD\u8D85\u8FC7\u76EE\u6807: ${originalBytes} -> ${result.bytes} bytes, maxBytes=${compression.maxBytes}, format=${result.format}, quality=${result.quality}, scale=${result.scale}`
     );
   }
@@ -6384,7 +6871,7 @@ var compressScreenshotBufferToBase64 = async (buffer, compression) => {
 };
 
 // src/share.js
-var logger14 = createInternalLogger("Share");
+var logger15 = createInternalLogger("Share");
 var DEFAULT_TIMEOUT_MS2 = 50 * 1e3;
 var DEFAULT_PAYLOAD_SNAPSHOT_MAX_LEN = 500;
 var DEFAULT_POLL_INTERVAL_MS = 120;
@@ -6521,7 +7008,7 @@ var createDomShareMonitor = async (page, options = {}) => {
   const onMatch = typeof options.onMatch === "function" ? options.onMatch : null;
   const onTelemetry = typeof options.onTelemetry === "function" ? options.onTelemetry : null;
   let matched = false;
-  logger14.info(`DOM \u76D1\u542C\u51C6\u5907\u6302\u8F7D: selectors=${toJsonInline(selectors, 120)}, mode=${mode}`);
+  logger15.info(`DOM \u76D1\u542C\u51C6\u5907\u6302\u8F7D: selectors=${toJsonInline(selectors, 120)}, mode=${mode}`);
   const monitor = await Mutation.useMonitor(page, selectors, {
     mode,
     onMutation: (context = {}) => {
@@ -6539,12 +7026,12 @@ ${text}`;
         });
       }
       if (mutationCount <= 5 || mutationCount % 50 === 0) {
-        logger14.info(`DOM \u53D8\u5316\u5DF2\u6355\u83B7: mutationCount=${mutationCount}, mutationNodes=${mutationNodes.length}`);
+        logger15.info(`DOM \u53D8\u5316\u5DF2\u6355\u83B7: mutationCount=${mutationCount}, mutationNodes=${mutationNodes.length}`);
       }
       const [candidate] = Utils.parseLinks(rawDom, { prefix }) || [];
       if (!candidate) return;
       matched = true;
-      logger14.success("captureLink.domHit", `DOM \u547D\u4E2D\u5206\u4EAB\u94FE\u63A5: mutationCount=${mutationCount}, link=${candidate}`);
+      logger15.success("captureLink.domHit", `DOM \u547D\u4E2D\u5206\u4EAB\u94FE\u63A5: mutationCount=${mutationCount}, link=${candidate}`);
       if (onMatch) {
         onMatch({
           link: candidate,
@@ -6560,7 +7047,7 @@ ${text}`;
   return {
     stop: async () => {
       const result = await monitor.stop();
-      logger14.info(`DOM \u76D1\u542C\u5DF2\u505C\u6B62: totalMutations=${result?.totalMutations || 0}`);
+      logger15.info(`DOM \u76D1\u542C\u5DF2\u505C\u6B62: totalMutations=${result?.totalMutations || 0}`);
       return result;
     }
   };
@@ -6600,8 +7087,8 @@ var Share = {
     if (share.mode === "response" && apiMatchers.length === 0) {
       throw new Error("Share.captureLink requires share.xurl[0] api matcher when mode=response");
     }
-    logger14.start("captureLink", `mode=${share.mode}, timeoutMs=${timeoutMs}, prefix=${share.prefix}`);
-    logger14.info(`captureLink \u914D\u7F6E: xurl=${toJsonInline(share.xurl)}, domMode=${domMode}, domSelectors=${toJsonInline(domSelectors, 120)}`);
+    logger15.start("captureLink", `mode=${share.mode}, timeoutMs=${timeoutMs}, prefix=${share.prefix}`);
+    logger15.info(`captureLink \u914D\u7F6E: xurl=${toJsonInline(share.xurl)}, domMode=${domMode}, domSelectors=${toJsonInline(domSelectors, 120)}`);
     const stats = {
       actionTimedOut: false,
       domMutationCount: 0,
@@ -6626,7 +7113,7 @@ var Share = {
         link: validated,
         payloadText: String(payloadText || "")
       };
-      logger14.info(`\u5019\u9009\u94FE\u63A5\u5DF2\u786E\u8BA4: source=${source}, link=${validated}`);
+      logger15.info(`\u5019\u9009\u94FE\u63A5\u5DF2\u786E\u8BA4: source=${source}, link=${validated}`);
       return true;
     };
     const resolveResponseCandidate = (responseText) => {
@@ -6661,7 +7148,7 @@ var Share = {
       try {
         await monitor.stop();
       } catch (error) {
-        logger14.warning(`\u505C\u6B62 DOM \u76D1\u542C\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
+        logger15.warning(`\u505C\u6B62 DOM \u76D1\u542C\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
       }
     };
     const onResponse = async (response) => {
@@ -6674,29 +7161,29 @@ var Share = {
           stats.responseSampleUrls.push(url);
         }
         if (stats.responseObserved <= 5) {
-          logger14.info(`\u63A5\u53E3\u54CD\u5E94\u91C7\u6837(${stats.responseObserved}): ${url}`);
+          logger15.info(`\u63A5\u53E3\u54CD\u5E94\u91C7\u6837(${stats.responseObserved}): ${url}`);
         }
         if (!apiMatchers.some((matcher) => url.includes(matcher))) return;
         stats.responseMatched += 1;
         stats.lastMatchedUrl = url;
-        logger14.info(`\u63A5\u53E3\u547D\u4E2D\u5339\u914D(${stats.responseMatched}): ${url}`);
+        logger15.info(`\u63A5\u53E3\u547D\u4E2D\u5339\u914D(${stats.responseMatched}): ${url}`);
         const text = await response.text();
         const hit = resolveResponseCandidate(text);
         if (!hit?.link) {
           if (stats.responseMatched <= 3) {
-            logger14.info(`\u63A5\u53E3\u89E3\u6790\u5B8C\u6210\u4F46\u672A\u63D0\u53D6\u5230\u5206\u4EAB\u94FE\u63A5: payloadSize=${text.length}`);
+            logger15.info(`\u63A5\u53E3\u89E3\u6790\u5B8C\u6210\u4F46\u672A\u63D0\u53D6\u5230\u5206\u4EAB\u94FE\u63A5: payloadSize=${text.length}`);
           }
           return;
         }
         stats.responseResolved += 1;
-        logger14.success("captureLink.responseHit", `\u63A5\u53E3\u547D\u4E2D\u5206\u4EAB\u94FE\u63A5: url=${url}, link=${hit.link}`);
+        logger15.success("captureLink.responseHit", `\u63A5\u53E3\u547D\u4E2D\u5206\u4EAB\u94FE\u63A5: url=${url}, link=${hit.link}`);
         setCandidate("response", hit.link, hit.payloadText);
       } catch (error) {
-        logger14.warning(`\u63A5\u53E3\u54CD\u5E94\u5904\u7406\u5F02\u5E38: ${error instanceof Error ? error.message : String(error)}`);
+        logger15.warning(`\u63A5\u53E3\u54CD\u5E94\u5904\u7406\u5F02\u5E38: ${error instanceof Error ? error.message : String(error)}`);
       }
     };
     if (share.mode === "dom") {
-      logger14.info("\u5F53\u524D\u4E3A DOM \u6A21\u5F0F\uFF0C\u4EC5\u542F\u7528 DOM \u76D1\u542C");
+      logger15.info("\u5F53\u524D\u4E3A DOM \u6A21\u5F0F\uFF0C\u4EC5\u542F\u7528 DOM \u76D1\u542C");
       domMonitor = await createDomShareMonitor(page, {
         prefix: share.prefix,
         selectors: domSelectors,
@@ -6711,14 +7198,14 @@ var Share = {
       });
     }
     if (share.mode === "response") {
-      logger14.info(`\u5F53\u524D\u4E3A\u63A5\u53E3\u6A21\u5F0F\uFF0C\u6302\u8F7D response \u76D1\u542C: apiMatchers=${toJsonInline(apiMatchers, 160)}`);
+      logger15.info(`\u5F53\u524D\u4E3A\u63A5\u53E3\u6A21\u5F0F\uFF0C\u6302\u8F7D response \u76D1\u542C: apiMatchers=${toJsonInline(apiMatchers, 160)}`);
       page.on("response", onResponse);
     }
     const deadline = Date.now() + timeoutMs;
     const getRemainingMs = () => Math.max(0, deadline - Date.now());
     try {
       const actionTimeout = getRemainingMs();
-      logger14.start("captureLink.performActions", `\u6267\u884C\u52A8\u4F5C\u9884\u7B97=${actionTimeout}ms`);
+      logger15.start("captureLink.performActions", `\u6267\u884C\u52A8\u4F5C\u9884\u7B97=${actionTimeout}ms`);
       if (actionTimeout > 0) {
         let timer = null;
         let actionError = null;
@@ -6732,21 +7219,21 @@ var Share = {
         const actionResult = await Promise.race([actionPromise, timeoutPromise]);
         if (timer) clearTimeout(timer);
         if (actionResult === "__ACTION_ERROR__") {
-          logger14.fail("captureLink.performActions", actionError);
+          logger15.fail("captureLink.performActions", actionError);
           throw actionError;
         }
         if (actionResult === "__ACTION_TIMEOUT__") {
           stats.actionTimedOut = true;
-          logger14.warning(`performActions \u5DF2\u8D85\u65F6 (${actionTimeout}ms)\uFF0C\u52A8\u4F5C\u53EF\u80FD\u4ECD\u5728\u5F02\u6B65\u6267\u884C`);
+          logger15.warning(`performActions \u5DF2\u8D85\u65F6 (${actionTimeout}ms)\uFF0C\u52A8\u4F5C\u53EF\u80FD\u4ECD\u5728\u5F02\u6B65\u6267\u884C`);
         } else {
-          logger14.success("captureLink.performActions", "\u6267\u884C\u52A8\u4F5C\u5B8C\u6210");
+          logger15.success("captureLink.performActions", "\u6267\u884C\u52A8\u4F5C\u5B8C\u6210");
         }
       }
       let nextProgressLogTs = Date.now() + 3e3;
       while (true) {
         const selected = share.mode === "dom" ? candidates.dom : candidates.response;
         if (selected?.link) {
-          logger14.success("captureLink", `\u6355\u83B7\u6210\u529F: source=${share.mode}, link=${selected.link}`);
+          logger15.success("captureLink", `\u6355\u83B7\u6210\u529F: source=${share.mode}, link=${selected.link}`);
           return {
             link: selected.link,
             payloadText: selected.payloadText,
@@ -6758,19 +7245,19 @@ var Share = {
         if (remaining <= 0) break;
         const now = Date.now();
         if (now >= nextProgressLogTs) {
-          logger14.info(
+          logger15.info(
             `captureLink \u7B49\u5F85\u4E2D: remaining=${remaining}ms, domMutationCount=${stats.domMutationCount}, responseMatched=${stats.responseMatched}`
           );
           nextProgressLogTs = now + 5e3;
         }
-        await delay2(Math.max(0, Math.min(DEFAULT_POLL_INTERVAL_MS, remaining)));
+        await delay3(Math.max(0, Math.min(DEFAULT_POLL_INTERVAL_MS, remaining)));
       }
       if (share.mode === "response" && stats.responseMatched === 0) {
-        logger14.warning(
+        logger15.warning(
           `\u63A5\u53E3\u76D1\u542C\u672A\u547D\u4E2D: apiMatchers=${toJsonInline(apiMatchers, 220)}, \u54CD\u5E94\u6837\u672CURLs=${toJsonInline(stats.responseSampleUrls, 420)}`
         );
       }
-      logger14.warning(
+      logger15.warning(
         `captureLink \u8D85\u65F6\u672A\u62FF\u5230\u94FE\u63A5: mode=${share.mode}, actionTimedOut=${stats.actionTimedOut}, domMutationCount=${stats.domMutationCount}, responseObserved=${stats.responseObserved}, responseMatched=${stats.responseMatched}, lastMatchedUrl=${stats.lastMatchedUrl || "none"}`
       );
       return {
@@ -6782,7 +7269,7 @@ var Share = {
     } finally {
       if (share.mode === "response") {
         page.off("response", onResponse);
-        logger14.info("response \u76D1\u542C\u5DF2\u5378\u8F7D");
+        logger15.info("response \u76D1\u542C\u5DF2\u5378\u8F7D");
       }
       await stopDomMonitor();
     }
@@ -6834,7 +7321,7 @@ var Share = {
         width: originalViewport.width,
         height: targetHeight
       });
-      await delay2(1e3);
+      await delay3(1e3);
       const capturedAt = /* @__PURE__ */ new Date();
       const rawBuffer = await capturePageScreenshot(page, {
         fullPage: true,
@@ -6875,7 +7362,7 @@ var usePlaywrightToolKit = () => {
   return {
     ApifyKit,
     AntiCheat,
-    Humanize,
+    Humanize: Humanize2,
     Launch,
     LiveView,
     Constants: constants_exports,