@skrillex1224/playwright-toolkit 2.1.280 → 2.1.282

package/dist/index.js

@@ -4703,330 +4703,149 @@ 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 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 getTargetBoundingBox2 = async (target) => {
-  if (!target) {
-    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;
-};
-var resolveActionTarget = async (page, target, { throwOnMissing = true } = {}) => {
-  if (target == null) {
-    return null;
-  }
-  const resolvedTarget = resolveNativeTarget2(page, target);
-  if (throwOnMissing || await targetExists(resolvedTarget)) {
-    return resolvedTarget;
-  }
-  return null;
-};
-var readViewportScroll = async (page) => {
-  return await page.evaluate(() => ({ x: window.scrollX, y: window.scrollY })).catch(() => ({ x: 0, y: 0 }));
-};
-var buildTypingHumanConfig = (options = {}) => {
-  const humanConfig = {};
-  if (Number.isFinite(Number(options.baseDelay))) {
-    humanConfig.typing_delay = Number(options.baseDelay);
-  }
-  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)
-    ];
-  }
-  return Object.keys(humanConfig).length > 0 ? humanConfig : null;
-};
-var buildActionOptions = (options = {}) => {
-  const actionOptions = {
-    force: true
-  };
-  if (options && options.timeout != null) {
-    actionOptions.timeout = options.timeout;
-  }
-  const humanConfig = buildTypingHumanConfig(options);
-  if (humanConfig) {
-    actionOptions.human_config = humanConfig;
-  }
-  return actionOptions;
-};
-var jitterSleep = 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 isPageLike2 = (value) => value && typeof value === "object" && typeof value.evaluate === "function";
+var isPoint2 = (value) => value && typeof value === "object" && Number.isFinite(Number(value.x)) && Number.isFinite(Number(value.y));
+var resolveTarget = (page, target) => typeof target === "string" ? page.locator(target).first() : target;
+var sleep = (base, jitter = 0.3) => delay4(jitterMs(base, jitter));
+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;
-    }
-    if (typeof resolvedTarget.hover === "function") {
-      await resolvedTarget.hover({ force: true });
+      await page.mouse.move(Number(target.x), Number(target.y));
       return true;
     }
-    const box = await getTargetBoundingBox2(resolvedTarget);
-    if (!box) {
-      return false;
-    }
-    return await moveCursorToPoint(page, {
-      x: box.x + box.width / 2,
-      y: box.y + box.height / 2
-    });
+    await resolveTarget(page, target).hover();
+    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 });
-    if (!resolvedTarget) {
-      return { element: null, didScroll: false, restore: null };
-    }
-    const before = await readViewportScroll(page);
-    await resolvedTarget.scrollIntoViewIfNeeded?.().catch(() => {
-    });
-    const after = await readViewportScroll(page);
-    return {
-      element: resolvedTarget,
-      didScroll: before.x !== after.x || before.y !== after.y,
-      restore: null
-    };
+  async humanScroll(page, target) {
+    const element = resolveTarget(page, target);
+    if (!element) return { element: null, didScroll: false, restore: null };
+    await element.scrollIntoViewIfNeeded?.();
+    return { element, didScroll: true, restore: null };
   },
-  async humanClick(page, target, options = {}) {
-    if (isMobilePage(page)) {
-      return await MobileHumanize.humanClick(page, target, options);
-    }
+  async humanClick(page, target) {
     if (target == null) {
-      const { x = 0, y = 0 } = page?._humanCursor || {};
-      await page.mouse.click(x || 0, y || 0);
+      await page.mouse.click(0, 0);
       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 resolvedTarget.click === "function") {
-      await resolvedTarget.click(buildActionOptions(options));
+    if (typeof target === "string") {
+      await page.click(target);
       return true;
     }
-    const box = await getTargetBoundingBox2(resolvedTarget);
-    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);
+    await target.click();
     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 sleep(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 sleep(300, 0.5);
     }
   },
-  async humanType(page, selector, text, options = {}) {
-    if (isMobilePage(page)) {
-      return await MobileHumanize.humanType(page, selector, text, options);
-    }
-    const actionOptions = buildActionOptions(options);
+  async humanType(page, selector, text) {
     if (typeof selector === "string") {
-      await page.type(selector, text, actionOptions);
+      await page.type(selector, text);
       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);
   },
-  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)
-      });
+  async humanPress(page, targetOrKey, maybeKey) {
+    if (typeof maybeKey !== "string") {
+      await page.keyboard.press(targetOrKey);
       return true;
     }
     if (typeof targetOrKey === "string") {
-      await page.press(targetOrKey, key, buildActionOptions(pressOptions));
+      await page.press(targetOrKey, maybeKey);
       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));
