@skrillex1224/playwright-toolkit 2.1.227 → 2.1.228

package/dist/index.js

@@ -439,6 +439,9 @@ function createInternalLogger(moduleName, explicitLogger) {
   };
 }
 
+// src/internals/screenshot.js
+import delay from "delay";
+
 // src/internals/viewport.js
 var toPositiveInt = (value) => {
   const number = Math.round(Number(value) || 0);
@@ -472,11 +475,18 @@ var DEFAULT_TIMEOUT_MS = 5e3;
 var FORCED_FULLPAGE_TYPE = "jpeg";
 var FORCED_FULLPAGE_QUALITY = 50;
 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 toPositiveNumber = (value, fallback = 0) => {
   const n = Number(value);
   if (!Number.isFinite(n) || n <= 0) return fallback;
   return n;
 };
+var toPositiveInteger = (value, fallback = 0) => {
+  const number = Math.round(Number(value) || 0);
+  return number > 0 ? number : fallback;
+};
 var normalizeType = (value) => {
   const raw = String(value || "png").trim().toLowerCase();
   if (!SUPPORTED_TYPES.has(raw)) return "png";
@@ -505,6 +515,138 @@ var buildFullPageClip = (metrics, viewport, maxClipHeight) => {
     scale: 1
   };
 };
+var expandScrollableContent = async (page, options = {}) => {
+  return await page.evaluate(({ className, forceScrollableHeight, visibleOnly }) => {
+    const body = document.body;
+    const root = document.documentElement;
+    const scrollingElement = document.scrollingElement;
+    const candidates = [];
+    const seen = /* @__PURE__ */ new Set();
+    let maxHeight = window.innerHeight || 0;
+    const pushCandidate = (el) => {
+      if (!el || seen.has(el)) return;
+      seen.add(el);
+      candidates.push(el);
+    };
+    pushCandidate(scrollingElement);
+    pushCandidate(root);
+    pushCandidate(body);
+    document.querySelectorAll("*").forEach(pushCandidate);
+    const isDocumentElement = (el) => el === root || el === body || el === scrollingElement;
+    const isVisible = (el, style, rect) => {
+      if (!el || !style || !rect) return false;
+      if (style.display === "none" || style.visibility === "hidden" || style.visibility === "collapse") {
+        return false;
+      }
+      if (Number(style.opacity) === 0) return false;
+      return rect.width > 0 && rect.height > 0;
+    };
+    const isScrollableY = (el, style) => {
+      if (!el || el.scrollHeight <= el.clientHeight + 1) {
+        return false;
+      }
+      if (isDocumentElement(el)) {
+        return true;
+      }
+      const overflowY = String(style.overflowY || "").toLowerCase();
+      const overflow = String(style.overflow || "").toLowerCase();
+      const scrollableOverflow = /* @__PURE__ */ new Set(["auto", "scroll", "overlay"]);
+      return scrollableOverflow.has(overflowY) || scrollableOverflow.has(overflow);
+    };
+    candidates.forEach((el) => {
+      const style = window.getComputedStyle(el);
+      const rect = el.getBoundingClientRect();
+      if (visibleOnly && !isVisible(el, style, rect)) {
+        return;
+      }
+      if (!isScrollableY(el, style)) {
+        return;
+      }
+      const scrollHeight = Math.ceil(el.scrollHeight || 0);
+      if (scrollHeight <= 0) {
+        return;
+      }
+      if (scrollHeight > maxHeight) {
+        maxHeight = scrollHeight;
+      }
+      if (isDocumentElement(el)) {
+        return;
+      }
+      if (!el.classList.contains(className)) {
+        el.dataset.pkOrigOverflow = el.style.overflow;
+        el.dataset.pkOrigOverflowPriority = el.style.getPropertyPriority("overflow") || "";
+        el.dataset.pkOrigHeight = el.style.height;
+        el.dataset.pkOrigHeightPriority = el.style.getPropertyPriority("height") || "";
+        el.dataset.pkOrigMinHeight = el.style.minHeight;
+        el.dataset.pkOrigMinHeightPriority = el.style.getPropertyPriority("min-height") || "";
+        el.dataset.pkOrigMaxHeight = el.style.maxHeight;
+        el.dataset.pkOrigMaxHeightPriority = el.style.getPropertyPriority("max-height") || "";
+        el.classList.add(className);
+      }
+      if (forceScrollableHeight) {
+        el.style.setProperty("overflow", "visible", "important");
+        el.style.setProperty("height", `${scrollHeight}px`, "important");
+        el.style.setProperty("min-height", `${scrollHeight}px`, "important");
+        el.style.setProperty("max-height", "none", "important");
+        return;
+      }
+      el.style.overflow = "visible";
+      el.style.height = "auto";
+      el.style.maxHeight = "none";
+    });
+    return maxHeight;
+  }, {
+    className: EXPANDED_SCROLLABLE_CLASS,
+    forceScrollableHeight: Boolean(options.forceScrollableHeight),
+    visibleOnly: options.visibleOnly !== false
+  });
+};
+var prepareExpandedFullPageScreenshot = async (page, options = {}) => {
+  const originalViewport = await resolveCurrentViewportSize(page);
+  const defaultBuffer = Math.round((originalViewport.height || 1080) / 2);
+  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);
+  await page.setViewportSize({
+    width: originalViewport.width,
+    height: targetHeight
+  });
+  if (settleMs > 0) {
+    await delay(settleMs);
+  }
+  return {
+    originalViewport,
+    maxScrollHeight,
+    targetHeight
+  };
+};
+var restoreExpandedFullPageScreenshot = async (page, state = {}) => {
+  await page.evaluate((className) => {
+    document.querySelectorAll(`.${className}`).forEach((el) => {
+      el.style.setProperty("overflow", el.dataset.pkOrigOverflow || "", el.dataset.pkOrigOverflowPriority || "");
+      el.style.setProperty("height", el.dataset.pkOrigHeight || "", el.dataset.pkOrigHeightPriority || "");
+      el.style.setProperty("min-height", el.dataset.pkOrigMinHeight || "", el.dataset.pkOrigMinHeightPriority || "");
+      el.style.setProperty("max-height", el.dataset.pkOrigMaxHeight || "", el.dataset.pkOrigMaxHeightPriority || "");
+      delete el.dataset.pkOrigOverflow;
+      delete el.dataset.pkOrigOverflowPriority;
+      delete el.dataset.pkOrigHeight;
+      delete el.dataset.pkOrigHeightPriority;
+      delete el.dataset.pkOrigMinHeight;
+      delete el.dataset.pkOrigMinHeightPriority;
+      delete el.dataset.pkOrigMaxHeight;
+      delete el.dataset.pkOrigMaxHeightPriority;
+      el.classList.remove(className);
+    });
+  }, EXPANDED_SCROLLABLE_CLASS);
+  if (state?.originalViewport) {
+    await page.setViewportSize(state.originalViewport);
+  }
+};
 var capturePageScreenshot = async (page, options = {}) => {
   const fullPage = Boolean(options.fullPage);
   const type = fullPage ? FORCED_FULLPAGE_TYPE : normalizeType(options.type);
@@ -558,6 +700,22 @@ var capturePageScreenshot = async (page, options = {}) => {
     return await page.screenshot(fallbackOptions);
   }
 };
