@skrillex1224/playwright-toolkit 3.0.25 → 3.0.27

package/dist/index.cjs

@@ -229,7 +229,7 @@ var ActorInfo = {
       mode: "response",
       prefix: "https://www.doubao.com/thread/",
       xurl: [
-        "/samantha/thread/share/save",
+        "/share/save",
         "data",
         "share_id"
       ]
@@ -256,7 +256,6 @@ var ActorInfo = {
     name: "\u6587\u5FC3\u4E00\u8A00",
     domain: "wenxin.baidu.com",
     path: "/",
-    device: Device.Mobile,
     share: {
       mode: "custom",
       prefix: "",
@@ -495,9 +494,7 @@ function createInternalLogger(moduleName, explicitLogger) {
 
 // src/internals/screenshot.js
 var import_delay = __toESM(require("delay"), 1);
-
-// src/internals/constants.js
-var PageRuntimeStateKey = "__playwright_toolkit_runtime_state__";
+var import_jimp = require("jimp");
 
 // src/internals/viewport.js
 var toPositiveInt = (value) => {
@@ -529,21 +526,22 @@ var resolveCurrentViewportSize = async (page, fallback = {}) => {
 // src/internals/screenshot.js
 var logger = createInternalLogger("Screenshot");
 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 DEFAULT_MOBILE_SETTLE_MS = 50;
+var DEFAULT_SETTLE_MS = 260;
+var DEFAULT_QUALITY_RETRY_ATTEMPTS = 4;
+var DEFAULT_QUALITY_RETRY_DELAY_MS = 2500;
+var EXPANDED_ATTR = "data-pk-screenshot-expanded";
+var SUPPORTED_TYPES = /* @__PURE__ */ new Set(["png", "jpeg", "webp"]);
+var FULLPAGE_FALLBACK_TYPE = "jpeg";
+var FULLPAGE_FALLBACK_QUALITY = 50;
 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;
+  const n = Math.round(Number(value) || 0);
+  return n > 0 ? n : fallback;
 };
 var normalizeType = (value) => {
   const raw = String(value || "png").trim().toLowerCase();
@@ -558,488 +556,622 @@ var normalizeQuality = (value, type) => {
   if (rounded < 0 || rounded > 100) return void 0;
   return rounded;
 };
-var resolvePageDevice = (page) => normalizeDevice(page?.[PageRuntimeStateKey]?.device);
 var buildFullPageClip = (metrics, viewport, maxClipHeight) => {
   const contentSize = metrics && typeof metrics === "object" ? metrics.contentSize || null : null;
   const width = Math.max(1, Math.ceil(viewport.width || contentSize?.width || 1));
   let height = Math.max(1, Math.ceil(contentSize?.height || viewport.height || 1));
-  if (maxClipHeight > 0) {
-    height = Math.min(height, maxClipHeight);
-  }
-  return {
-    x: 0,
-    y: 0,
-    width,
-    height,
-    scale: 1
+  if (maxClipHeight > 0) height = Math.min(height, maxClipHeight);
+  return { x: 0, y: 0, width, height, scale: 1 };
+};
+var capturePageScreenshot = async (page, options = {}) => {
+  const fullPage = Boolean(options.fullPage);
+  const type = fullPage ? FULLPAGE_FALLBACK_TYPE : normalizeType(options.type);
+  const quality = fullPage ? FULLPAGE_FALLBACK_QUALITY : normalizeQuality(options.quality, type);
+  const timeout = toPositiveNumber(options.timeout, DEFAULT_TIMEOUT_MS);
+  const maxClipHeight = Math.round(toPositiveNumber(options.maxClipHeight, 0));
+  const fallbackOptions = {
+    type: type === "webp" ? "png" : type,
+    fullPage
   };
+  if (quality !== void 0 && fallbackOptions.type === "jpeg") fallbackOptions.quality = quality;
+  if (timeout > 0) fallbackOptions.timeout = timeout;
+  try {
+    const context = page && typeof page.context === "function" ? page.context() : null;
+    if (!context || typeof context.newCDPSession !== "function") {
+      throw new Error("CDP session is not available");
+    }
+    const session = await context.newCDPSession(page);
+    try {
+      const viewport = await resolveCurrentViewportSize(page);
+      const captureParams = {
+        format: type,
+        fromSurface: true,
+        captureBeyondViewport: fullPage,
+        optimizeForSpeed: true
+      };
+      if (quality !== void 0) captureParams.quality = quality;
+      if (fullPage) {
+        const metrics = await session.send("Page.getLayoutMetrics");
+        captureParams.clip = buildFullPageClip(metrics, viewport, maxClipHeight);
+      }
+      const result = await session.send("Page.captureScreenshot", captureParams);
+      if (!result || typeof result.data !== "string" || !result.data) {
+        throw new Error("CDP returned empty screenshot data");
+      }
+      return Buffer.from(result.data, "base64");
+    } finally {
+      if (typeof session.detach === "function") {
+        await session.detach().catch(() => {
+        });
+      }
+    }
+  } catch (error) {
+    logger.warning(`CDP \u622A\u56FE\u5931\u8D25\uFF0C\u56DE\u9000 page.screenshot: ${error?.message || error}`);
+    return await page.screenshot(fallbackOptions);
+  }
 };
-var expandScrollableContent = async (page, options = {}) => {
-  return await page.evaluate(({ className, forceScrollableHeight, visibleOnly, expandDocumentElements }) => {
-    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);
+var readMainFrameScroll = async (page) => {
+  return await page.evaluate(() => ({
+    x: Math.max(0, Math.round(window.scrollX || document.scrollingElement?.scrollLeft || 0)),
+    y: Math.max(0, Math.round(window.scrollY || document.scrollingElement?.scrollTop || 0))
+  })).catch(() => ({ x: 0, y: 0 }));
+};
+var restoreMainFrameScroll = async (page, state2) => {
+  if (!state2) return;
+  await page.evaluate(({ x, y }) => {
+    window.scrollTo(Math.max(0, Math.round(Number(x) || 0)), Math.max(0, Math.round(Number(y) || 0)));
+  }, state2).catch(() => {
+  });
+};
+var freezeViewportMetrics = async (page) => {
+  const viewport = await resolveCurrentViewportSize(page).catch(() => null);
+  if (!viewport?.width || !viewport?.height) return false;
+  return await page.evaluate(({ width, height }) => {
+    const key = "__pkScreenshotViewportFreeze";
+    if (window[key]?.active) return true;
+    const state2 = {
+      active: true,
+      entries: []
     };
-    pushCandidate(scrollingElement);
-    pushCandidate(root);
-    pushCandidate(body);
-    document.querySelectorAll("*").forEach(pushCandidate);
+    const override = (target, prop, value) => {
+      if (!target) return;
+      try {
+        const descriptor = Object.getOwnPropertyDescriptor(target, prop);
+        state2.entries.push({
+          target,
+          prop,
+          hadOwn: Boolean(descriptor),
+          descriptor
+        });
+        Object.defineProperty(target, prop, {
+          configurable: true,
+          get: () => value
+        });
+      } catch {
+      }
+    };
+    override(window, "innerWidth", width);
+    override(window, "innerHeight", height);
+    if (window.visualViewport) {
+      override(window.visualViewport, "width", width);
+      override(window.visualViewport, "height", height);
+    }
+    window[key] = state2;
+    return true;
+  }, {
+    width: Math.max(1, Math.round(viewport.width)),
+    height: Math.max(1, Math.round(viewport.height))
+  }).catch((error) => {
+    logger.warning(`\u51BB\u7ED3 viewport \u6307\u6807\u5931\u8D25: ${error?.message || error}`);
+    return false;
+  });
+};
+var restoreViewportMetrics = async (page) => {
+  await page.evaluate(() => {
+    const key = "__pkScreenshotViewportFreeze";
+    const state2 = window[key];
+    if (!state2?.active) return;
+    for (const entry of [...state2.entries].reverse()) {
+      try {
+        if (entry.hadOwn && entry.descriptor) {
+          Object.defineProperty(entry.target, entry.prop, entry.descriptor);
+        } else {
+          delete entry.target[entry.prop];
+        }
+      } catch {
+      }
+    }
+    delete window[key];
+  }).catch(() => {
+  });
+};
+var expandScrollableContentInContext = async (context, options = {}) => {
+  return await context.evaluate(async ({
+    expandedAttr,
+    maxHeight,
+    preloadLazyContent,
+    preloadSettleMs,
+    visibleOnly
+  }) => {
+    const root = document.documentElement;
+    const body = document.body;
+    const scrollingElement = document.scrollingElement || root || body;
+    const viewportWidth = window.innerWidth || root?.clientWidth || body?.clientWidth || 1;
+    const viewportHeight = window.innerHeight || root?.clientHeight || body?.clientHeight || 1;
     const scrollableOverflow = /* @__PURE__ */ new Set(["auto", "scroll", "overlay"]);
     const clippingOverflow = /* @__PURE__ */ new Set(["hidden", "clip"]);
+    const candidates = [];
+    const changed = [];
+    const push = (el) => {
+      if (el && !candidates.includes(el)) candidates.push(el);
+    };
+    push(scrollingElement);
+    push(root);
+    push(body);
+    document.querySelectorAll("*").forEach(push);
     const isDocumentElement = (el) => el === root || el === body || el === scrollingElement;
+    const delayMs = (ms) => new Promise((resolve) => setTimeout(resolve, Math.max(0, Number(ms) || 0)));
+    const styleValue = (el, prop) => el.style.getPropertyValue(prop) || "";
+    const stylePriority = (el, prop) => el.style.getPropertyPriority(prop) || "";
     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;
+      if (style.display === "none" || style.visibility === "hidden" || style.visibility === "collapse") return false;
+      if (Number(style.opacity || 1) === 0) return false;
       return rect.width > 0 && rect.height > 0;
     };
+    const intersectsViewport = (rect) => {
+      if (!rect || rect.width <= 0 || rect.height <= 0) return false;
+      return rect.bottom > 0 && rect.right > 0 && rect.top < viewportHeight && rect.left < viewportWidth;
+    };
+    const isVisibleInViewport = (el, style, rect) => isVisible(el, style, rect) && intersectsViewport(rect);
     const hasOverflowValue = (style, values) => {
-      const overflowY = String(style?.overflowY || "").toLowerCase();
       const overflow = String(style?.overflow || "").toLowerCase();
-      return values.has(overflowY) || values.has(overflow);
+      const overflowY = String(style?.overflowY || "").toLowerCase();
+      return values.has(overflow) || values.has(overflowY);
     };
     const isLargeVerticalClipper = (el, rect) => {
       if (!el || !rect) return false;
-      const viewportHeight = window.innerHeight || 0;
-      const visibleHeight = Math.ceil(rect.height || 0);
-      const clientHeight = Math.ceil(el.clientHeight || 0);
-      const boxHeight = Math.max(visibleHeight, clientHeight);
+      const boxHeight = Math.max(Math.ceil(rect.height || 0), Math.ceil(el.clientHeight || 0));
       return boxHeight >= Math.max(320, viewportHeight * 0.45);
     };
-    const hasLargeVerticalOverflow = (el, rect) => {
-      if (!isLargeVerticalClipper(el, rect)) return false;
-      const viewportHeight = window.innerHeight || 0;
-      const scrollHeight = Math.ceil(el.scrollHeight || 0);
-      const clientHeight = Math.ceil(el.clientHeight || 0);
-      const overflowDelta = scrollHeight - clientHeight;
-      return overflowDelta >= Math.max(160, viewportHeight * 0.18);
-    };
-    const rememberOriginalBoxStyles = (el, { includeDocumentElement = false } = {}) => {
-      if (!el || !includeDocumentElement && isDocumentElement(el) || el.classList.contains(className)) {
-        return;
-      }
-      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);
-    };
-    const expandDocumentElementsToHeight = (height) => {
-      if (!expandDocumentElements) return;
-      const targetHeight = Math.ceil(Number(height) || 0);
-      if (targetHeight <= 0) return;
-      [root, body, scrollingElement].forEach((el) => {
-        if (!el) return;
-        rememberOriginalBoxStyles(el, { includeDocumentElement: true });
-        el.style.setProperty("overflow", "visible", "important");
-        el.style.setProperty("height", `${targetHeight}px`, "important");
-        el.style.setProperty("min-height", `${targetHeight}px`, "important");
-        el.style.setProperty("max-height", "none", "important");
-      });
-    };
     const isScrollableY = (el, style, rect) => {
-      if (!el || el.scrollHeight <= el.clientHeight + 1) {
-        return false;
-      }
-      if (isDocumentElement(el)) {
-        return true;
-      }
-      if (hasOverflowValue(style, scrollableOverflow)) {
-        return true;
-      }
-      return hasOverflowValue(style, clippingOverflow) && hasLargeVerticalOverflow(el, rect);
+      if (!el || Math.ceil(el.scrollHeight || 0) <= Math.ceil(el.clientHeight || 0) + 2) return false;
+      if (isDocumentElement(el)) return true;
+      if (hasOverflowValue(style, scrollableOverflow)) return true;
+      if (!hasOverflowValue(style, clippingOverflow)) return false;
+      const overflowDelta = Math.ceil(el.scrollHeight || 0) - Math.ceil(el.clientHeight || 0);
+      return isLargeVerticalClipper(el, rect) && overflowDelta >= Math.max(160, viewportHeight * 0.18);
     };
-    const measureNeededHeight = (el) => {
-      if (!el) return 0;
-      const scrollHeight = Math.ceil(el.scrollHeight || 0);
-      if (scrollHeight <= 0) return 0;
-      if (isDocumentElement(el)) {
-        return scrollHeight;
-      }
-      const rect = el.getBoundingClientRect();
-      if (!rect || rect.width <= 0 || rect.height <= 0) {
-        return 0;
-      }
-      const documentTop = Math.max(0, Math.ceil(rect.top + (window.scrollY || window.pageYOffset || 0)));
-      return documentTop + scrollHeight;
+    const rememberBox = (el) => {
+      if (!el || el.getAttribute(expandedAttr) === "1") return;
+      el.setAttribute(expandedAttr, "1");
+      el.dataset.pkSsOverflow = styleValue(el, "overflow");
+      el.dataset.pkSsOverflowPriority = stylePriority(el, "overflow");
+      el.dataset.pkSsOverflowX = styleValue(el, "overflow-x");
+      el.dataset.pkSsOverflowXPriority = stylePriority(el, "overflow-x");
+      el.dataset.pkSsOverflowY = styleValue(el, "overflow-y");
+      el.dataset.pkSsOverflowYPriority = stylePriority(el, "overflow-y");
+      el.dataset.pkSsHeight = styleValue(el, "height");
+      el.dataset.pkSsHeightPriority = stylePriority(el, "height");
+      el.dataset.pkSsMinHeight = styleValue(el, "min-height");
+      el.dataset.pkSsMinHeightPriority = stylePriority(el, "min-height");
+      el.dataset.pkSsMaxHeight = styleValue(el, "max-height");
+      el.dataset.pkSsMaxHeightPriority = stylePriority(el, "max-height");
+      el.dataset.pkSsWidth = styleValue(el, "width");
+      el.dataset.pkSsWidthPriority = stylePriority(el, "width");
+      el.dataset.pkSsBoxSizing = styleValue(el, "box-sizing");
+      el.dataset.pkSsBoxSizingPriority = stylePriority(el, "box-sizing");
+      el.dataset.pkSsAlignSelf = styleValue(el, "align-self");
+      el.dataset.pkSsAlignSelfPriority = stylePriority(el, "align-self");
+      el.dataset.pkSsJustifySelf = styleValue(el, "justify-self");
+      el.dataset.pkSsJustifySelfPriority = stylePriority(el, "justify-self");
+      el.dataset.pkSsScrollTop = String(Math.max(0, Math.round(el.scrollTop || 0)));
+      el.dataset.pkSsScrollLeft = String(Math.max(0, Math.round(el.scrollLeft || 0)));
+      changed.push(el);
     };
-    const scrollableElements = [];
-    const expandedAncestors = [];
-    const expandElementToScrollHeight = (el) => {
-      if (!el || isDocumentElement(el)) return;
-      const scrollHeight = Math.ceil(el.scrollHeight || 0);
-      if (scrollHeight <= 0) return;
-      rememberOriginalBoxStyles(el);
+    const setExpandedBox = (el, { height, width }) => {
+      if (!el) return;
+      rememberBox(el);
       el.style.setProperty("overflow", "visible", "important");
-      el.style.setProperty("height", `${scrollHeight}px`, "important");
-      el.style.setProperty("min-height", `${scrollHeight}px`, "important");
+      el.style.setProperty("overflow-y", "visible", "important");
       el.style.setProperty("max-height", "none", "important");
+      if (height > 0) {
+        const cssHeight = `${Math.ceil(height)}px`;
+        el.style.setProperty("height", cssHeight, "important");
+        el.style.setProperty("min-height", cssHeight, "important");
+      }
+      if (!isDocumentElement(el) && width > 0) {
+        el.style.setProperty("box-sizing", "border-box", "important");
+        el.style.setProperty("width", `${Math.ceil(width)}px`, "important");
+        el.style.setProperty("align-self", "flex-start", "important");
+        el.style.setProperty("justify-self", "start", "important");
+      }
+      el.scrollTop = 0;
+      el.scrollLeft = 0;
     };
     const expandClippingAncestors = (el) => {
       for (let node = el?.parentElement; node && !isDocumentElement(node); node = node.parentElement) {
         const style = window.getComputedStyle(node);
         const rect = node.getBoundingClientRect();
         if (!isVisible(node, style, rect)) continue;
-        const scrollableClip = hasOverflowValue(style, scrollableOverflow);
-        const visualClip = hasOverflowValue(style, clippingOverflow);
-        if (!scrollableClip && (!visualClip || !isLargeVerticalClipper(node, rect))) continue;
-        rememberOriginalBoxStyles(node);
+        const clips = hasOverflowValue(style, scrollableOverflow) || hasOverflowValue(style, clippingOverflow);
+        if (!clips) continue;
+        rememberBox(node);
         node.style.setProperty("overflow", "visible", "important");
+        node.style.setProperty("overflow-y", "visible", "important");
         node.style.setProperty("max-height", "none", "important");
-        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 preloadCandidates = [];
+    for (const el of candidates) {
+      const style = window.getComputedStyle(el);
+      const rect = isDocumentElement(el) ? { top: 0, left: 0, width: viewportWidth, height: viewportHeight } : el.getBoundingClientRect();
+      if (visibleOnly && !isDocumentElement(el) && !isVisibleInViewport(el, style, rect)) continue;
+      if (!isScrollableY(el, style, rect)) continue;
+      preloadCandidates.push(el);
+    }
+    if (preloadLazyContent && preloadCandidates.length > 0) {
+      preloadCandidates.forEach((el) => {
+        rememberBox(el);
+        const maxTop = Math.max(0, Math.ceil((el.scrollHeight || 0) - (el.clientHeight || viewportHeight || 0)));
+        if (isDocumentElement(el)) {
+          window.scrollTo(window.scrollX || 0, maxTop);
+        } else {
+          el.scrollTop = maxTop;
+          el.dispatchEvent(new Event("scroll", { bubbles: true }));
+        }
+      });
+      window.dispatchEvent(new Event("scroll"));
+      await delayMs(preloadSettleMs);
+    }
+    let targetHeight = viewportHeight;
+    let scrollableCount = 0;
+    let expandedCount = 0;
+    for (const el of preloadCandidates) {
+      const rect = isDocumentElement(el) ? { top: 0, left: 0, width: viewportWidth, height: viewportHeight } : el.getBoundingClientRect();
+      const scrollHeight = Math.ceil(el.scrollHeight || 0);
+      const clientHeight = Math.ceil(el.clientHeight || viewportHeight || 0);
+      if (scrollHeight <= clientHeight + 2) continue;
+      scrollableCount += 1;
+      if (isDocumentElement(el)) {
+        targetHeight = Math.max(targetHeight, scrollHeight);
+        el.scrollTop = 0;
+        continue;
       }
-    };
-    const measureExpandedRenderedBottom = () => {
-      let renderedBottom = maxHeight;
+      const documentTop = Math.max(0, Math.ceil(rect.top + (window.scrollY || window.pageYOffset || 0)));
+      const width = Math.max(1, Math.ceil(rect.width || el.clientWidth || viewportWidth || 1));
+      targetHeight = Math.max(targetHeight, documentTop + scrollHeight);
+      expandClippingAncestors(el);
+      setExpandedBox(el, { height: scrollHeight, width });
+      expandedCount += 1;
+    }
+    for (let pass = 0; pass < 2; pass += 1) {
+      for (const el of changed) {
+        if (!el || isDocumentElement(el)) continue;
+        const height = Math.ceil(el.scrollHeight || 0);
+        if (height > Math.ceil(el.clientHeight || 0) + 2) {
+          el.style.setProperty("height", `${height}px`, "important");
+          el.style.setProperty("min-height", `${height}px`, "important");
+        }
+      }
+    }
+    const measureDocumentHeight = () => Math.max(
+      viewportHeight,
+      Math.ceil(root?.scrollHeight || 0),
+      Math.ceil(body?.scrollHeight || 0),
+      Math.ceil(scrollingElement?.scrollHeight || 0)
+    );
+    const measureExpandedBottom = () => {
+      let bottom = viewportHeight;
       const scrollY = window.scrollY || window.pageYOffset || 0;
-      candidates.forEach((el) => {
+      document.querySelectorAll(`[${expandedAttr}="1"]`).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));
+        if (!rect || rect.width <= 0 || rect.height <= 0) return;
+        bottom = Math.max(bottom, 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)
-      );
+      return bottom;
     };
-    candidates.forEach((el) => {
-      const style = window.getComputedStyle(el);
-      const rect = el.getBoundingClientRect();
-      if (visibleOnly && !isVisible(el, style, rect)) {
-        return;
-      }
-      if (!isScrollableY(el, style, rect)) {
-        return;
-      }
-      const neededHeight = measureNeededHeight(el);
-      if (neededHeight <= 0) {
-        return;
-      }
-      if (neededHeight > maxHeight) {
-        maxHeight = neededHeight;
-      }
-      scrollableElements.push(el);
-      if (isDocumentElement(el)) {
-        return;
-      }
-      expandClippingAncestors(el);
-      if (forceScrollableHeight) {
-        expandElementToScrollHeight(el);
-        return;
-      }
-      rememberOriginalBoxStyles(el);
-      el.style.overflow = "visible";
-      el.style.height = "auto";
-      el.style.maxHeight = "none";
+    targetHeight = Math.max(targetHeight, measureDocumentHeight(), measureExpandedBottom());
+    targetHeight = Math.min(Math.max(1, Math.ceil(targetHeight)), Math.max(1, Math.ceil(maxHeight || targetHeight)));
+    [root, body, scrollingElement].forEach((el) => {
+      if (!el) return;
+      setExpandedBox(el, { height: targetHeight, width: 0 });
     });
-    expandAncestorsToCurrentScrollHeight();
-    scrollableElements.forEach((el) => {
-      const neededHeight = measureNeededHeight(el);
-      if (neededHeight > maxHeight) {
-        maxHeight = neededHeight;
+    window.scrollTo(0, 0);
+    document.querySelectorAll(`[${expandedAttr}="1"]`).forEach((el) => {
+      if (!isDocumentElement(el)) {
+        el.scrollTop = 0;
+        el.scrollLeft = 0;
       }
     });
-    maxHeight = Math.max(maxHeight, measureDocumentScrollHeight(), measureExpandedRenderedBottom());
-    if (expandDocumentElements) {
-      for (let pass = 0; pass < 2; pass += 1) {
-        expandDocumentElementsToHeight(maxHeight);
-        maxHeight = Math.max(maxHeight, measureDocumentScrollHeight(), measureExpandedRenderedBottom());
-      }
-    }
-    return Math.ceil(maxHeight);
+    window.dispatchEvent(new Event("scroll"));
+    await delayMs(preloadSettleMs);
+    return {
+      height: Math.max(targetHeight, measureDocumentHeight(), measureExpandedBottom()),
+      scrollableCount,
+      expandedCount
+    };
   }, {
-    className: EXPANDED_SCROLLABLE_CLASS,
-    forceScrollableHeight: options.forceScrollableHeight !== false,
-    visibleOnly: options.visibleOnly !== false,
-    expandDocumentElements: options.expandDocumentElements === true
+    expandedAttr: EXPANDED_ATTR,
+    maxHeight: toPositiveInteger(options.maxHeight, DEFAULT_MAX_HEIGHT),
+    preloadLazyContent: options.preloadLazyContent !== false,
+    preloadSettleMs: Math.max(0, Math.min(500, Number(options.preloadSettleMs ?? options.settleMs ?? 120) || 0)),
+    visibleOnly: options.visibleOnly !== false
+  }).catch((error) => {
+    logger.warning(`\u5C55\u5F00\u6EDA\u52A8\u5BB9\u5668\u5931\u8D25: ${error?.message || error}`);
+    return { height: 0, scrollableCount: 0, expandedCount: 0 };
   });
 };
-var adjustAffixedElementsForExpandedScreenshot = async (page, options = {}) => {
-  return await page.evaluate(({ className, targetHeight }) => {
-    const viewportWidth = window.innerWidth || document.documentElement?.clientWidth || document.body?.clientWidth || 0;
-    const viewportHeight = window.innerHeight || document.documentElement?.clientHeight || document.body?.clientHeight || 0;
-    const scrollY = window.scrollY || window.pageYOffset || 0;
-    const safeTargetHeight = Math.ceil(Number(targetHeight) || 0);
-    if (safeTargetHeight <= viewportHeight + 1) {
-      return 0;
-    }
-    const hasOwn2 = (source, key) => Object.prototype.hasOwnProperty.call(source, key);
-    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 edgeThreshold = Math.max(24, Math.min(96, viewportHeight * 0.12));
-    const maxAffixedHeight = Math.max(56, viewportHeight * 0.65);
-    const candidates = [];
-    document.querySelectorAll("*").forEach((el) => {
-      const style = window.getComputedStyle(el);
-      const position = String(style.position || "").toLowerCase();
-      if (position !== "fixed" && position !== "sticky") return;
-      const rect = el.getBoundingClientRect();
-      if (!isVisible(el, style, rect)) return;
-      if (rect.height > maxAffixedHeight) return;
-      if (rect.width < viewportWidth * 0.25 && rect.height < 80) return;
-      const top = Number.parseFloat(style.top);
-      const bottom = Number.parseFloat(style.bottom);
-      const hasTopRule = Number.isFinite(top) && top <= Math.max(160, viewportHeight * 0.25);
-      const hasBottomRule = Number.isFinite(bottom) && bottom <= Math.max(160, viewportHeight * 0.25);
-      const isNearViewportTop = rect.top <= edgeThreshold;
-      const isNearViewportBottom = rect.bottom >= viewportHeight - edgeThreshold;
-      const edge = (hasBottomRule || isNearViewportBottom) && !(hasTopRule || isNearViewportTop) ? "bottom" : "top";
-      if (position === "fixed" && edge === "top" && !hasTopRule && !isNearViewportTop) return;
-      if (position === "fixed" && edge === "bottom" && !hasBottomRule && !isNearViewportBottom) return;
-      if (position === "sticky" && !hasTopRule && !hasBottomRule && !isNearViewportTop && !isNearViewportBottom) return;
-      candidates.push({ el, position, edge });
-    });
-    const candidateSet = new Set(candidates.map(({ el }) => el));
-    const topLevelCandidates = candidates.filter(({ el }) => {
-      for (let parent = el.parentElement; parent; parent = parent.parentElement) {
-        if (candidateSet.has(parent)) return false;
+var expandFrameElement = async (frame, height) => {
+  const handle = await frame.frameElement?.().catch(() => null);
+  if (!handle) return false;
+  try {
+    return await handle.evaluate((el, { expandedAttr, targetHeight }) => {
+      if (!el || targetHeight <= 0) return false;
+      if (el.getAttribute(expandedAttr) !== "1") {
+        el.setAttribute(expandedAttr, "1");
+        el.dataset.pkSsOverflow = el.style.getPropertyValue("overflow") || "";
+        el.dataset.pkSsOverflowPriority = el.style.getPropertyPriority("overflow") || "";
+        el.dataset.pkSsOverflowX = el.style.getPropertyValue("overflow-x") || "";
+        el.dataset.pkSsOverflowXPriority = el.style.getPropertyPriority("overflow-x") || "";
+        el.dataset.pkSsOverflowY = el.style.getPropertyValue("overflow-y") || "";
+        el.dataset.pkSsOverflowYPriority = el.style.getPropertyPriority("overflow-y") || "";
+        el.dataset.pkSsHeight = el.style.getPropertyValue("height") || "";
+        el.dataset.pkSsHeightPriority = el.style.getPropertyPriority("height") || "";
+        el.dataset.pkSsMinHeight = el.style.getPropertyValue("min-height") || "";
+        el.dataset.pkSsMinHeightPriority = el.style.getPropertyPriority("min-height") || "";
+        el.dataset.pkSsMaxHeight = el.style.getPropertyValue("max-height") || "";
+        el.dataset.pkSsMaxHeightPriority = el.style.getPropertyPriority("max-height") || "";
+        el.dataset.pkSsWidth = el.style.getPropertyValue("width") || "";
+        el.dataset.pkSsWidthPriority = el.style.getPropertyPriority("width") || "";
+        el.dataset.pkSsBoxSizing = el.style.getPropertyValue("box-sizing") || "";
+        el.dataset.pkSsBoxSizingPriority = el.style.getPropertyPriority("box-sizing") || "";
+        el.dataset.pkSsAlignSelf = el.style.getPropertyValue("align-self") || "";
+        el.dataset.pkSsAlignSelfPriority = el.style.getPropertyPriority("align-self") || "";
+        el.dataset.pkSsJustifySelf = el.style.getPropertyValue("justify-self") || "";
+        el.dataset.pkSsJustifySelfPriority = el.style.getPropertyPriority("justify-self") || "";
+        el.dataset.pkSsScrollTop = String(Math.max(0, Math.round(el.scrollTop || 0)));
+        el.dataset.pkSsScrollLeft = String(Math.max(0, Math.round(el.scrollLeft || 0)));
       }
+      el.style.setProperty("overflow", "visible", "important");
+      el.style.setProperty("overflow-y", "visible", "important");
+      el.style.setProperty("height", `${Math.ceil(targetHeight)}px`, "important");
+      el.style.setProperty("min-height", `${Math.ceil(targetHeight)}px`, "important");
+      el.style.setProperty("max-height", "none", "important");
+      el.style.setProperty("align-self", "flex-start", "important");
+      el.style.setProperty("justify-self", "start", "important");
       return true;
+    }, { expandedAttr: EXPANDED_ATTR, targetHeight: Math.ceil(height) });
+  } finally {
+    await handle.dispose?.().catch(() => {
     });
-    topLevelCandidates.forEach(({ el, position, edge }) => {
-      if (!hasOwn2(el.dataset, "pkAffixedAdjusted")) {
-        el.dataset.pkAffixedAdjusted = "1";
-        el.dataset.pkOrigPosition = el.style.getPropertyValue("position") || "";
-        el.dataset.pkOrigPositionPriority = el.style.getPropertyPriority("position") || "";
-        el.dataset.pkOrigTop = el.style.getPropertyValue("top") || "";
-        el.dataset.pkOrigTopPriority = el.style.getPropertyPriority("top") || "";
-        el.dataset.pkOrigBottom = el.style.getPropertyValue("bottom") || "";
-        el.dataset.pkOrigBottomPriority = el.style.getPropertyPriority("bottom") || "";
-        el.dataset.pkOrigTranslate = el.style.getPropertyValue("translate") || "";
-        el.dataset.pkOrigTranslatePriority = el.style.getPropertyPriority("translate") || "";
-      }
-      el.classList.add(className);
-      if (position === "fixed") {
-        const deltaY = edge === "bottom" ? safeTargetHeight - viewportHeight - scrollY : -scrollY;
-        if (Math.abs(deltaY) > 1) {
-          el.style.setProperty("translate", `0 ${Math.round(deltaY)}px`, "important");
-        }
-        return;
+  }
+};
+var restoreExpandedStateInContext = async (context) => {
+  await context.evaluate(({ expandedAttr }) => {
+    const hasOwn2 = (source, key) => Object.prototype.hasOwnProperty.call(source, key);
+    const restoreStyle = (el, prop, valueKey, priorityKey) => {
+      if (!hasOwn2(el.dataset, valueKey)) return;
+      const value = el.dataset[valueKey] || "";
+      const priority = el.dataset[priorityKey] || "";
+      if (value) {
+        el.style.setProperty(prop, value, priority);
+      } else {
+        el.style.removeProperty(prop);
       }
-      el.style.setProperty("position", "relative", "important");
-      el.style.setProperty("top", "auto", "important");
-      el.style.setProperty("bottom", "auto", "important");
+      delete el.dataset[valueKey];
+      delete el.dataset[priorityKey];
+    };
+    document.querySelectorAll(`[${expandedAttr}="1"]`).forEach((el) => {
+      restoreStyle(el, "overflow", "pkSsOverflow", "pkSsOverflowPriority");
+      restoreStyle(el, "overflow-x", "pkSsOverflowX", "pkSsOverflowXPriority");
+      restoreStyle(el, "overflow-y", "pkSsOverflowY", "pkSsOverflowYPriority");
+      restoreStyle(el, "height", "pkSsHeight", "pkSsHeightPriority");
+      restoreStyle(el, "min-height", "pkSsMinHeight", "pkSsMinHeightPriority");
+      restoreStyle(el, "max-height", "pkSsMaxHeight", "pkSsMaxHeightPriority");
+      restoreStyle(el, "width", "pkSsWidth", "pkSsWidthPriority");
+      restoreStyle(el, "box-sizing", "pkSsBoxSizing", "pkSsBoxSizingPriority");
+      restoreStyle(el, "align-self", "pkSsAlignSelf", "pkSsAlignSelfPriority");
+      restoreStyle(el, "justify-self", "pkSsJustifySelf", "pkSsJustifySelfPriority");
+      if (hasOwn2(el.dataset, "pkSsScrollTop")) {
+        el.scrollTop = Math.max(0, Math.round(Number(el.dataset.pkSsScrollTop) || 0));
+        delete el.dataset.pkSsScrollTop;
+      }
+      if (hasOwn2(el.dataset, "pkSsScrollLeft")) {
+        el.scrollLeft = Math.max(0, Math.round(Number(el.dataset.pkSsScrollLeft) || 0));
+        delete el.dataset.pkSsScrollLeft;
+      }
+      el.removeAttribute(expandedAttr);
     });
-    return topLevelCandidates.length;
+    window.dispatchEvent(new Event("scroll"));
   }, {
-    className: EXPANDED_SCROLLABLE_CLASS,
-    targetHeight: options.targetHeight
+    expandedAttr: EXPANDED_ATTR
+  }).catch(() => {
   });
 };
-var restoreAffixedElementsForExpandedScreenshot = async (page) => {
-  await page.evaluate((className) => {
-    const hasOwn2 = (source, key) => Object.prototype.hasOwnProperty.call(source, key);
-    const expansionKeys = [
-      "pkOrigOverflow",
-      "pkOrigHeight",
-      "pkOrigMinHeight",
-      "pkOrigMaxHeight"
-    ];
-    document.querySelectorAll('[data-pk-affixed-adjusted="1"]').forEach((el) => {
-      if (hasOwn2(el.dataset, "pkOrigPosition")) {
-        el.style.setProperty("position", el.dataset.pkOrigPosition || "", el.dataset.pkOrigPositionPriority || "");
-        delete el.dataset.pkOrigPosition;
-        delete el.dataset.pkOrigPositionPriority;
-      }
-      if (hasOwn2(el.dataset, "pkOrigTop")) {
-        el.style.setProperty("top", el.dataset.pkOrigTop || "", el.dataset.pkOrigTopPriority || "");
-        delete el.dataset.pkOrigTop;
-        delete el.dataset.pkOrigTopPriority;
-      }
-      if (hasOwn2(el.dataset, "pkOrigBottom")) {
-        el.style.setProperty("bottom", el.dataset.pkOrigBottom || "", el.dataset.pkOrigBottomPriority || "");
-        delete el.dataset.pkOrigBottom;
-        delete el.dataset.pkOrigBottomPriority;
-      }
-      if (hasOwn2(el.dataset, "pkOrigTranslate")) {
-        el.style.setProperty("translate", el.dataset.pkOrigTranslate || "", el.dataset.pkOrigTranslatePriority || "");
-        delete el.dataset.pkOrigTranslate;
-        delete el.dataset.pkOrigTranslatePriority;
-      }
-      delete el.dataset.pkAffixedAdjusted;
-      const stillExpanded = expansionKeys.some((key) => hasOwn2(el.dataset, key));
-      if (!stillExpanded) {
-        el.classList.remove(className);
-      }
+var resetScrollPositionInContext = async (context) => {
+  await context.evaluate(() => {
+    const root = document.documentElement;
+    const body = document.body;
+    const scrollingElement = document.scrollingElement || root || body;
+    window.scrollTo(0, 0);
+    [root, body, scrollingElement].forEach((el) => {
+      if (!el) return;
+      el.scrollTop = 0;
+      el.scrollLeft = 0;
+      el.dispatchEvent(new Event("scroll", { bubbles: true }));
     });
-  }, EXPANDED_SCROLLABLE_CLASS);
+    window.dispatchEvent(new Event("scroll"));
+  }).catch(() => {
+  });
 };
 var prepareExpandedFullPageScreenshot = async (page, options = {}) => {
-  const originalViewport = await resolveCurrentViewportSize(page);
   const maxHeight = toPositiveInteger(options.maxHeight, DEFAULT_MAX_HEIGHT);
-  const preserveViewport = options.preserveViewport ?? resolvePageDevice(page) === Device.Mobile;
-  const defaultSettleMs = preserveViewport ? DEFAULT_MOBILE_SETTLE_MS : DEFAULT_SETTLE_MS;
-  const requestedSettleMs = Math.max(0, Number(options.settleMs ?? defaultSettleMs) || 0);
-  const settleMs = preserveViewport ? Math.min(requestedSettleMs, DEFAULT_MOBILE_SETTLE_MS) : requestedSettleMs;
-  const maxScrollHeight = await expandScrollableContent(page, {
-    forceScrollableHeight: options.forceScrollableHeight,
-    visibleOnly: options.visibleOnly !== false,
-    expandDocumentElements: preserveViewport
-  });
-  const targetHeight = Math.min(maxScrollHeight, maxHeight);
-  let viewportResized = false;
-  if (!preserveViewport) {
-    await page.setViewportSize({
-      width: originalViewport.width,
-      height: targetHeight
+  const settleMs = Math.max(0, Number(options.settleMs ?? DEFAULT_SETTLE_MS) || 0);
+  const frames = typeof page.frames === "function" ? page.frames() : [page.mainFrame?.()].filter(Boolean);
+  const mainFrame = page.mainFrame?.() || frames[0] || null;
+  let targetHeight = 0;
+  let scrollableCount = 0;
+  let expandedCount = 0;
+  for (const frame of frames) {
+    if (!frame || frame === mainFrame) continue;
+    const state2 = await expandScrollableContentInContext(frame, {
+      ...options,
+      maxHeight,
+      settleMs
     });
-    viewportResized = true;
-  } else {
-    await adjustAffixedElementsForExpandedScreenshot(page, { targetHeight }).catch((error) => {
-      logger.warning(`\u79FB\u52A8\u7AEF\u5438\u9644\u5143\u7D20\u91CD\u5B9A\u4F4D\u5931\u8D25: ${error?.message || error}`);
+    if (state2.height > 0) {
+      await expandFrameElement(frame, Math.min(state2.height, maxHeight)).catch(() => false);
+      await resetScrollPositionInContext(frame);
+    }
+    targetHeight = Math.max(targetHeight, state2.height || 0);
+    scrollableCount += state2.scrollableCount || 0;
+    expandedCount += state2.expandedCount || 0;
+  }
+  if (mainFrame) {
+    const state2 = await expandScrollableContentInContext(mainFrame, {
+      ...options,
+      maxHeight,
+      settleMs
     });
-  }
-  if (settleMs > 0) {
-    await (0, import_delay.default)(settleMs);
-  }
+    targetHeight = Math.max(targetHeight, state2.height || 0);
+    scrollableCount += state2.scrollableCount || 0;
+    expandedCount += state2.expandedCount || 0;
+    await resetScrollPositionInContext(mainFrame);
+  }
+  targetHeight = Math.min(Math.max(1, Math.ceil(targetHeight || 0)), maxHeight);
+  if (settleMs > 0) await (0, import_delay.default)(settleMs);
+  logger.info(`\u5C55\u5F00\u5F0F\u957F\u622A\u56FE\u76EE\u6807: height=${targetHeight}, scrollables=${scrollableCount}, expanded=${expandedCount}`);
   return {
-    originalViewport,
-    maxScrollHeight,
     targetHeight,
-    preserveViewport,
-    viewportResized
+    frames,
+    settleMs
   };
 };
 var restoreExpandedFullPageScreenshot = async (page, state2 = {}) => {
-  await page.evaluate((className) => {
-    const targets = new Set([
-      ...document.querySelectorAll(`.${className}`),
-      document.documentElement,
-      document.body,
-      document.scrollingElement
-    ].filter((el) => el?.classList?.contains(className)));
-    targets.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 (state2?.originalViewport && state2?.viewportResized) {
-    await page.setViewportSize(state2.originalViewport);
+  const frames = Array.isArray(state2.frames) ? [...state2.frames].reverse() : typeof page.frames === "function" ? [...page.frames()].reverse() : [];
+  for (const frame of frames) {
+    await restoreExpandedStateInContext(frame);
   }
 };
-var capturePageScreenshot = async (page, options = {}) => {
-  const fullPage = Boolean(options.fullPage);
-  const type = fullPage ? FORCED_FULLPAGE_TYPE : normalizeType(options.type);
-  const quality = fullPage ? FORCED_FULLPAGE_QUALITY : normalizeQuality(options.quality, type);
-  const timeout = toPositiveNumber(options.timeout, DEFAULT_TIMEOUT_MS);
-  const maxClipHeight = Math.round(toPositiveNumber(options.maxClipHeight, 0));
-  const fallbackOptions = {
-    type: type === "webp" ? "png" : type,
-    fullPage
-  };
-  if (quality !== void 0 && fallbackOptions.type === "jpeg") {
-    fallbackOptions.quality = quality;
-  }
-  if (timeout > 0) {
-    fallbackOptions.timeout = timeout;
-  }
+var captureExpandedFullPageScreenshotOnce = async (page, options = {}) => {
+  const originalViewport = await resolveCurrentViewportSize(page).catch(() => null);
+  const originalMainScroll = await readMainFrameScroll(page);
+  let state2 = null;
+  let viewportResized = false;
   try {
-    const context = page && typeof page.context === "function" ? page.context() : null;
-    if (!context || typeof context.newCDPSession !== "function") {
-      throw new Error("CDP session is not available");
-    }
-    const session = await context.newCDPSession(page);
-    try {
-      const metrics = await session.send("Page.getLayoutMetrics");
-      const viewport = await resolveCurrentViewportSize(page);
-      const captureParams = {
-        format: type,
-        fromSurface: true,
-        captureBeyondViewport: fullPage,
-        optimizeForSpeed: true
-      };
-      if (quality !== void 0) {
-        captureParams.quality = quality;
-      }
-      if (fullPage) {
-        captureParams.clip = buildFullPageClip(metrics, viewport, maxClipHeight);
-      }
-      const result = await session.send("Page.captureScreenshot", captureParams);
-      if (!result || typeof result.data !== "string" || !result.data) {
-        throw new Error("CDP returned empty screenshot data");
-      }
-      return Buffer.from(result.data, "base64");
-    } finally {
-      if (typeof session.detach === "function") {
-        await session.detach().catch(() => {
-        });
-      }
+    await freezeViewportMetrics(page);
+    state2 = await prepareExpandedFullPageScreenshot(page, options);
+    const targetHeight = Math.max(1, Math.ceil(state2.targetHeight || options.maxHeight || DEFAULT_MAX_HEIGHT));
+    if (originalViewport?.width && originalViewport?.height && targetHeight > Math.ceil(originalViewport.height) + 1) {
+      await page.setViewportSize({
+        width: Math.ceil(originalViewport.width),
+        height: targetHeight
+      });
+      viewportResized = true;
+      if (state2.settleMs > 0) await (0, import_delay.default)(state2.settleMs);
     }
-  } catch (error) {
-    logger.warning(`CDP \u622A\u56FE\u5931\u8D25\uFF0C\u56DE\u9000 page.screenshot: ${error?.message || error}`);
-    return await page.screenshot(fallbackOptions);
-  }
-};
-var captureExpandedFullPageScreenshot = async (page, options = {}) => {
-  const state2 = await prepareExpandedFullPageScreenshot(page, options);
-  try {
     return await capturePageScreenshot(page, {
+      ...options,
       fullPage: true,
-      type: options.type || "png",
-      quality: options.quality,
-      timeout: options.timeout,
-      maxClipHeight: state2.targetHeight
+      maxClipHeight: targetHeight
     });
   } finally {
-    await restoreAffixedElementsForExpandedScreenshot(page).catch((error) => {
-      logger.warning(`\u79FB\u52A8\u7AEF\u5438\u9644\u5143\u7D20\u6062\u590D\u5931\u8D25: ${error?.message || error}`);
-    });
     if (options.restore) {
       await restoreExpandedFullPageScreenshot(page, state2);
+      if (viewportResized && originalViewport?.width && originalViewport?.height) {
+        await page.setViewportSize({
+          width: Math.ceil(originalViewport.width),
+          height: Math.ceil(originalViewport.height)
+        }).catch((error) => {
+          logger.warning(`\u6062\u590D viewport \u5931\u8D25: ${error?.message || error}`);
+        });
+      }
     }
+    await restoreViewportMetrics(page);
+    if (options.restore) {
+      await restoreMainFrameScroll(page, originalMainScroll);
+    }
+  }
+};
+var isDarkBlankPixel = ({ r, g, b }) => {
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  return max <= 34 && max - min <= 10;
+};
+var analyzeScreenshotBuffer = async (buffer) => {
+  const image = await import_jimp.Jimp.read(buffer);
+  const { width, height } = image.bitmap;
+  const stepY = Math.max(1, Math.floor(height / 900));
+  const stepX = Math.max(1, Math.floor(width / 420));
+  let darkRows = 0;
+  let loadingLikeRows = 0;
+  let rows = 0;
+  for (let y = 0; y < height; y += stepY) {
+    rows += 1;
+    let dark = 0;
+    let edge = 0;
+    let count = 0;
+    let prev = null;
+    for (let x = 0; x < width; x += stepX) {
+      const rgba = (0, import_jimp.intToRGBA)(image.getPixelColor(x, y));
+      count += 1;
+      if (isDarkBlankPixel(rgba)) dark += 1;
+      if (prev) {
+        const diff = Math.abs(rgba.r - prev.r) + Math.abs(rgba.g - prev.g) + Math.abs(rgba.b - prev.b);
+        if (diff > 45) edge += 1;
+      }
+      prev = rgba;
+    }
+    const darkRatio = dark / Math.max(1, count);
+    const edgeRatio = edge / Math.max(1, count - 1);
+    if (darkRatio >= 0.965 && edgeRatio <= 0.012) darkRows += 1;
+    if (darkRatio >= 0.88 && edgeRatio <= 0.025) loadingLikeRows += 1;
+  }
+  const sampledRows = Math.max(1, rows);
+  return {
+    width,
+    height,
+    darkBlankRowsRatio: darkRows / sampledRows,
+    loadingLikeRowsRatio: loadingLikeRows / sampledRows
+  };
+};
+var resolveScreenshotQualityIssue = (analysis) => {
+  if (!analysis) return null;
+  if (analysis.loadingLikeRowsRatio >= 0.92 || analysis.darkBlankRowsRatio >= 0.72) {
+    return "loading-like-dark-screenshot";
   }
+  return null;
+};
+var captureExpandedFullPageScreenshot = async (page, options = {}) => {
+  const attempts = Math.max(1, toPositiveInteger(options.qualityRetryAttempts, DEFAULT_QUALITY_RETRY_ATTEMPTS));
+  const retryDelayMs = Math.max(0, Number(options.qualityRetryDelayMs ?? DEFAULT_QUALITY_RETRY_DELAY_MS) || 0);
+  let lastBuffer = null;
+  let lastAnalysis = null;
+  let lastIssue = null;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    const buffer = await captureExpandedFullPageScreenshotOnce(page, options);
+    const analysis = await analyzeScreenshotBuffer(buffer).catch((error) => {
+      logger.warning(`\u622A\u56FE\u8D28\u91CF\u5206\u6790\u5931\u8D25: ${error?.message || error}`);
+      return null;
+    });
+    const issue = resolveScreenshotQualityIssue(analysis);
+    lastBuffer = buffer;
+    lastAnalysis = analysis;
+    lastIssue = issue;
+    if (!issue) return buffer;
+    if (attempt < attempts && retryDelayMs > 0) {
+      logger.warning(`\u622A\u56FE\u7591\u4F3C\u5F02\u5E38(${issue})\uFF0C\u7B49\u5F85\u540E\u91CD\u8BD5: attempt=${attempt}/${attempts}`);
+      await (0, import_delay.default)(retryDelayMs);
+    }
+  }
+  if (lastIssue && lastAnalysis) {
+    logger.warning(
+      `\u622A\u56FE\u8D28\u91CF\u4ECD\u5F02\u5E38(${lastIssue})\uFF0C\u8FD4\u56DE\u6700\u4F73\u53EF\u5F97\u7ED3\u679C: dark=${lastAnalysis.darkBlankRowsRatio.toFixed(2)}, loading=${lastAnalysis.loadingLikeRowsRatio.toFixed(2)}`
+    );
+  }
+  return lastBuffer;
 };
 
 // src/errors.js
@@ -1489,6 +1621,9 @@ var ProxyMeterRuntime = {
   getProxyMeterSnapshot
 };
 
+// src/internals/constants.js
+var PageRuntimeStateKey = "__playwright_toolkit_runtime_state__";
+
 // src/runtime-env.js
 var BROWSER_PROFILE_SCHEMA_VERSION = 1;
 var SUPPORTED_CLOAK_FINGERPRINT_PLATFORMS = /* @__PURE__ */ new Set(["linux", "macos", "windows"]);
@@ -9068,11 +9203,11 @@ var resolveScreenshotWatermarkifyMeta = async (page, options = {}) => {
     watermark: options.watermark,
     strip: options.strip,
     stripLogoSrc,
-    device: resolvePageDevice2(page)
+    device: resolvePageDevice(page)
   };
 };
 var buildFontFamily = () => 'MiSans, "SF Pro Display", "PingFang SC", "Helvetica Neue", Arial, sans-serif';
-var resolvePageDevice2 = (page) => normalizeDevice(page?.[PageRuntimeStateKey]?.device);
+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 : {};
@@ -9724,7 +9859,7 @@ var watermarkifyScreenshotBuffer = async (buffer, meta, page = null, options = {
 };
 
 // src/internals/compression.js
-var import_jimp = require("jimp");
+var import_jimp2 = require("jimp");
 var logger15 = createInternalLogger("Compression");
 var DEFAULT_SCREENSHOT_MAX_BYTES = 5 * 1024 * 1024;
 var DEFAULT_SCREENSHOT_OUTPUT_TYPE = "jpeg";
@@ -9791,10 +9926,10 @@ var encodeJpeg = async (sourceImage, compression, scale, quality) => {
     image.resize({
       w: width,
       h: height,
-      mode: import_jimp.ResizeStrategy.BILINEAR
+      mode: import_jimp2.ResizeStrategy.BILINEAR
     });
   }
-  const buffer = await image.getBuffer(import_jimp.JimpMime.jpeg, { quality });
+  const buffer = await image.getBuffer(import_jimp2.JimpMime.jpeg, { quality });
   return {
     buffer,
     bytes: getBase64BytesFromBuffer(buffer),
@@ -9806,7 +9941,7 @@ var encodeJpeg = async (sourceImage, compression, scale, quality) => {
   };
 };
 var compressImageBuffer = async (buffer, compression) => {
-  const sourceImage = await import_jimp.Jimp.read(buffer);
+  const sourceImage = await import_jimp2.Jimp.read(buffer);
   const maxQuality = toJpegQuality(compression.quality);
   const minQuality = Math.min(maxQuality, toJpegQuality(compression.minQuality));
   let quality = maxQuality;