@skrillex1224/playwright-toolkit 2.1.280 → 2.1.281

package/dist/index.js

@@ -4703,143 +4703,91 @@ var DefaultHumanize = {
 
 // src/internals/humanize/cloakbrowser.js
 import delay4 from "delay";
-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 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 resolveNativeTarget2 = (page, target) => typeof target === "string" ? page.locator(target).first() : target;
-var targetExists = async (target) => {
-  if (!target) {
-    return false;
-  }
-  if (typeof target.count === "function") {
-    const count = await target.count().catch(() => 0);
-    return count > 0;
-  }
-  if (typeof target.elementHandle === "function") {
-    const handle = await target.elementHandle().catch(() => null);
-    try {
-      return Boolean(handle);
-    } finally {
-      await handle?.dispose?.().catch(() => {
-      });
-    }
-  }
-  return true;
+var getViewportCenter = (page) => {
+  const viewport = page?.viewportSize?.() || { width: 1365, height: 900 };
+  return {
+    x: Math.round(viewport.width / 2),
+    y: Math.round(viewport.height / 2)
+  };
 };
-var getTargetBoundingBox2 = async (target) => {
-  if (!target) {
+var readViewportScroll = async (page) => await page.evaluate(() => ({ x: window.scrollX, y: window.scrollY })).catch(() => ({ x: 0, y: 0 }));
+var getTargetBox = async (target) => {
+  if (!target || typeof target.boundingBox !== "function") {
     return null;
   }
-  if (typeof target.boundingBox === "function") {
-    return await target.boundingBox().catch(() => null);
-  }
-  if (typeof target.elementHandle === "function") {
-    const handle = await target.elementHandle().catch(() => null);
-    try {
-      return await handle?.boundingBox?.().catch(() => null);
-    } finally {
-      await handle?.dispose?.().catch(() => {
-      });
-    }
-  }
-  return null;
+  return await target.boundingBox().catch(() => null);
 };
-var resolveActionTarget = async (page, target, { throwOnMissing = true } = {}) => {
-  if (target == null) {
-    return null;
-  }
-  const resolvedTarget = resolveNativeTarget2(page, target);
-  if (throwOnMissing || await targetExists(resolvedTarget)) {
-    return resolvedTarget;
+var clickOptionsFrom = (options = {}) => {
+  const nextOptions = {
+    force: true
+  };
+  if (options.timeout != null) {
+    nextOptions.timeout = options.timeout;
   }
-  return null;
-};
-var readViewportScroll = async (page) => {
-  return await page.evaluate(() => ({ x: window.scrollX, y: window.scrollY })).catch(() => ({ x: 0, y: 0 }));
+  return nextOptions;
 };
-var buildTypingHumanConfig = (options = {}) => {
-  const humanConfig = {};
-  if (Number.isFinite(Number(options.baseDelay))) {
-    humanConfig.typing_delay = Number(options.baseDelay);
+var typeOptionsFrom = (options = {}) => {
+  const nextOptions = {};
+  if (options.timeout != null) {
+    nextOptions.timeout = options.timeout;
   }
-  if (Number.isFinite(Number(options.pauseProbability))) {
-    humanConfig.typing_pause_chance = Number(options.pauseProbability);
-  }
-  if (Number.isFinite(Number(options.pauseBase))) {
-    const basePause = Math.max(40, Number(options.pauseBase));
-    humanConfig.typing_pause_range = [
-      Math.round(basePause * 0.5),
-      Math.round(basePause * 1.5)
-    ];
+  if (options.baseDelay != null) {
+    nextOptions.delay = Math.max(0, Number(options.baseDelay) || 0);
   }
-  return Object.keys(humanConfig).length > 0 ? humanConfig : null;
+  return nextOptions;
 };
-var buildActionOptions = (options = {}) => {
-  const actionOptions = {
-    force: true
-  };
-  if (options && options.timeout != null) {
-    actionOptions.timeout = options.timeout;
+var pressOptionsFrom = (options = {}) => {
+  const nextOptions = {};
+  if (options.timeout != null) {
+    nextOptions.timeout = options.timeout;
   }
-  const humanConfig = buildTypingHumanConfig(options);
-  if (humanConfig) {
-    actionOptions.human_config = humanConfig;
+  if (options.holdDelay != null) {
+    nextOptions.delay = Math.max(0, Number(options.holdDelay) || 0);
   }
-  return actionOptions;
+  return nextOptions;
 };
-var jitterSleep = async (baseMs, jitterPercent = 0.3) => {
+var waitDesktopJitter = async (baseMs, jitterPercent = 0.3) => {
   await delay4(jitterMs(baseMs, jitterPercent));
 };
-var moveCursorToPoint = async (page, point) => {
-  await page.mouse.move(Number(point.x), Number(point.y));
-  return true;
-};
-var CloakBrowserHumanize = {
+var DesktopCloakHumanize = {
   jitterMs(base, jitterPercent = 0.3) {
     return jitterMs(base, jitterPercent);
   },
   async initializeCursor(page) {
-    if (isMobilePage(page)) {
-      return await MobileHumanize.initializeCursor(page);
-    }
     return Boolean(page);
   },
   async humanMove(page, target) {
-    if (isMobilePage(page)) {
-      return await MobileHumanize.humanMove(page, target);
+    if (target == null) {
+      return false;
     }
     if (isPoint2(target)) {
-      return await moveCursorToPoint(page, target);
-    }
-    const resolvedTarget = await resolveActionTarget(page, target, { throwOnMissing: false });
-    if (!resolvedTarget) {
-      return false;
+      await page.mouse.move(Number(target.x), Number(target.y));
+      return true;
     }
-    if (typeof resolvedTarget.hover === "function") {
-      await resolvedTarget.hover({ force: true });
+    const resolvedTarget = resolveNativeTarget2(page, target);
+    if (typeof resolvedTarget?.hover === "function") {
+      await resolvedTarget.hover(clickOptionsFrom());
       return true;
     }
-    const box = await getTargetBoundingBox2(resolvedTarget);
+    const box = await getTargetBox(resolvedTarget);
     if (!box) {
       return false;
     }
-    return await moveCursorToPoint(page, {
-      x: box.x + box.width / 2,
-      y: box.y + box.height / 2
-    });
+    await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
+    return true;
   },
-  async humanScroll(page, target, options = {}) {
-    if (isMobilePage(page)) {
-      return await MobileHumanize.humanScroll(page, target, options);
-    }
-    const resolvedTarget = await resolveActionTarget(page, target, { throwOnMissing: false });
+  async humanScroll(page, target) {
+    const resolvedTarget = resolveNativeTarget2(page, target);
     if (!resolvedTarget) {
       return { element: null, didScroll: false, restore: null };
     }
     const before = await readViewportScroll(page);
-    await resolvedTarget.scrollIntoViewIfNeeded?.().catch(() => {
-    });
+    await resolvedTarget.scrollIntoViewIfNeeded?.();
     const after = await readViewportScroll(page);
     return {
       element: resolvedTarget,
@@ -4848,183 +4796,156 @@ var CloakBrowserHumanize = {
     };
   },
   async humanClick(page, target, options = {}) {
-    if (isMobilePage(page)) {
-      return await MobileHumanize.humanClick(page, target, options);
-    }
     if (target == null) {
-      const { x = 0, y = 0 } = page?._humanCursor || {};
-      await page.mouse.click(x || 0, y || 0);
+      const center = getViewportCenter(page);
+      await page.mouse.click(center.x, center.y);
       return true;
     }
     if (isPoint2(target)) {
       await page.mouse.click(Number(target.x), Number(target.y));
       return true;
     }
-    const resolvedTarget = await resolveActionTarget(page, target, {
-      throwOnMissing: options.throwOnMissing !== false
-    });
-    if (!resolvedTarget) {
-      return false;
+    if (typeof target === "string") {
+      await page.click(target, clickOptionsFrom(options));
+      return true;
     }
-    if (typeof resolvedTarget.click === "function") {
-      await resolvedTarget.click(buildActionOptions(options));
+    if (typeof target?.click === "function") {
+      await target.click(clickOptionsFrom(options));
       return true;
     }
-    const box = await getTargetBoundingBox2(resolvedTarget);
+    const box = await getTargetBox(target);
     if (!box) {
-      if (options.throwOnMissing !== false) {
-        throw new Error("\u65E0\u6CD5\u83B7\u53D6\u5143\u7D20\u4F4D\u7F6E");
-      }
       return false;
     }
     await page.mouse.click(box.x + box.width / 2, box.y + box.height / 2);
     return true;
   },
-  async randomSleep(pageOrBaseMs, maybeBaseMs, maybeJitterPercent) {
-    if (isPageLike2(pageOrBaseMs)) {
-      if (isMobilePage(pageOrBaseMs)) {
-        return await MobileHumanize.randomSleep(maybeBaseMs, maybeJitterPercent);
-      }
-      await jitterSleep(maybeBaseMs, maybeJitterPercent ?? 0.3);
-      return;
-    }
-    await jitterSleep(pageOrBaseMs, maybeBaseMs ?? 0.3);
+  async randomSleep(baseMs, jitterPercent = 0.3) {
+    await waitDesktopJitter(baseMs, jitterPercent);
   },
   async simulateGaze(page, baseDurationMs = 2500) {
-    if (isMobilePage(page)) {
-      return await MobileHumanize.simulateGaze(page, baseDurationMs);
-    }
     const durationMs = jitterMs(baseDurationMs, 0.4);
-    const startTime = Date.now();
-    const viewportSize = page.viewportSize() || { width: 1365, height: 900 };
-    while (Date.now() - startTime < durationMs) {
+    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, viewportSize.width - 200),
-        100 + Math.random() * Math.max(120, viewportSize.height - 200)
+        100 + Math.random() * Math.max(120, viewport.width - 200),
+        100 + Math.random() * Math.max(120, viewport.height - 200)
       );
-      await jitterSleep(600, 0.5);
+      await waitDesktopJitter(600, 0.5);
     }
   },
   async humanType(page, selector, text, options = {}) {
-    if (isMobilePage(page)) {
-      return await MobileHumanize.humanType(page, selector, text, options);
-    }
-    const actionOptions = buildActionOptions(options);
     if (typeof selector === "string") {
-      await page.type(selector, text, actionOptions);
+      await page.type(selector, text, typeOptionsFrom(options));
       return;
     }
-    const resolvedTarget = await resolveActionTarget(page, selector, { throwOnMissing: true });
-    if (!resolvedTarget || typeof resolvedTarget.type !== "function") {
-      throw new Error("\u76EE\u6807\u5143\u7D20\u4E0D\u652F\u6301 type()");
-    }
-    await resolvedTarget.type(text, actionOptions);
+    await selector.type(text, typeOptionsFrom(options));
   },
   async humanPress(page, targetOrKey, maybeKey, options = {}) {
-    if (isMobilePage(page)) {
-      return await MobileHumanize.humanPress(page, targetOrKey, maybeKey, options);
-    }
     const hasTarget = typeof maybeKey === "string";
     const key = hasTarget ? maybeKey : targetOrKey;
     const pressOptions = hasTarget ? options : maybeKey || options;
     if (!hasTarget) {
-      await jitterSleep(pressOptions.reactionDelay ?? 180, 0.45);
-      await page.keyboard.press(key, {
-        ...pressOptions.keyboardOptions || {},
-        delay: jitterMs(pressOptions.holdDelay ?? 45, 0.5)
-      });
+      await page.keyboard.press(key, pressOptionsFrom(pressOptions));
       return true;
     }
     if (typeof targetOrKey === "string") {
-      await page.press(targetOrKey, key, buildActionOptions(pressOptions));
+      await page.press(targetOrKey, key, pressOptionsFrom(pressOptions));
       return true;
     }
-    const resolvedTarget = await resolveActionTarget(page, targetOrKey, {
-      throwOnMissing: pressOptions.throwOnMissing !== false
-    });
-    if (!resolvedTarget) {
-      return false;
-    }
-    if (typeof resolvedTarget.press === "function") {
-      await resolvedTarget.press(key, buildActionOptions(pressOptions));
+    if (typeof targetOrKey?.press === "function") {
+      await targetOrKey.press(key, pressOptionsFrom(pressOptions));
       return true;
     }
-    await this.humanClick(page, targetOrKey, {
-      ...pressOptions,
-      reactionDelay: pressOptions.focusDelay ?? 180
-    });
-    await jitterSleep(pressOptions.reactionDelay ?? 180, 0.45);
-    await page.keyboard.press(key, {
-      ...pressOptions.keyboardOptions || {},
-      delay: jitterMs(pressOptions.holdDelay ?? 45, 0.5)
-    });
+    await page.keyboard.press(key, pressOptionsFrom(pressOptions));
     return true;
   },
   async humanClear(page, selector) {
-    if (isMobilePage(page)) {
-      return await MobileHumanize.humanClear(page, selector);
-    }
     if (typeof selector === "string") {
       if (typeof page.clear === "function") {
-        await page.clear(selector, { force: true });
+        await page.clear(selector, clickOptionsFrom());
         return;
       }
-      await page.fill(selector, "", { force: true });
+      await page.fill(selector, "", clickOptionsFrom());
       return;
     }
-    const resolvedTarget = await resolveActionTarget(page, selector, { throwOnMissing: true });
-    if (!resolvedTarget) {
-      throw new Error("\u76EE\u6807\u5143\u7D20\u4E0D\u652F\u6301 clear()");
-    }
-    if (typeof resolvedTarget.clear === "function") {
-      await resolvedTarget.clear(buildActionOptions());
+    if (typeof selector?.clear === "function") {
+      await selector.clear(clickOptionsFrom());
       return;
     }
-    if (typeof resolvedTarget.fill === "function") {
-      await resolvedTarget.fill("", buildActionOptions());
+    if (typeof selector?.fill === "function") {
+      await selector.fill("", clickOptionsFrom());
       return;
     }
-    throw new Error("\u76EE\u6807\u5143\u7D20\u4E0D\u652F\u6301 clear()");
   },
   async warmUpBrowsing(page, baseDuration = 3500) {
-    if (isMobilePage(page)) {
-      return await MobileHumanize.warmUpBrowsing(page, baseDuration);
-    }
     const durationMs = jitterMs(baseDuration, 0.4);
-    const startTime = Date.now();
-    const viewportSize = page.viewportSize() || { width: 1365, height: 900 };
-    while (Date.now() - startTime < durationMs) {
-      const action = Math.random();
-      if (action < 0.4) {
-        await page.mouse.move(
-          100 + Math.random() * Math.max(120, viewportSize.width - 200),
-          100 + Math.random() * Math.max(120, viewportSize.height - 200)
-        );
-        await jitterSleep(350, 0.4);
-        continue;
-      }
-      if (action < 0.7) {
-        await page.mouse.wheel(0, (Math.random() - 0.5) * 220);
-        await jitterSleep(500, 0.4);
-        continue;
-      }
-      await jitterSleep(800, 0.5);
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < durationMs) {
+      await this.simulateGaze(page, 240);
+      await this.naturalScroll(page, Math.random() > 0.4 ? "down" : "up", 160, 3);
+      await waitDesktopJitter(250, 0.35);
     }
   },
   async naturalScroll(page, direction = "down", distance = 300, baseSteps = 5) {
-    if (isMobilePage(page)) {
-      return await MobileHumanize.naturalScroll(page, direction, distance, baseSteps);
-    }
-    const steps = Math.max(3, baseSteps + Math.floor(Math.random() * 3) - 1);
-    const actualDistance = jitterMs(distance, 0.15);
+    const steps = Math.max(1, Number(baseSteps) || 1);
+    const stepDistance = (Number(distance) || 0) / steps;
     const sign = direction === "down" ? 1 : -1;
-    const stepDistance = actualDistance / steps;
     for (let index = 0; index < steps; index += 1) {
-      const factor = 1 - index / steps * 0.5;
-      const jitter = 0.9 + Math.random() * 0.2;
-      await page.mouse.wheel(0, stepDistance * factor * sign * jitter);
-      await jitterSleep(60 + index * 25, 0.3);
+      await page.mouse.wheel(0, stepDistance * sign);
+      await waitDesktopJitter(60 + index * 20, 0.3);
+    }
+  }
+};
+var resolveDelegate2 = (page) => isMobilePage(page) ? MobileHumanize : DesktopCloakHumanize;
+var callDelegate2 = (method, page, args) => {
+  const delegate = resolveDelegate2(page);
+  return delegate[method](page, ...args);
+};
+var CloakBrowserHumanize = {
+  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)) {
+      const delegate = resolveDelegate2(pageOrBaseMs);
+      return delegate.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]);
   }
 };