+var captureExpandedFullPageScreenshot = async (page, options = {}) => {
+  const state = await prepareExpandedFullPageScreenshot(page, options);
+  try {
+    return await capturePageScreenshot(page, {
+      fullPage: true,
+      type: options.type || "png",
+      quality: options.quality,
+      timeout: options.timeout,
+      maxClipHeight: state.targetHeight
+    });
+  } finally {
+    if (options.restore) {
+      await restoreExpandedFullPageScreenshot(page, state);
+    }
+  }
+};
 
 // src/errors.js
 var errors_exports = {};
@@ -2096,7 +2254,7 @@ var AntiCheat = {
 };
 
 // src/internals/humanize/desktop.js
-import delay from "delay";
+import delay2 from "delay";
 import { createCursor } from "ghost-cursor-playwright";
 var logger6 = createInternalLogger("Humanize");
 var $CursorWeakMap = /* @__PURE__ */ new WeakMap();
@@ -2328,7 +2486,7 @@ var Humanize = {
         }
         await page.mouse.wheel(0, deltaY);
         didScroll = true;
-        await delay(this.jitterMs(20 + Math.random() * 40, 0.2));
+        await delay2(this.jitterMs(20 + Math.random() * 40, 0.2));
       }
       logger6.warn(`humanScroll | \u5728 ${maxSteps} \u6B65\u540E\u65E0\u6CD5\u786E\u4FDD\u53EF\u89C1\u6027`);
       return { element, didScroll };
