@skrillex1224/playwright-toolkit 2.1.231 → 2.1.233

package/dist/index.cjs

@@ -505,9 +505,6 @@ var SUPPORTED_TYPES = /* @__PURE__ */ new Set(["png", "jpeg", "webp"]);
 var EXPANDED_SCROLLABLE_CLASS = "__pk_expanded__";
 var DEFAULT_MAX_HEIGHT = 8e3;
 var DEFAULT_SETTLE_MS = 1e3;
-var DEFAULT_BUFFER_RATIO = 0.25;
-var DEFAULT_BUFFER_MIN = 120;
-var DEFAULT_BUFFER_MAX = 320;
 var toPositiveNumber = (value, fallback = 0) => {
   const n = Number(value);
   if (!Number.isFinite(n) || n <= 0) return fallback;
@@ -517,10 +514,6 @@ var toPositiveInteger = (value, fallback = 0) => {
   const number = Math.round(Number(value) || 0);
   return number > 0 ? number : fallback;
 };
-var resolveDefaultBuffer = (viewport = {}) => {
-  const height = Math.max(1, Number(viewport.height) || 0);
-  return Math.round(Math.min(DEFAULT_BUFFER_MAX, Math.max(DEFAULT_BUFFER_MIN, height * DEFAULT_BUFFER_RATIO)));
-};
 var normalizeType = (value) => {
   const raw = String(value || "png").trim().toLowerCase();
   if (!SUPPORTED_TYPES.has(raw)) return "png";
@@ -625,6 +618,7 @@ var expandScrollableContent = async (page, options = {}) => {
       return documentTop + scrollHeight;
     };
     const scrollableElements = [];
+    const expandedAncestors = [];
     const expandElementToScrollHeight = (el) => {
       if (!el || isDocumentElement(el)) return;
       const scrollHeight = Math.ceil(el.scrollHeight || 0);
@@ -647,13 +641,44 @@ var expandScrollableContent = async (page, options = {}) => {
         rememberOriginalBoxStyles(node);
         node.style.setProperty("overflow", "visible", "important");
         node.style.setProperty("max-height", "none", "important");
-        if (node.scrollHeight > node.clientHeight + 1) {
+        expandedAncestors.push(node);
+      }
+    };
+    const expandAncestorsToCurrentScrollHeight = () => {
+      const ancestors = [...new Set(expandedAncestors)];
+      for (let pass = 0; pass < 2; pass += 1) {
+        ancestors.forEach((node) => {
+          if (!node || isDocumentElement(node)) return;
           const scrollHeight = Math.ceil(node.scrollHeight || 0);
+          if (scrollHeight <= node.clientHeight + 1) return;
+          rememberOriginalBoxStyles(node);
           node.style.setProperty("height", `${scrollHeight}px`, "important");
           node.style.setProperty("min-height", `${scrollHeight}px`, "important");
-        }
+          node.style.setProperty("max-height", "none", "important");
+        });
       }
     };
+    const measureExpandedRenderedBottom = () => {
+      let renderedBottom = maxHeight;
+      const scrollY = window.scrollY || window.pageYOffset || 0;
+      candidates.forEach((el) => {
+        if (!el || isDocumentElement(el)) return;
+        if (!el.classList.contains(className) && !el.closest(`.${className}`)) return;
+        const style = window.getComputedStyle(el);
+        const rect = el.getBoundingClientRect();
+        if (!isVisible(el, style, rect)) return;
+        renderedBottom = Math.max(renderedBottom, Math.ceil(rect.bottom + scrollY));
+      });
+      return renderedBottom;
+    };
+    const measureDocumentScrollHeight = () => {
+      return Math.max(
+        maxHeight,
+        Math.ceil(root?.scrollHeight || 0),
+        Math.ceil(body?.scrollHeight || 0),
+        Math.ceil(scrollingElement?.scrollHeight || 0)
+      );
+    };
     candidates.forEach((el) => {
       const style = window.getComputedStyle(el);
       const rect = el.getBoundingClientRect();
@@ -684,13 +709,15 @@ var expandScrollableContent = async (page, options = {}) => {
       el.style.height = "auto";
       el.style.maxHeight = "none";
     });
+    expandAncestorsToCurrentScrollHeight();
     scrollableElements.forEach((el) => {
       const neededHeight = measureNeededHeight(el);
       if (neededHeight > maxHeight) {
         maxHeight = neededHeight;
       }
     });
-    return maxHeight;
+    maxHeight = Math.max(maxHeight, measureDocumentScrollHeight(), measureExpandedRenderedBottom());
+    return Math.ceil(maxHeight);
   }, {
     className: EXPANDED_SCROLLABLE_CLASS,
     forceScrollableHeight: options.forceScrollableHeight !== false,
@@ -699,15 +726,13 @@ var expandScrollableContent = async (page, options = {}) => {
 };
 var prepareExpandedFullPageScreenshot = async (page, options = {}) => {
   const originalViewport = await resolveCurrentViewportSize(page);
-  const defaultBuffer = resolveDefaultBuffer(originalViewport);
-  const buffer = options.buffer ?? defaultBuffer;
   const maxHeight = toPositiveInteger(options.maxHeight, DEFAULT_MAX_HEIGHT);
   const settleMs = Math.max(0, Number(options.settleMs ?? DEFAULT_SETTLE_MS) || 0);
   const maxScrollHeight = await expandScrollableContent(page, {
     forceScrollableHeight: options.forceScrollableHeight,
     visibleOnly: options.visibleOnly !== false
   });
-  const targetHeight = Math.min(maxScrollHeight + buffer, maxHeight);
+  const targetHeight = Math.min(maxScrollHeight, maxHeight);
   await page.setViewportSize({
     width: originalViewport.width,
     height: targetHeight
@@ -2350,6 +2375,358 @@ var AntiCheat = {
   }
 };
 
+// src/device-input.js
+var resolveDeviceFromPage = (page) => normalizeDevice(page?.[PageRuntimeStateKey]?.device);
+var assertPage = (page, method) => {
+  if (!page || typeof page !== "object") {
+    throw new Error(`DeviceInput.${method} requires a Playwright page`);
+  }
+};
+var isPoint = (value) => value && typeof value === "object" && Number.isFinite(Number(value.x)) && Number.isFinite(Number(value.y));
+var pointFromArgs = (pointOrX, maybeY) => {
+  if (isPoint(pointOrX)) {
+    return { x: Number(pointOrX.x), y: Number(pointOrX.y) };
+  }
+  return { x: Number(pointOrX), y: Number(maybeY) };
+};
+var resolveNativeTarget = (page, target) => {
+  if (!target) return null;
+  if (typeof target === "string") return page.locator(target);
+  return target;
+};
+var normalizeSelectorOptions = (options = {}) => ({
+  targetParent: Boolean(options.targetParent ?? options.parent ?? false),
+  pick: options.pick === "last" || options.last ? "last" : "first",
+  visibleOnly: options.visibleOnly !== false,
+  fallbackDomClick: Boolean(options.fallbackDomClick),
+  forceMouse: Boolean(options.forceMouse),
+  forceClick: Boolean(options.forceClick),
+  mouseOptions: options.mouseOptions || {},
+  clickOptions: options.clickOptions || {},
+  tapOptions: options.tapOptions || {}
+});
+var waitFor = (page, timeout) => {
+  if (!timeout) return Promise.resolve();
+  if (page && typeof page.waitForTimeout === "function") {
+    return page.waitForTimeout(timeout);
+  }
+  return new Promise((resolve) => setTimeout(resolve, timeout));
+};
+var getTargetBoundingBox = async (target) => {
+  if (!target) return null;
+  if (typeof target.boundingBox === "function") return target.boundingBox();
+  if (typeof target.elementHandle === "function") {
+    const handle = await target.elementHandle();
+    try {
+      return await handle?.boundingBox?.();
+    } finally {
+      if (handle && typeof handle.dispose === "function") {
+        await handle.dispose().catch(() => {
+        });
+      }
+    }
+  }
+  return null;
+};
+var assertPoint = (point) => {
+  if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) {
+    throw new Error(`Invalid input point: ${JSON.stringify(point)}`);
+  }
+};
+var dispatchMouseMove = (page, point, options = {}) => page.mouse.move(point.x, point.y, options);
+var dispatchMouseStart = (page, options = {}) => page.mouse.down(options);
+var dispatchMouseEnd = (page, options = {}) => page.mouse.up(options);
+var dragWithMouse = async (page, points, options = {}) => {
+  await dispatchMouseMove(page, points.start, { steps: 8 });
+  await waitFor(page, options.initialDelayMs ?? 250);
+  await dispatchMouseStart(page);
+  await waitFor(page, options.holdDelayMs ?? 350);
+  await dispatchMouseMove(page, points.lift, { steps: 6 });
+  await waitFor(page, options.liftDelayMs ?? 250);
+  for (let step = 1; step <= points.steps; step += 1) {
+    const progress = step / points.steps;
+    const easedProgress = 1 - (1 - progress) * (1 - progress);
+    await dispatchMouseMove(page, {
+      x: points.lift.x + (points.end.x - points.lift.x) * easedProgress,
+      y: points.lift.y + (points.end.y - points.lift.y) * easedProgress
+    }, { steps: 2 });
+    await waitFor(page, options.stepDelayMs ?? 90);
+  }
+  await waitFor(page, options.beforeReleaseDelayMs ?? 100);
+  await dispatchMouseEnd(page);
+  await waitFor(page, options.afterReleaseDelayMs ?? 100);
+  return true;
+};
+var dragWithTouch = async (page, points, options = {}) => {
+  let client = null;
+  try {
+    client = await page.context().newCDPSession(page);
+    await client.send("Input.dispatchTouchEvent", {
+      type: "touchStart",
+      touchPoints: [{ x: points.start.x, y: points.start.y, id: 1 }]
+    });
+    await waitFor(page, options.holdDelayMs ?? 350);
+    const totalSteps = points.steps + 1;
+    for (let step = 1; step <= totalSteps; step += 1) {
+      const progress = step / totalSteps;
+      const easedProgress = 1 - (1 - progress) * (1 - progress);
+      const from = step === 1 ? points.start : points.lift;
+      const to = points.end;
+      await client.send("Input.dispatchTouchEvent", {
+        type: "touchMove",
+        touchPoints: [{
+          x: from.x + (to.x - from.x) * easedProgress,
+          y: from.y + (to.y - from.y) * easedProgress,
+          id: 1
+        }]
+      });
+      await waitFor(page, options.stepDelayMs ?? 90);
+    }
+    await waitFor(page, options.beforeReleaseDelayMs ?? 100);
+    await client.send("Input.dispatchTouchEvent", {
+      type: "touchEnd",
+      touchPoints: []
+    });
+    await waitFor(page, options.afterReleaseDelayMs ?? 100);
+    return true;
+  } finally {
+    if (client && typeof client.detach === "function") {
+      await client.detach().catch(() => {
+      });
+    }
+  }
+};
+var clickTargetWithDevice = async (page, target, options = {}) => {
+  const normalizedOptions = normalizeSelectorOptions(options);
+  const resolvedDevice = resolveDeviceFromPage(page);
+  if (target && resolvedDevice === Device.Mobile && !normalizedOptions.forceClick) {
+    if (typeof target.tap === "function") {
+      await target.tap(normalizedOptions.tapOptions);
+      return true;
+    }
+    const box = await getTargetBoundingBox(target);
+    if (box) {
+      await DeviceInput.clickPoint(page, {
+        x: box.x + box.width / 2,
+        y: box.y + box.height / 2
+      }, normalizedOptions);
+      return true;
+    }
+  }
+  if (!target || typeof target.click !== "function") {
+    throw new Error("DeviceInput click target does not expose click()");
+  }
+  await target.click(normalizedOptions.clickOptions || options);
+  return true;
+};
+var DeviceInput = {
+  device(page) {
+    return resolveDeviceFromPage(page);
+  },
+  isMobile(page) {
+    return resolveDeviceFromPage(page) === Device.Mobile;
+  },
+  async clickPoint(page, pointOrX, maybeY, options = {}) {
+    assertPage(page, "clickPoint");
+    const clickOptions = isPoint(pointOrX) && maybeY && typeof maybeY === "object" ? maybeY : options;
+    const point = pointFromArgs(pointOrX, maybeY);
+    assertPoint(point);
+    if (resolveDeviceFromPage(page) === Device.Mobile && !clickOptions.forceMouse && page.touchscreen && typeof page.touchscreen.tap === "function") {
+      await page.touchscreen.tap(point.x, point.y);
+      return true;
+    }
+    await page.mouse.click(point.x, point.y, clickOptions.mouseOptions || {});
+    return true;
+  },
+  async tapPoint(page, pointOrX, maybeY, options = {}) {
+    return DeviceInput.clickPoint(page, pointOrX, maybeY, options);
+  },
+  async click(page, target, options = {}) {
+    assertPage(page, "click");
+    if (isPoint(target)) {
+      return DeviceInput.clickPoint(page, target, void 0, options);
+    }
+    const nativeTarget = resolveNativeTarget(page, target);
+    return clickTargetWithDevice(page, nativeTarget, options);
+  },
+  async tap(page, target, options = {}) {
+    return DeviceInput.click(page, target, options);
+  },
+  async move(page, pointOrX, maybeY, options = {}) {
+    assertPage(page, "move");
+    const moveOptions = isPoint(pointOrX) && maybeY && typeof maybeY === "object" ? maybeY : options;
+    const point = pointFromArgs(pointOrX, maybeY);
+    assertPoint(point);
+    if (resolveDeviceFromPage(page) === Device.Mobile && !moveOptions.forceMouse) {
+      return true;
+    }
+    await page.mouse.move(point.x, point.y, moveOptions.mouseOptions || moveOptions);
+    return true;
+  },
+  async focus(page, target, options = {}) {
+    assertPage(page, "focus");
+    const nativeTarget = resolveNativeTarget(page, target);
+    if (!nativeTarget || typeof nativeTarget.focus !== "function") {
+      throw new Error("DeviceInput focus target does not expose focus()");
+    }
+    await nativeTarget.focus(options);
+    return true;
+  },
+  async fill(page, target, value, options = {}) {
+    assertPage(page, "fill");
+    const nativeTarget = resolveNativeTarget(page, target);
+    if (!nativeTarget || typeof nativeTarget.fill !== "function") {
+      throw new Error("DeviceInput fill target does not expose fill()");
+    }
+    await nativeTarget.fill(value, options);
+    return true;
+  },
+  async keyboardType(page, text, options = {}) {
+    assertPage(page, "keyboardType");
+    await page.keyboard.type(text, options);
+    return true;
+  },
+  async type(page, targetOrText, maybeText, options = {}) {
+    assertPage(page, "type");
+    if (maybeText == null || typeof maybeText === "object" && !Array.isArray(maybeText)) {
+      return DeviceInput.keyboardType(page, targetOrText, maybeText || options);
+    }
+    const nativeTarget = resolveNativeTarget(page, targetOrText);
+    if (!nativeTarget || typeof nativeTarget.type !== "function") {
+      throw new Error("DeviceInput type target does not expose type()");
+    }
+    await nativeTarget.type(maybeText, options);
+    return true;
+  },
+  async press(page, targetOrKey, maybeKey, options = {}) {
+    assertPage(page, "press");
+    const hasTarget = typeof maybeKey === "string";
+    const key = hasTarget ? maybeKey : targetOrKey;
+    const pressOptions = hasTarget ? options : maybeKey || options;
+    if (hasTarget) {
+      await DeviceInput.click(page, targetOrKey, pressOptions.clickOptions || {});
+    }
+    await page.keyboard.press(key, pressOptions.keyboardOptions || pressOptions);
+    return true;
+  },
+  async selectorCenterPoint(page, selector, options = {}) {
+    assertPage(page, "selectorCenterPoint");
+    const normalizedOptions = normalizeSelectorOptions(options);
+    return page.evaluate(({ innerSelector, innerOptions }) => {
+      const nodes = Array.from(document.querySelectorAll(innerSelector));
+      const ordered = innerOptions.pick === "last" ? nodes.reverse() : nodes;
+      let rect = null;
+      for (const node of ordered) {
+        if (!node) continue;
+        const target = innerOptions.targetParent ? node.parentElement || node : node;
+        rect = target.getBoundingClientRect?.() || null;
+        const isVisible = Boolean(rect && rect.width > 0 && rect.height > 0);
+        if (innerOptions.visibleOnly && !isVisible) continue;
+        break;
+      }
+      if (!rect || rect.width <= 0 || rect.height <= 0) return null;
+      return {
+        x: rect.left + rect.width / 2,
+        y: rect.top + rect.height / 2
+      };
+    }, { innerSelector: selector, innerOptions: normalizedOptions });
+  },
+  async domClick(page, selector, options = {}) {
+    assertPage(page, "domClick");
+    const normalizedOptions = normalizeSelectorOptions(options);
+    return page.evaluate(({ innerSelector, innerOptions }) => {
+      const nodes = Array.from(document.querySelectorAll(innerSelector));
+      const ordered = innerOptions.pick === "last" ? nodes.reverse() : nodes;
+      let target = null;
+      for (const node of ordered) {
+        if (!node) continue;
+        const candidate = innerOptions.targetParent ? node.parentElement || node : node;
+        const rect = candidate.getBoundingClientRect?.() || null;
+        const isVisible = Boolean(rect && rect.width > 0 && rect.height > 0);
+        if (innerOptions.visibleOnly && !isVisible) continue;
+        target = candidate;
+        break;
+      }
+      if (!target || typeof target.click !== "function") return false;
+      target.click();
+      return true;
+    }, { innerSelector: selector, innerOptions: normalizedOptions });
+  },
+  async clickSelectorCenter(page, selector, options = {}) {
+    assertPage(page, "clickSelectorCenter");
+    const normalizedOptions = normalizeSelectorOptions(options);
+    try {
+      const point = await DeviceInput.selectorCenterPoint(page, selector, normalizedOptions);
+      if (point) {
+        await DeviceInput.clickPoint(page, point, void 0, normalizedOptions);
+        return true;
+      }
+    } catch (error) {
+      if (!normalizedOptions.fallbackDomClick) throw error;
+    }
+    if (normalizedOptions.fallbackDomClick) {
+      return DeviceInput.domClick(page, selector, normalizedOptions);
+    }
+    return false;
+  },
+  async clickText(frameOrPage, texts, options = {}) {
+    for (const text of texts || []) {
+      if (!text) continue;
+      const candidates = [
+        frameOrPage.getByText(text, { exact: false }).first(),
+        frameOrPage.locator(`text=${text}`).first()
+      ];
+      for (const candidate of candidates) {
+        const isVisible = await candidate.isVisible({
+          timeout: options.visibleTimeoutMs ?? options.actionVisibleTimeoutMs ?? 1500
+        }).catch(() => false);
+        if (!isVisible) continue;
+        const page = options.page || (frameOrPage && typeof frameOrPage.context === "function" ? frameOrPage : null) || candidate.page?.();
+        if (!page) {
+          throw new Error("DeviceInput.clickText requires options.page when used with a frame locator");
+        }
+        await DeviceInput.click(page, candidate, options);
+        return true;
+      }
+    }
+    return false;
+  },
+  async drag(page, sourceLocator, targetLocator, options = {}) {
+    assertPage(page, "drag");
+    const sourceBox = await sourceLocator.boundingBox();
+    const targetBox = await targetLocator.boundingBox();
+    if (!sourceBox || !targetBox) {
+      throw new Error("Unable to resolve drag coordinates.");
+    }
+    const steps = options.steps || 10;
+    const liftOffsetX = Math.min(18, Math.max(8, sourceBox.width * 0.12));
+    const liftOffsetY = Math.min(12, Math.max(4, sourceBox.height * 0.08));
+    const points = {
+      start: {
+        x: sourceBox.x + sourceBox.width / 2,
+        y: sourceBox.y + sourceBox.height / 2
+      },
+      lift: {
+        x: sourceBox.x + sourceBox.width / 2 + liftOffsetX,
+        y: sourceBox.y + sourceBox.height / 2 + liftOffsetY
+      },
+      end: {
+        x: targetBox.x + targetBox.width / 2,
+        y: targetBox.y + targetBox.height / 2
+      },
+      steps
+    };
+    if (resolveDeviceFromPage(page) === Device.Mobile && !options.forceMouse) {
+      try {
+        return await dragWithTouch(page, points, options);
+      } catch (error) {
+        if (options.allowMouseFallback === false) throw error;
+      }
+    }
+    return dragWithMouse(page, points, options);
+  }
+};
+
 // src/internals/humanize/desktop.js
 var import_delay2 = __toESM(require("delay"), 1);
 var import_ghost_cursor_playwright = require("ghost-cursor-playwright");
@@ -2865,141 +3242,6 @@ var Humanize = {
   }
 };
 
-// src/internals/humanize/machine.js
-var resolveDeviceFromPage = (page) => normalizeDevice(page?.[PageRuntimeStateKey]?.device);
-var isPoint = (value) => value && typeof value === "object" && Number.isFinite(Number(value.x)) && Number.isFinite(Number(value.y));
-var resolveNativeTarget = (page, target) => {
-  if (!target) return null;
-  if (typeof target === "string") {
-    return page.locator(target);
-  }
-  return target;
-};
-var normalizeSelectorOptions = (options = {}) => ({
-  targetParent: Boolean(options.targetParent ?? options.parent ?? false),
-  pick: options.pick === "last" || options.last ? "last" : "first",
-  visibleOnly: options.visibleOnly !== false,
-  fallbackDomClick: Boolean(options.fallbackDomClick),
-  forceMouse: Boolean(options.forceMouse)
-});
-var MachineHumanize = {
-  async clickPoint(page, pointOrX, maybeY, options = {}) {
-    const clickOptions = isPoint(pointOrX) && maybeY && typeof maybeY === "object" ? maybeY : options;
-    const point = isPoint(pointOrX) ? pointOrX : { x: pointOrX, y: maybeY };
-    const x = Number(point.x);
-    const y = Number(point.y);
-    if (!Number.isFinite(x) || !Number.isFinite(y)) {
-      throw new Error(`Invalid click point: ${JSON.stringify(point)}`);
-    }
-    const resolvedDevice = resolveDeviceFromPage(page);
-    if (resolvedDevice === Device.Mobile && !clickOptions.forceMouse && page.touchscreen && typeof page.touchscreen.tap === "function") {
-      await page.touchscreen.tap(x, y);
-      return true;
-    }
-    await page.mouse.click(x, y, clickOptions.mouseOptions || {});
-    return true;
-  },
-  async click(page, target, options = {}) {
-    if (isPoint(target)) {
-      return MachineHumanize.clickPoint(page, target, void 0, options);
-    }
-    const nativeTarget = resolveNativeTarget(page, target);
-    if (!nativeTarget || typeof nativeTarget.click !== "function") {
-      throw new Error("Machine click target does not expose click()");
-    }
-    await nativeTarget.click(options.clickOptions || options);
-    return true;
-  },
-  async focus(page, target, options = {}) {
-    const nativeTarget = resolveNativeTarget(page, target);
-    if (!nativeTarget || typeof nativeTarget.focus !== "function") {
-      throw new Error("Machine focus target does not expose focus()");
-    }
-    await nativeTarget.focus(options);
-    return true;
-  },
-  async fill(page, target, value, options = {}) {
-    const nativeTarget = resolveNativeTarget(page, target);
-    if (!nativeTarget || typeof nativeTarget.fill !== "function") {
-      throw new Error("Machine fill target does not expose fill()");
-    }
-    await nativeTarget.fill(value, options);
-    return true;
-  },
-  async keyboardType(page, text, options = {}) {
-    await page.keyboard.type(text, options);
-    return true;
-  },
-  async type(page, targetOrText, maybeText, options = {}) {
-    if (maybeText == null || typeof maybeText === "object" && !Array.isArray(maybeText)) {
-      return MachineHumanize.keyboardType(page, targetOrText, maybeText || options);
-    }
-    const nativeTarget = resolveNativeTarget(page, targetOrText);
-    if (!nativeTarget || typeof nativeTarget.type !== "function") {
-      throw new Error("Machine type target does not expose type()");
-    }
-    await nativeTarget.type(maybeText, options);
-    return true;
-  },
-  async selectorCenterPoint(page, selector, options = {}) {
-    const normalizedOptions = normalizeSelectorOptions(options);
-    return page.evaluate(({ innerSelector, innerOptions }) => {
-      const nodes = Array.from(document.querySelectorAll(innerSelector));
-      const ordered = innerOptions.pick === "last" ? nodes.reverse() : nodes;
-      let rect = null;
-      for (const node of ordered) {
-        if (!node) continue;
-        const target = innerOptions.targetParent ? node.parentElement || node : node;
-        rect = target.getBoundingClientRect?.() || null;
-        const isVisible = Boolean(rect && rect.width > 0 && rect.height > 0);
-        if (innerOptions.visibleOnly && !isVisible) continue;
-        break;
-      }
-      if (!rect || rect.width <= 0 || rect.height <= 0) return null;
-      return {
-        x: rect.left + rect.width / 2,
-        y: rect.top + rect.height / 2
-      };
-    }, { innerSelector: selector, innerOptions: normalizedOptions });
-  },
-  async domClick(page, selector, options = {}) {
-    const normalizedOptions = normalizeSelectorOptions(options);
-    return page.evaluate(({ innerSelector, innerOptions }) => {
-      const nodes = Array.from(document.querySelectorAll(innerSelector));
-      const ordered = innerOptions.pick === "last" ? nodes.reverse() : nodes;
-      let target = null;
-      for (const node of ordered) {
-        if (!node) continue;
-        const candidate = innerOptions.targetParent ? node.parentElement || node : node;
-        const rect = candidate.getBoundingClientRect?.() || null;
-        const isVisible = Boolean(rect && rect.width > 0 && rect.height > 0);
-        if (innerOptions.visibleOnly && !isVisible) continue;
-        target = candidate;
-        break;
-      }
-      if (!target || typeof target.click !== "function") return false;
-      target.click();
-      return true;
-    }, { innerSelector: selector, innerOptions: normalizedOptions });
-  },
-  async clickSelectorCenter(page, selector, options = {}) {
-    const normalizedOptions = normalizeSelectorOptions(options);
-    try {
-      const point = await MachineHumanize.selectorCenterPoint(page, selector, normalizedOptions);
-      if (point) {
-        await MachineHumanize.clickPoint(page, point, void 0, normalizedOptions);
-        return true;
-      }
-    } catch (error) {
-      if (!normalizedOptions.fallbackDomClick) throw error;
-    }
-    if (normalizedOptions.fallbackDomClick) {
-      return MachineHumanize.domClick(page, selector, normalizedOptions);
-    }
-    return false;
-  }
-};
-
 // src/internals/humanize/shared.js
 var import_delay3 = __toESM(require("delay"), 1);
 var jitterMs = (base, jitterPercent = 0.3) => {
@@ -3828,9 +4070,6 @@ var callDelegate = (method, page, args) => {
   return delegate[method](page, ...args);
 };
 var Humanize2 = {
-  // M = Machine: native/mechanical operations for兼容路径。
-  // 这组 API 不做人类化处理，只保留原生 click / focus / fill / type 等语义。
-  M: MachineHumanize,
   jitterMs(base, jitterPercent = 0.3) {
     return Humanize.jitterMs(base, jitterPercent);
   },
@@ -4406,42 +4645,14 @@ var clickCaptchaAction = async (frame, texts, options) => {
       if (!isVisible) {
         continue;
       }
-      await candidate.click();
+      await DeviceInput.click(options.page, candidate);
       return true;
     }
   }
   return false;
 };
-var dragCaptchaWithMouse = async (page, sourceLocator, targetLocator) => {
-  const sourceBox = await sourceLocator.boundingBox();
-  const targetBox = await targetLocator.boundingBox();
-  if (!sourceBox || !targetBox) {
-    throw new Error("Unable to resolve captcha drag coordinates.");
-  }
-  const startX = sourceBox.x + sourceBox.width / 2;
-  const startY = sourceBox.y + sourceBox.height / 2;
-  const endX = targetBox.x + targetBox.width / 2;
-  const endY = targetBox.y + targetBox.height / 2;
-  const steps = 10;
-  const liftOffsetX = Math.min(18, Math.max(8, sourceBox.width * 0.12));
-  const liftOffsetY = Math.min(12, Math.max(4, sourceBox.height * 0.08));
-  await page.mouse.move(startX, startY, { steps: 8 });
-  await page.waitForTimeout(250);
-  await page.mouse.down();
-  await page.waitForTimeout(350);
-  await page.mouse.move(startX + liftOffsetX, startY + liftOffsetY, { steps: 6 });
-  await page.waitForTimeout(250);
-  for (let step = 1; step <= steps; step++) {
-    const progress = step / steps;
-    const easedProgress = 1 - (1 - progress) * (1 - progress);
-    const currentX = startX + liftOffsetX + (endX - startX - liftOffsetX) * easedProgress;
-    const currentY = startY + liftOffsetY + (endY - startY - liftOffsetY) * easedProgress;
-    await page.mouse.move(currentX, currentY, { steps: 2 });
-    await page.waitForTimeout(90);
-  }
-  await page.waitForTimeout(100);
-  await page.mouse.up();
-  await page.waitForTimeout(100);
+var dragCaptchaAction = async (page, sourceLocator, targetLocator) => {
+  await DeviceInput.drag(page, sourceLocator, targetLocator);
 };
 
 // src/internals/captcha/bytedance.js
@@ -4537,7 +4748,7 @@ var getVerifycenterCaptchaContext = async (page, options) => {
   return { iframeLocator, frame };
 };
 var refreshCaptcha = async (page, frame, options) => {
-  const clicked = await clickCaptchaAction(frame, options.refreshTexts, options).catch(() => false);
+  const clicked = await clickCaptchaAction(frame, options.refreshTexts, { ...options, page }).catch(() => false);
   if (!clicked) {
     logger10.warn("Refresh button not found.");
     return false;
@@ -4663,9 +4874,9 @@ async function solveCaptcha(page, options = {}, dependencies = {}) {
           state: "visible",
           timeout: config.sourceImageVisibleTimeoutMs
         });
-        await dragCaptchaWithMouse(page, sourceImage, dropTarget);
+        await dragCaptchaAction(page, sourceImage, dropTarget);
       }
-      const submitted = await clickCaptchaAction(frame, config.submitTexts, config).catch(() => false);
+      const submitted = await clickCaptchaAction(frame, config.submitTexts, { ...config, page }).catch(() => false);
       if (!submitted) {
         logger10.warn("\u672A\u627E\u5230\u63D0\u4EA4\u6309\u94AE\uFF0C\u53EF\u80FD\u4F1A\u81EA\u52A8\u63D0\u4EA4\u3002");
       }
@@ -8371,7 +8582,6 @@ var Share = {
    *
    * @param {import('playwright').Page} page
    * @param {Object} [options]
-   * @param {number} [options.buffer] 额外缓冲高度；默认按视口高度自动计算，传 0 可关闭
    * @param {boolean} [options.restore]
    * @param {number} [options.maxHeight]
    * @param {number} [options.maxBytes] 默认 5MiB，返回 base64 超过后会压缩
@@ -8384,7 +8594,6 @@ var Share = {
     const screenshotWatermarkify = resolveCaptureScreenWatermarkify(page, options.watermarkify);
     const compression = resolveImageCompression(options);
     const captureOptions = {
-      ...Object.prototype.hasOwnProperty.call(options, "buffer") ? { buffer: options.buffer } : {},
       restore,
       maxHeight: options.maxHeight,
       type: "png",
@@ -8410,6 +8619,7 @@ var usePlaywrightToolKit = () => {
   return {
     ApifyKit,
     AntiCheat,
+    DeviceInput,
     Humanize: Humanize2,
     Launch,
     LiveView,