-      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 targetOrKey.press(maybeKey);
     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 });
-        return;
-      }
-      await page.fill(selector, "", { force: true });
-      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());
+      await page.fill(selector, "");
       return;
     }
-    if (typeof resolvedTarget.fill === "function") {
-      await resolvedTarget.fill("", buildActionOptions());
-      return;
-    }
-    throw new Error("\u76EE\u6807\u5143\u7D20\u4E0D\u652F\u6301 clear()");
+    await selector.fill("");
   },
   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);
-    }
+    await this.simulateGaze(page, Math.min(baseDuration, 900));
   },
   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 sign = direction === "down" ? 1 : -1;
-    const stepDistance = actualDistance / steps;
+    const steps = Math.max(1, Number(baseSteps) || 1);
+    const delta = (Number(distance) || 0) / steps * (direction === "down" ? 1 : -1);
     for (let index = 0; index < steps; index += 1) {
-      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, delta);
+      await sleep(60 + index * 20, 0.3);
     }
   }
 };
+var resolveDelegate2 = (page) => isMobilePage(page) ? MobileHumanize : DesktopCloakHumanize;
+var callDelegate2 = (method, page, args) => resolveDelegate2(page)[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)) {
+      return resolveDelegate2(pageOrBaseMs).randomSleep(maybeBaseMs, maybeJitterPercent);
+    }
+    return DesktopCloakHumanize.randomSleep(pageOrBaseMs, maybeBaseMs);
+  },
+  simulateGaze(page, baseDurationMs = 2500) {
+    return callDelegate2("simulateGaze", page, [baseDurationMs]);
+  },
+  humanType(page, selector, text, options = {}) {
+    return callDelegate2("humanType", page, [selector, text, options]);
+  },
+  humanPress(page, targetOrKey, maybeKey, options = {}) {
+    if (typeof maybeKey === "string") {
+      return callDelegate2("humanPress", page, [targetOrKey, maybeKey, options]);
+    }
+    return callDelegate2("humanPress", page, [targetOrKey, maybeKey || options]);
+  },
+  humanClear(page, selector) {
+    return callDelegate2("humanClear", page, [selector]);
+  },
+  warmUpBrowsing(page, baseDuration = 3500) {
+    return callDelegate2("warmUpBrowsing", page, [baseDuration]);
+  },
+  naturalScroll(page, direction = "down", distance = 300, baseSteps = 5) {
+    return callDelegate2("naturalScroll", page, [direction, distance, baseSteps]);
+  }
+};
 
 // src/humanize.js
 var humanizeStrategies = {
@@ -6827,7 +6646,7 @@ var Mutation = {
     const overallTimeout = options.timeout ?? 180 * 1e3;
     const onMutation = options.onMutation;
     const pollInterval = 500;
-    const sleep = (ms) => new Promise((resolve) => {
+    const sleep2 = (ms) => new Promise((resolve) => {
       setTimeout(resolve, ms);
     });
     const truncate = (value, max = 800) => {
@@ -7019,7 +6838,7 @@ var Mutation = {
     const deadline = Date.now() + overallTimeout;
     let lastState = state2;
     while (Date.now() < deadline) {
-      await sleep(pollInterval);
+      await sleep2(pollInterval);
       lastState = await buildState();
       if (!lastState?.hasMatched) {
         continue;