@@ -2357,7 +2515,7 @@ var Humanize = {
       restoreOnce.restored = true;
       if (typeof restoreOnce.do !== "function") return;
       try {
-        await delay(this.jitterMs(1e3));
+        await delay2(this.jitterMs(1e3));
         await restoreOnce.do();
       } catch (restoreError) {
         logger6.warn(`humanClick: \u6062\u590D\u6EDA\u52A8\u4F4D\u7F6E\u5931\u8D25: ${restoreError.message}`);
@@ -2365,7 +2523,7 @@ var Humanize = {
     };
     try {
       if (target == null) {
-        await delay(this.jitterMs(reactionDelay, 0.4));
+        await delay2(this.jitterMs(reactionDelay, 0.4));
         await cursor.actions.click();
         logger6.success("humanClick", "Clicked current position");
         return true;
@@ -2399,7 +2557,7 @@ var Humanize = {
       const x = box.x + box.width / 2 + (Math.random() - 0.5) * box.width * 0.3;
       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 delay2(this.jitterMs(reactionDelay, 0.4));
       await cursor.actions.click();
       await restoreOnce();
       logger6.success("humanClick");
@@ -2418,7 +2576,7 @@ var Humanize = {
   async randomSleep(baseMs, jitterPercent = 0.3) {
     const ms = this.jitterMs(baseMs, jitterPercent);
     logger6.start("randomSleep", `base=${baseMs}, actual=${ms}ms`);
-    await delay(ms);
+    await delay2(ms);
     logger6.success("randomSleep");
   },
   /**
@@ -2436,7 +2594,7 @@ var Humanize = {
       const x = 100 + Math.random() * (viewportSize.width - 200);
       const y = 100 + Math.random() * (viewportSize.height - 200);
       await cursor.actions.move({ x, y });
-      await delay(this.jitterMs(600, 0.5));
+      await delay2(this.jitterMs(600, 0.5));
     }
     logger6.success("simulateGaze");
   },
@@ -2460,7 +2618,7 @@ var Humanize = {
     try {
       const locator = page.locator(selector);
       await Humanize.humanClick(page, locator);
-      await delay(this.jitterMs(200, 0.4));
+      await delay2(this.jitterMs(200, 0.4));
       for (let i = 0; i < text.length; i++) {
         const char = text[i];
         let charDelay;
@@ -2472,11 +2630,11 @@ var Humanize = {
           charDelay = this.jitterMs(baseDelay, 0.4);
         }
         await page.keyboard.type(char);
-        await delay(charDelay);
+        await delay2(charDelay);
         if (Math.random() < pauseProbability && i < text.length - 1) {
           const pauseTime = this.jitterMs(pauseBase, 0.5);
           logger6.debug(`\u505C\u987F ${pauseTime}ms...`);
-          await delay(pauseTime);
+          await delay2(pauseTime);
         }
       }
       logger6.success("humanType");
@@ -2510,7 +2668,7 @@ var Humanize = {
       if (hasTarget) {
         await this.humanClick(page, targetOrKey, { reactionDelay: focusDelay, scrollIfNeeded, throwOnMissing });
       }
-      await delay(this.jitterMs(reactionDelay, 0.45));
+      await delay2(this.jitterMs(reactionDelay, 0.45));
       await page.keyboard.press(key, {
         ...keyboardOptions,
         delay: this.jitterMs(holdDelay, 0.5)
@@ -2532,14 +2690,14 @@ var Humanize = {
     try {
       const locator = page.locator(selector);
       await locator.click();
-      await delay(this.jitterMs(200, 0.4));
+      await delay2(this.jitterMs(200, 0.4));
       const currentValue = await locator.inputValue();
       if (!currentValue || currentValue.length === 0) {
         logger6.success("humanClear", "already empty");
         return;
       }
       await page.keyboard.press("Meta+A");
-      await delay(this.jitterMs(100, 0.4));
+      await delay2(this.jitterMs(100, 0.4));
       await page.keyboard.press("Backspace");
       logger6.success("humanClear");
     } catch (error) {
@@ -2565,13 +2723,13 @@ var Humanize = {
           const x = 100 + Math.random() * (viewportSize.width - 200);
           const y = 100 + Math.random() * (viewportSize.height - 200);
           await cursor.actions.move({ x, y });
-          await delay(this.jitterMs(350, 0.4));
+          await delay2(this.jitterMs(350, 0.4));
         } else if (action < 0.7) {
           const scrollY = (Math.random() - 0.5) * 200;
           await page.mouse.wheel(0, scrollY);
-          await delay(this.jitterMs(500, 0.4));
+          await delay2(this.jitterMs(500, 0.4));
         } else {
-          await delay(this.jitterMs(800, 0.5));
+          await delay2(this.jitterMs(800, 0.5));
         }
       }
       logger6.success("warmUpBrowsing");
@@ -2600,7 +2758,7 @@ var Humanize = {
         const scrollAmount = stepDistance * factor * sign * jitter;
         await page.mouse.wheel(0, scrollAmount);
         const baseDelay = 60 + i * 25;
-        await delay(this.jitterMs(baseDelay, 0.3));
+        await delay2(this.jitterMs(baseDelay, 0.3));
       }
       logger6.success("naturalScroll");
     } catch (error) {
@@ -2746,7 +2904,7 @@ var MachineHumanize = {
 };
 
 // src/internals/humanize/shared.js
-import delay2 from "delay";
+import delay3 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));
@@ -2772,7 +2930,7 @@ var resolveElement = async (page, target, { throwOnMissing = true } = {}) => {
   }
   return element;
 };
-var waitJitter = (base, jitterPercent = 0.3) => delay2(jitterMs(base, jitterPercent));
+var waitJitter = (base, jitterPercent = 0.3) => delay3(jitterMs(base, jitterPercent));
 
 // src/internals/humanize/mobile.js
 var logger7 = createInternalLogger("Humanize.Mobile");
@@ -3573,8 +3731,8 @@ var callDelegate = (method, page, args) => {
   return delegate[method](page, ...args);
 };
 var Humanize2 = {
-  // M = Machine: native/mechanical operations for compatibility paths.
-  // These APIs intentionally do not humanize timing, motion, or intent.
+  // M = Machine: native/mechanical operations for兼容路径。
+  // 这组 API 不做人类化处理，只保留原生 click / focus / fill / type 等语义。
   M: MachineHumanize,
   jitterMs(base, jitterPercent = 0.3) {
     return Humanize.jitterMs(base, jitterPercent);
@@ -6081,7 +6239,7 @@ var Logger = {
 };
 
 // src/share.js
-import delay3 from "delay";
+import delay4 from "delay";
 
 // src/internals/watermarkify.js
 var DEFAULT_TIMEZONE_OFFSET = 8;
@@ -6115,6 +6273,18 @@ var DEFAULT_STRIP_PROMPT_MAX_LINES = 3;
 var DEFAULT_STRIP_CONTENT_SAFE_PADDING_X = 12;
 var DEFAULT_STRIP_TEXT_WIDTH_SAFETY = 10;
 var DEFAULT_BROWSER_COMPOSITOR_VIEWPORT_HEIGHT = 1200;
+var MOBILE_STRIP_HEIGHT = 104;
+var MOBILE_STRIP_PADDING_X = 14;
+var MOBILE_STRIP_PADDING_Y = 13;
+var MOBILE_STRIP_ROW_HEIGHT = 22;
+var MOBILE_STRIP_ROW_GAP = 7;
+var MOBILE_STRIP_LABEL_FONT_SIZE = 12.5;
+var MOBILE_STRIP_VALUE_FONT_SIZE = 13.5;
+var MOBILE_STRIP_LABEL_WIDTH = 45;
+var MOBILE_STRIP_PROMPT_LABEL_WIDTH = 60;
+var MOBILE_STRIP_LOC_LABEL_WIDTH = 30;
+var MOBILE_STRIP_IP_LABEL_WIDTH = 22;
+var MOBILE_STRIP_META_GAP = 12;
 var WEAK_LOCATION_VALUES = /* @__PURE__ */ new Set(["cn", "\u4E2D\u56FD"]);
 var LOCATION_NETWORK_SUFFIX_PATTERNS = [
   /(?:中国)?移动$/i,
@@ -6899,10 +7069,16 @@ var resolveScreenshotWatermarkifyMeta = async (page, options = {}) => {
     }),
     watermark: options.watermark,
     strip: options.strip,
-    stripLogoSrc
+    stripLogoSrc,
+    device: resolvePageDevice(page)
   };
 };
 var buildFontFamily = () => 'MiSans, "SF Pro Display", "PingFang SC", "Helvetica Neue", Arial, sans-serif';
+var resolvePageDevice = (page) => normalizeDevice(page?.[PageRuntimeStateKey]?.device);
+var findStripSegment = (segments, kind) => {
+  const found = Array.isArray(segments) ? segments.find((segment) => segment?.kind === kind) : null;
+  return found && typeof found === "object" ? found : {};
+};
 var buildStripSegmentLayout = (segment, options = {}) => {
   const label = normalizeWhitespace(segment?.label || "");
   const rawValue = normalizeWhitespace(segment?.rawValue || segment?.value || "-") || "-";
@@ -7230,6 +7406,116 @@ var renderStripDivider = (x, centerY, height) => {
         />
     `;
 };
+var renderMobileStripText = ({
+  label,
+  value,
+  labelX,
+  y,
+  valueWidth,
+  labelWidth = MOBILE_STRIP_LABEL_WIDTH,
+  fontFamily
+}) => {
+  const safeLabel = normalizeWhitespace(label) || "-";
+  const safeValue = fitTextWithEllipsis(
+    Array.from(normalizeWhitespace(value) || "-"),
+    Math.max(18, valueWidth),
+    MOBILE_STRIP_VALUE_FONT_SIZE
+  );
+  return `
+        <text
+            x="${labelX}"
+            y="${y}"
+            fill="#111111"
+            fill-opacity="0.54"
+            font-family="${fontFamily}"
+            font-size="${MOBILE_STRIP_LABEL_FONT_SIZE}"
+            font-weight="650"
+            dominant-baseline="middle"
+        >${escapeXml(safeLabel)}</text>
+        <text
+            x="${labelX + labelWidth}"
+            y="${y}"
+            fill="#111111"
+            font-family="${fontFamily}"
+            font-size="${MOBILE_STRIP_VALUE_FONT_SIZE}"
+            font-weight="730"
+            dominant-baseline="middle"
+        >${escapeXml(safeValue)}</text>
+    `;
+};
+var renderMobileStrip = ({ meta, width, height, fontFamily }) => {
+  const stripHeight = MOBILE_STRIP_HEIGHT;
+  const stripY = height - stripHeight;
+  const contentX = MOBILE_STRIP_PADDING_X;
+  const contentWidth = Math.max(1, width - MOBILE_STRIP_PADDING_X * 2);
+  const prompt = findStripSegment(meta.stripSegments, "prompt");
+  const time = findStripSegment(meta.stripSegments, "time");
+  const location = findStripSegment(meta.stripSegments, "location");
+  const ip = findStripSegment(meta.stripSegments, "ip");
+  const row1Y = stripY + MOBILE_STRIP_PADDING_Y + MOBILE_STRIP_ROW_HEIGHT / 2;
+  const row2Y = row1Y + MOBILE_STRIP_ROW_HEIGHT + MOBILE_STRIP_ROW_GAP;
+  const row3Y = row2Y + MOBILE_STRIP_ROW_HEIGHT + MOBILE_STRIP_ROW_GAP;
+  const promptValueWidth = contentWidth - MOBILE_STRIP_PROMPT_LABEL_WIDTH;
+  const locValueX = contentX + MOBILE_STRIP_LOC_LABEL_WIDTH;
+  const ipLabelX = Math.min(
+    width - MOBILE_STRIP_PADDING_X - MOBILE_STRIP_IP_LABEL_WIDTH - 70,
+    Math.max(
+      locValueX + 80 + MOBILE_STRIP_META_GAP,
+      contentX + Math.round(contentWidth * 0.52)
+    )
+  );
+  const locValueWidth = Math.max(
+    28,
+    ipLabelX - locValueX - MOBILE_STRIP_META_GAP
+  );
+  const ipValueWidth = Math.max(
+    28,
+    width - MOBILE_STRIP_PADDING_X - (ipLabelX + MOBILE_STRIP_IP_LABEL_WIDTH)
+  );
+  return `
+        <g id="strip">
+            <rect x="0" y="${stripY}" width="${width}" height="${stripHeight}" fill="#ffffff" fill-opacity="0.985" />
+            <rect x="0" y="${stripY}" width="${width}" height="1" fill="#111111" fill-opacity="0.10" />
+            <rect x="${contentX}" y="${stripY}" width="${Math.max(96, Math.round(width * 0.36))}" height="2" fill="url(#stripAccent)" />
+            ${renderMobileStripText({
+    label: "Prompt",
+    value: prompt.rawValue || prompt.value || "-",
+    labelX: contentX,
+    y: row1Y,
+    valueWidth: promptValueWidth,
+    labelWidth: MOBILE_STRIP_PROMPT_LABEL_WIDTH,
+    fontFamily
+  })}
+            ${renderMobileStripText({
+    label: "Time",
+    value: time.rawValue || time.value || "-",
+    labelX: contentX,
+    y: row2Y,
+    valueWidth: promptValueWidth,
+    labelWidth: MOBILE_STRIP_LABEL_WIDTH,
+    fontFamily
+  })}
+            ${renderMobileStripText({
+    label: "Loc",
+    value: location.rawValue || location.value || "-",
+    labelX: contentX,
+    y: row3Y,
+    valueWidth: locValueWidth,
+    labelWidth: MOBILE_STRIP_LOC_LABEL_WIDTH,
+    fontFamily
+  })}
+            ${renderMobileStripText({
+    label: "IP",
+    value: ip.rawValue || ip.value || "-",
+    labelX: ipLabelX,
+    y: row3Y,
+    valueWidth: ipValueWidth,
+    labelWidth: MOBILE_STRIP_IP_LABEL_WIDTH,
+    fontFamily
+  })}
+        </g>
+    `;
+};
 var buildWatermarkifySvg = (meta, imageWidth, imageHeight) => {
   const hasWatermark = meta?.watermark?.enabled !== false && normalizeText(meta?.watermarkText);
   const hasStrip = meta?.strip?.enabled !== false && Array.isArray(meta?.stripSegments) && meta.stripSegments.length > 0;
@@ -7278,6 +7564,27 @@ var buildWatermarkifySvg = (meta, imageWidth, imageHeight) => {
     parts.push(`<g id="watermarks">${stamps.join("")}</g>`);
   }
   if (hasStrip) {
+    if (normalizeDevice(meta.device) === Device.Mobile) {
+      parts.push(renderMobileStrip({
+        meta,
+        width,
+        height,
+        fontFamily
+      }));
+      return `
+                <svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">
+                    <defs>
+                        <linearGradient id="stripAccent" x1="0%" y1="0%" x2="100%" y2="0%">
+                            <stop offset="0%" stop-color="#111111" stop-opacity="0.98" />
+                            <stop offset="24%" stop-color="#111111" stop-opacity="0.68" />
+                            <stop offset="58%" stop-color="#111111" stop-opacity="0.08" />
+                            <stop offset="100%" stop-color="#111111" stop-opacity="0" />
+                        </linearGradient>
+                    </defs>
+                    ${parts.join("")}
+                </svg>
+            `;
+    }
     const logoSize = 28;
     const logoX = DEFAULT_STRIP_PADDING_LEFT;
     const contentStartX = logoX + logoSize + DEFAULT_STRIP_GAP;
@@ -7404,16 +7711,16 @@ var watermarkifyScreenshotBuffer = async (buffer, meta, page = null) => {
   return await composeScreenshotBufferWithBrowser(page, buffer, overlaySvg, imageInfo);
 };
 
-// src/internals/screenshot-compression.js
+// src/internals/compression.js
 import { Jimp, JimpMime, ResizeStrategy } from "jimp";
-var logger14 = createInternalLogger("ScreenshotCompression");
+var logger14 = createInternalLogger("Compression");
 var DEFAULT_SCREENSHOT_MAX_BYTES = 5 * 1024 * 1024;
 var DEFAULT_SCREENSHOT_OUTPUT_TYPE = "jpeg";
 var DEFAULT_SCREENSHOT_QUALITY = 0.72;
 var DEFAULT_SCREENSHOT_MIN_QUALITY = 0.38;
 var DEFAULT_SCREENSHOT_MIN_SCALE = 0.25;
 var SUPPORTED_SCREENSHOT_OUTPUT_TYPES = /* @__PURE__ */ new Set(["jpeg"]);
-var toPositiveInteger = (value, fallback = 0) => {
+var toPositiveInteger2 = (value, fallback = 0) => {
   const number = Math.floor(Number(value) || 0);
   return number > 0 ? number : fallback;
 };
@@ -7435,7 +7742,7 @@ var normalizeScreenshotOutputType = (value) => {
 };
 var getBase64BytesFromBuffer = (buffer) => Math.ceil(buffer.length / 3) * 4;
 var toJpegQuality = (value) => Math.round(normalizeQuality2(value, DEFAULT_SCREENSHOT_QUALITY) * 100);
-var resolveCaptureScreenCompression = (options = {}) => {
+var resolveImageCompression = (options = {}) => {
   const explicit = options.compression;
   const source = explicit && typeof explicit === "object" && !Array.isArray(explicit) ? explicit : {};
   const enabled = explicit !== false && source.enabled !== false && options.compress !== false;
@@ -7449,7 +7756,7 @@ var resolveCaptureScreenCompression = (options = {}) => {
   );
   return {
     enabled,
-    maxBytes: toPositiveInteger(
+    maxBytes: toPositiveInteger2(
       source.maxBytes ?? source.maxBase64Bytes ?? options.maxBytes ?? options.maxBase64Bytes,
       DEFAULT_SCREENSHOT_MAX_BYTES
     ),
@@ -7486,7 +7793,7 @@ var encodeJpeg = async (sourceImage, compression, scale, quality) => {
     format: compression.outputType
   };
 };
-var compressScreenshotBuffer = async (buffer, compression) => {
+var compressImageBuffer = async (buffer, compression) => {
   const sourceImage = await Jimp.read(buffer);
   const maxQuality = toJpegQuality(compression.quality);
   const minQuality = Math.min(maxQuality, toJpegQuality(compression.minQuality));
@@ -7519,12 +7826,12 @@ var compressScreenshotBuffer = async (buffer, compression) => {
   const fallback = !smallest || finalCandidate.bytes < smallest.bytes ? finalCandidate : smallest;
   return { ...fallback, withinLimit: fallback.bytes <= compression.maxBytes };
 };
-var compressScreenshotBufferToBase64 = async (buffer, compression) => {
+var compressImageBufferToBase64 = async (buffer, compression) => {
   const originalBytes = getBase64BytesFromBuffer(buffer);
   if (!compression.enabled || originalBytes <= compression.maxBytes) {
     return buffer.toString("base64");
   }
-  const result = await compressScreenshotBuffer(buffer, compression).catch((error) => {
+  const result = await compressImageBuffer(buffer, compression).catch((error) => {
     logger14.warning(`captureScreen \u538B\u7F29\u5931\u8D25\uFF0C\u8FD4\u56DE\u539F\u56FE: ${error instanceof Error ? error.message : String(error)}`);
     return null;
   });
@@ -7923,7 +8230,7 @@ var Share = {
           );
           nextProgressLogTs = now + 5e3;
         }
-        await delay3(Math.max(0, Math.min(DEFAULT_POLL_INTERVAL_MS, remaining)));
+        await delay4(Math.max(0, Math.min(DEFAULT_POLL_INTERVAL_MS, remaining)));
       }
       if (share.mode === "response" && stats.responseMatched === 0) {
         logger15.warning(
@@ -7961,71 +8268,27 @@ var Share = {
    * @returns {Promise<string>} base64 image
    */
   async captureScreen(page, options = {}) {
-    const originalViewport = await resolveCurrentViewportSize(page);
-    const defaultBuffer = Math.round((originalViewport.height || 1080) / 2);
-    const buffer = options.buffer ?? defaultBuffer;
     const restore = options.restore ?? false;
-    const maxHeight = options.maxHeight ?? 8e3;
     const screenshotWatermarkify = resolveCaptureScreenWatermarkify(page, options.watermarkify);
-    const compression = resolveCaptureScreenCompression(options);
-    try {
-      const maxScrollHeight = await page.evaluate(() => {
-        let maxHeight2 = document.body.scrollHeight;
-        document.querySelectorAll("*").forEach((el) => {
-          const style = window.getComputedStyle(el);
-          const overflowY = style.overflowY;
-          if ((overflowY === "auto" || overflowY === "scroll") && el.scrollHeight > el.clientHeight) {
-            if (el.scrollHeight > maxHeight2) {
-              maxHeight2 = el.scrollHeight;
-            }
-            el.dataset.pkOrigOverflow = el.style.overflow;
-            el.dataset.pkOrigHeight = el.style.height;
-            el.dataset.pkOrigMaxHeight = el.style.maxHeight;
-            el.classList.add("__pk_expanded__");
-            el.style.overflow = "visible";
-            el.style.height = "auto";
-            el.style.maxHeight = "none";
-          }
-        });
-        return maxHeight2;
-      });
-      const targetHeight = Math.min(maxScrollHeight + buffer, maxHeight);
-      await page.setViewportSize({
-        width: originalViewport.width,
-        height: targetHeight
-      });
-      await delay3(1e3);
-      const capturedAt = /* @__PURE__ */ new Date();
-      const rawBuffer = await capturePageScreenshot(page, {
-        fullPage: true,
-        type: "png",
-        maxClipHeight: targetHeight
+    const compression = resolveImageCompression(options);
+    const captureOptions = {
+      buffer: options.buffer ?? 0,
+      restore,
+      maxHeight: options.maxHeight,
+      type: "png",
+      visibleOnly: true
+    };
+    const capturedAt = /* @__PURE__ */ new Date();
+    const rawBuffer = await captureExpandedFullPageScreenshot(page, captureOptions);
+    let outputBuffer = rawBuffer;
+    if (screenshotWatermarkify.enabled) {
+      const watermarkifyMeta = await resolveScreenshotWatermarkifyMeta(page, {
+        ...screenshotWatermarkify,
+        capturedAt
       });
-      let outputBuffer = rawBuffer;
-      if (screenshotWatermarkify.enabled) {
-        const watermarkifyMeta = await resolveScreenshotWatermarkifyMeta(page, {
-          ...screenshotWatermarkify,
-          capturedAt
-        });
-        outputBuffer = await watermarkifyScreenshotBuffer(rawBuffer, watermarkifyMeta, page);
-      }
-      return await compressScreenshotBufferToBase64(outputBuffer, compression);
-    } finally {
-      if (restore) {
-        await page.evaluate(() => {
-          document.querySelectorAll(".__pk_expanded__").forEach((el) => {
-            el.style.overflow = el.dataset.pkOrigOverflow || "";
-            el.style.height = el.dataset.pkOrigHeight || "";
-            el.style.maxHeight = el.dataset.pkOrigMaxHeight || "";
-            delete el.dataset.pkOrigOverflow;
-            delete el.dataset.pkOrigHeight;
-            delete el.dataset.pkOrigMaxHeight;
-            el.classList.remove("__pk_expanded__");
-          });
-        });
-        await page.setViewportSize(originalViewport);
-      }
+      outputBuffer = await watermarkifyScreenshotBuffer(rawBuffer, watermarkifyMeta, page);
     }
+    return await compressImageBufferToBase64(outputBuffer, compression);
   }
 };