@skrillex1224/playwright-toolkit 2.1.207 → 2.1.208

package/dist/index.cjs

@@ -319,17 +319,6 @@ var ActorInfo = {
         "id"
       ]
     }
-  }),
-  quark: createActorInfo({
-    key: "quark",
-    name: "\u5938\u514B",
-    domain: "ai.quark.cn",
-    path: "/s",
-    share: {
-      mode: "dom",
-      prefix: "",
-      xurl: []
-    }
   })
 };
 
@@ -3285,7 +3274,7 @@ var Mutation = {
       if (text.length <= max) return text;
       return `${text.slice(0, max)}...`;
     };
-    const normalizeText = (value) => String(value || "").replace(/\s+/g, " ").trim();
+    const normalizeText2 = (value) => String(value || "").replace(/\s+/g, " ").trim();
     const normalizeHtml = (value) => String(value || "").trim();
     const hashSnapshot = (value) => (0, import_node_crypto.createHash)("sha256").update(String(value || "")).digest("hex");
     const buildState = async () => {
@@ -3350,7 +3339,7 @@ var Mutation = {
               if (frame) {
                 try {
                   const frameSnapshot = await readFrameSnapshot(frame);
-                  text = normalizeText(frameSnapshot?.text || "");
+                  text = normalizeText2(frameSnapshot?.text || "");
                   html = normalizeHtml(frameSnapshot?.html || "");
                   frameUrl = String(frameSnapshot?.url || "").trim();
                   readyState = String(frameSnapshot?.readyState || "").trim();
@@ -3364,7 +3353,7 @@ var Mutation = {
             } else {
               try {
                 const elementSnapshot = await readElementSnapshot(handle);
-                text = normalizeText(elementSnapshot?.text || "");
+                text = normalizeText2(elementSnapshot?.text || "");
                 html = normalizeHtml(elementSnapshot?.html || "");
               } catch (error) {
                 source = "main-unreadable";
@@ -4558,6 +4547,905 @@ var Logger = {
 
 // src/share.js
 var import_delay2 = __toESM(require("delay"), 1);
+
+// src/internals/watermarkify.js
+var SCREENSHOT_WATERMARKIFY_HOST_ID = "__pk_screenshot_watermarkify__";
+var DEFAULT_TIMEZONE_OFFSET = 8;
+var DEFAULT_RESOLVER_TIMEOUT_MS = 180;
+var DEFAULT_IP_LOOKUP_TIMEOUT_MS = 1e4;
+var DEFAULT_WATERMARK_OPACITY = 0.156;
+var DEFAULT_WATERMARK_ROTATE_DEG = -16;
+var DEFAULT_WATERMARK_CELL_WIDTH = 860;
+var DEFAULT_WATERMARK_CELL_HEIGHT = 330;
+var DEFAULT_STRIP_LOGO_URL = "https://static.heartbitai.com/geo/icon/favicon.png";
+var DEFAULT_IP_LOOKUP_URL = "http://myip.ipip.net";
+var DEFAULT_LOGO_FETCH_TIMEOUT_MS = 2500;
+var WEAK_LOCATION_VALUES = /* @__PURE__ */ new Set(["cn", "\u4E2D\u56FD"]);
+var LOCATION_NETWORK_SUFFIX_PATTERNS = [
+  /(?:中国)?移动$/i,
+  /(?:中国)?联通$/i,
+  /(?:中国)?电信$/i,
+  /铁通$/i,
+  /教育网$/i,
+  /广电$/i,
+  /鹏博士$/i,
+  /阿里云$/i,
+  /腾讯云$/i,
+  /百度云$/i,
+  /华为云$/i,
+  /cloudflare$/i,
+  /amazon$/i,
+  /aws$/i,
+  /azure$/i,
+  /google$/i,
+  /oracle$/i,
+  /linode$/i,
+  /vultr$/i,
+  /digitalocean$/i
+];
+var cachedStripLogoSrcPromise = null;
+var normalizeText = (value) => String(value || "").trim();
+var toInline = (value, maxLen = 200) => {
+  const text = normalizeText(value);
+  if (!text) return "";
+  return text.replace(/\s+/g, " ").trim().slice(0, maxLen);
+};
+var shortenTail = (value, maxLen = 80) => {
+  const text = toInline(value, Math.max(maxLen * 2, maxLen + 8));
+  if (!text || text.length <= maxLen) return text;
+  return `${text.slice(0, Math.max(0, maxLen - 1)).trimEnd()}\u2026`;
+};
+var shortenMiddle = (value, maxLen = 56, headLen = 32, tailLen = 14) => {
+  const text = toInline(value, Math.max(maxLen * 2, maxLen + headLen + tailLen));
+  if (!text || text.length <= maxLen) return text;
+  const safeHeadLen = Math.max(4, Math.min(headLen, maxLen - 5));
+  const safeTailLen = Math.max(4, Math.min(tailLen, maxLen - safeHeadLen - 1));
+  return `${text.slice(0, safeHeadLen).trimEnd()}\u2026${text.slice(-safeTailLen).trimStart()}`;
+};
+var padDatePart = (value) => String(value).padStart(2, "0");
+var formatUtcOffsetLabel = (offsetHours = DEFAULT_TIMEZONE_OFFSET) => {
+  const sign = offsetHours >= 0 ? "+" : "-";
+  const absolute = Math.abs(offsetHours);
+  const hours = Math.trunc(absolute);
+  const minutes = Math.round((absolute - hours) * 60);
+  if (!minutes) {
+    return `UTC${sign}${hours}`;
+  }
+  return `UTC${sign}${hours}:${padDatePart(minutes)}`;
+};
+var formatTimestampForUtcOffset = (date, offsetHours = DEFAULT_TIMEZONE_OFFSET) => {
+  const source = date instanceof Date ? date : new Date(date || Date.now());
+  const shifted = new Date(source.getTime() + offsetHours * 60 * 60 * 1e3);
+  return [
+    `${shifted.getUTCFullYear()}-${padDatePart(shifted.getUTCMonth() + 1)}-${padDatePart(shifted.getUTCDate())}`,
+    `${padDatePart(shifted.getUTCHours())}:${padDatePart(shifted.getUTCMinutes())}:${padDatePart(shifted.getUTCSeconds())}`,
+    formatUtcOffsetLabel(offsetHours)
+  ].join(" ");
+};
+var normalizeWhitespace = (value) => String(value || "").replace(/\u00a0/g, " ").replace(/\s+/g, " ").trim();
+var stripLocationNetworkSuffix = (value) => {
+  const parts = normalizeWhitespace(value).split(" ").filter(Boolean);
+  if (parts.length <= 1) {
+    return normalizeWhitespace(value);
+  }
+  const last = parts[parts.length - 1];
+  if (!LOCATION_NETWORK_SUFFIX_PATTERNS.some((pattern) => pattern.test(last))) {
+    return parts.join(" ");
+  }
+  return parts.slice(0, -1).join(" ").trim();
+};
+var isWeakLocationValue = (value) => {
+  const text = normalizeWhitespace(value).toLowerCase();
+  if (!text) return true;
+  if (WEAK_LOCATION_VALUES.has(text)) return true;
+  return /^[a-z]{2,3}$/i.test(text);
+};
+var pickHeaderValue = async (response, names = []) => {
+  if (!response || typeof response.headerValue !== "function") return "";
+  for (const name of names) {
+    const value = await response.headerValue(name).catch(() => null);
+    const text = normalizeText(value);
+    if (text) return text;
+  }
+  return "";
+};
+var parseIpIpResponse = (rawText) => {
+  const text = normalizeWhitespace(rawText);
+  if (!text) return null;
+  const ipMatch = text.match(/当前\s*IP[:：]\s*([^\s]+)/i) || text.match(/\b((?:\d{1,3}\.){3}\d{1,3}|(?:[0-9a-f]{0,4}:){2,}[0-9a-f]{0,4})\b/i);
+  const locationMatch = text.match(/来自于[:：]?\s*(.+)$/i);
+  const ip = toInline(ipMatch?.[1], 80);
+  const rawLocation = toInline(locationMatch?.[1], 120);
+  const location = toInline(stripLocationNetworkSuffix(rawLocation), 80) || rawLocation;
+  if (!ip && !location) {
+    return null;
+  }
+  return { ip, location };
+};
+var fillEnrichment = (target, source) => {
+  if (!target || !source || typeof source !== "object") {
+    return target;
+  }
+  if (!target.ip && source.ip) {
+    target.ip = toInline(source.ip, 80);
+  }
+  if (!target.location && source.location) {
+    target.location = toInline(source.location, 80);
+  }
+  return target;
+};
+var getHostname = (url) => {
+  try {
+    const parsed = new URL(url);
+    return parsed.hostname || parsed.host || "\u672C\u5730\u9875\u9762";
+  } catch {
+    if (/^https?:\/\//i.test(url)) {
+      return url;
+    }
+    return "\u672C\u5730\u9875\u9762";
+  }
+};
+var withTimeout = async (promise, timeoutMs) => {
+  const safeTimeoutMs = Math.max(0, Number(timeoutMs) || 0);
+  if (!safeTimeoutMs) {
+    return promise;
+  }
+  let timer = null;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(null), safeTimeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+};
+var fetchAsDataUrl = async (url, timeoutMs = DEFAULT_LOGO_FETCH_TIMEOUT_MS) => {
+  if (typeof fetch !== "function") {
+    return "";
+  }
+  const controller = typeof AbortController === "function" ? new AbortController() : null;
+  const safeTimeoutMs = Math.max(300, Number(timeoutMs) || DEFAULT_LOGO_FETCH_TIMEOUT_MS);
+  const timer = controller ? setTimeout(() => controller.abort(), safeTimeoutMs) : null;
+  try {
+    const response = await fetch(url, {
+      redirect: "follow",
+      signal: controller?.signal
+    });
+    if (!response?.ok) {
+      return "";
+    }
+    const contentType = normalizeText(response.headers?.get?.("content-type")) || "image/png";
+    if (!/^image\//i.test(contentType)) {
+      return "";
+    }
+    const buffer = Buffer.from(await response.arrayBuffer());
+    if (!buffer.length) {
+      return "";
+    }
+    return `data:${contentType};base64,${buffer.toString("base64")}`;
+  } catch {
+    return "";
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+};
+var resolveStripLogoSrc = async () => {
+  if (!cachedStripLogoSrcPromise) {
+    cachedStripLogoSrcPromise = (async () => {
+      const dataUrl = await fetchAsDataUrl(DEFAULT_STRIP_LOGO_URL);
+      return dataUrl || DEFAULT_STRIP_LOGO_URL;
+    })();
+  }
+  const resolved = await cachedStripLogoSrcPromise.catch(() => DEFAULT_STRIP_LOGO_URL);
+  return normalizeText(resolved) || DEFAULT_STRIP_LOGO_URL;
+};
+var normalizeLayer = (value, defaults) => {
+  if (value === false) {
+    return {
+      ...defaults,
+      enabled: false
+    };
+  }
+  if (value && typeof value === "object") {
+    return {
+      ...defaults,
+      ...value,
+      enabled: value.enabled !== false
+    };
+  }
+  return {
+    ...defaults,
+    enabled: true
+  };
+};
+var resolveWithCustomResolver = async (page, baseMeta, options = {}) => {
+  const resolver = typeof options.resolver === "function" ? options.resolver : null;
+  if (!resolver) {
+    return null;
+  }
+  const response = options.response && typeof options.response === "object" ? options.response : null;
+  const serverAddr = response && typeof response.serverAddr === "function" ? await response.serverAddr().catch(() => null) : null;
+  const controller = typeof AbortController === "function" ? new AbortController() : null;
+  try {
+    const resolved = await withTimeout(
+      Promise.resolve(resolver({
+        page,
+        response,
+        url: baseMeta.url,
+        hostname: baseMeta.hostname,
+        title: baseMeta.title,
+        query: baseMeta.query,
+        taskId: baseMeta.taskId,
+        serverAddr,
+        signal: controller?.signal
+      })).catch(() => null),
+      options.resolverTimeoutMs ?? DEFAULT_RESOLVER_TIMEOUT_MS
+    );
+    if (!resolved || typeof resolved !== "object") {
+      return null;
+    }
+    return {
+      ip: toInline(resolved.ip, 80),
+      location: toInline(resolved.location, 80)
+    };
+  } finally {
+    controller?.abort();
+  }
+};
+var openProbePage = async (page) => {
+  if (!page || typeof page.context !== "function") {
+    return null;
+  }
+  const context = page.context();
+  if (!context) {
+    return null;
+  }
+  if (typeof context.newPage === "function") {
+    try {
+      const probePage2 = await context.newPage();
+      return {
+        page: probePage2,
+        close: async () => {
+          await probePage2.close().catch(() => {
+          });
+        }
+      };
+    } catch {
+    }
+  }
+  const browser = typeof context.browser === "function" ? context.browser() : null;
+  if (!browser || typeof browser.newContext !== "function") {
+    return null;
+  }
+  const probeContext = await browser.newContext().catch(() => null);
+  if (!probeContext || typeof probeContext.newPage !== "function") {
+    await probeContext?.close?.().catch(() => {
+    });
+    return null;
+  }
+  const probePage = await probeContext.newPage().catch(async () => {
+    await probeContext.close().catch(() => {
+    });
+    return null;
+  });
+  if (!probePage) {
+    return null;
+  }
+  return {
+    page: probePage,
+    close: async () => {
+      await probeContext.close().catch(() => {
+      });
+    }
+  };
+};
+var resolveWithIpLookup = async (page, options = {}) => {
+  if (!page || typeof page.context !== "function" || options.ipLookup === false) {
+    return null;
+  }
+  const probeScope = await openProbePage(page);
+  if (!probeScope?.page) {
+    return null;
+  }
+  const timeoutMs = Math.max(
+    300,
+    Number(options.ipLookupTimeoutMs) || DEFAULT_IP_LOOKUP_TIMEOUT_MS
+  );
+  try {
+    const probePage = probeScope.page;
+    const response = await probePage.goto(DEFAULT_IP_LOOKUP_URL, {
+      waitUntil: "commit",
+      timeout: timeoutMs
+    }).catch(() => null);
+    let rawText = "";
+    if (response && typeof response.text === "function") {
+      rawText = String(await withTimeout(
+        response.text().catch(() => ""),
+        timeoutMs
+      ) || "");
+    }
+    if (!rawText) {
+      rawText = String(await withTimeout(
+        probePage.evaluate(() => {
+          return document.body?.innerText || document.documentElement?.innerText || "";
+        }).catch(() => ""),
+        Math.min(timeoutMs, 500)
+      ) || "");
+    }
+    return parseIpIpResponse(rawText);
+  } catch {
+    return null;
+  } finally {
+    await probeScope.close().catch(() => {
+    });
+  }
+};
+var resolveEnrichment = async (page, baseMeta, options) => {
+  const response = options.response && typeof options.response === "object" ? options.response : null;
+  const merged = {
+    ip: toInline(options.ip, 80),
+    location: toInline(options.location, 80)
+  };
+  if (!merged.ip || !merged.location) {
+    fillEnrichment(
+      merged,
+      await resolveWithCustomResolver(page, baseMeta, options)
+    );
+  }
+  if ((!merged.ip || !merged.location) && options.ipLookup !== false) {
+    fillEnrichment(
+      merged,
+      await resolveWithIpLookup(page, options)
+    );
+  }
+  if (!merged.location || isWeakLocationValue(merged.location)) {
+    const headerLocation = toInline(await pickHeaderValue(response, [
+      "cf-ipcountry",
+      "x-vercel-ip-country",
+      "x-country-code",
+      "x-geo-country"
+    ]), 80);
+    if (!merged.location || isWeakLocationValue(merged.location) && headerLocation) {
+      merged.location = headerLocation || merged.location;
+    }
+  }
+  return merged;
+};
+var buildWatermarkStamp = ({ taskId, captureTime, ip, location }) => {
+  const parts = [
+    `TaskID ${shortenMiddle(taskId, 56, 24, 16) || "-"}`,
+    `Time ${captureTime}`,
+    `Loc ${shortenTail(location, 20) || "-"}`,
+    `IP ${toInline(ip, 24) || "-"}`
+  ];
+  return parts.join(" | ");
+};
+var buildStripSegments = ({ taskId, captureTime, ip, location }) => {
+  return [
+    {
+      kind: "taskId",
+      label: "TaskID",
+      value: toInline(taskId, 240) || "-",
+      rawValue: toInline(taskId, 240) || "-"
+    },
+    {
+      kind: "time",
+      label: "Time",
+      value: captureTime,
+      rawValue: captureTime
+    },
+    {
+      kind: "location",
+      label: "Loc",
+      value: shortenTail(location, 24) || "-",
+      rawValue: toInline(location, 80) || "-"
+    },
+    {
+      kind: "ip",
+      label: "IP",
+      value: toInline(ip, 28) || "-",
+      rawValue: toInline(ip, 80) || "-"
+    }
+  ];
+};
+var createBaseWatermarkifyOptions = () => ({
+  enabled: true,
+  timezoneOffsetHours: DEFAULT_TIMEZONE_OFFSET,
+  response: null,
+  ip: "",
+  location: "",
+  query: "",
+  taskId: "",
+  ipLookup: true,
+  ipLookupTimeoutMs: DEFAULT_IP_LOOKUP_TIMEOUT_MS,
+  resolver: null,
+  resolverTimeoutMs: DEFAULT_RESOLVER_TIMEOUT_MS,
+  watermark: normalizeLayer(void 0, {
+    opacity: DEFAULT_WATERMARK_OPACITY,
+    rotateDeg: DEFAULT_WATERMARK_ROTATE_DEG,
+    cellWidth: DEFAULT_WATERMARK_CELL_WIDTH,
+    cellHeight: DEFAULT_WATERMARK_CELL_HEIGHT
+  }),
+  strip: normalizeLayer(void 0, {})
+});
+var createDisabledWatermarkifyOptions = () => ({
+  ...createBaseWatermarkifyOptions(),
+  enabled: false,
+  watermark: normalizeLayer(false, {
+    opacity: DEFAULT_WATERMARK_OPACITY,
+    rotateDeg: DEFAULT_WATERMARK_ROTATE_DEG,
+    cellWidth: DEFAULT_WATERMARK_CELL_WIDTH,
+    cellHeight: DEFAULT_WATERMARK_CELL_HEIGHT
+  }),
+  strip: normalizeLayer(false, {})
+});
+var normalizeScreenshotWatermarkify = (value) => {
+  const base = createBaseWatermarkifyOptions();
+  if (value === false) {
+    return createDisabledWatermarkifyOptions();
+  }
+  if (value == null || value === true) {
+    return base;
+  }
+  const source = value && typeof value === "object" ? value : {};
+  const timezoneOffsetHoursRaw = Number(source.timezoneOffsetHours);
+  const ipLookupTimeoutMsRaw = Number(source.ipLookupTimeoutMs);
+  const resolverTimeoutMsRaw = Number(source.resolverTimeoutMs);
+  return {
+    ...base,
+    enabled: source.enabled !== false,
+    timezoneOffsetHours: Number.isFinite(timezoneOffsetHoursRaw) ? timezoneOffsetHoursRaw : DEFAULT_TIMEZONE_OFFSET,
+    response: source.response ?? null,
+    ip: normalizeText(source.ip),
+    location: normalizeText(source.location),
+    query: toInline(source.query, 140),
+    taskId: toInline(source.taskId, 120),
+    ipLookup: source.ipLookup !== false,
+    ipLookupTimeoutMs: Number.isFinite(ipLookupTimeoutMsRaw) ? ipLookupTimeoutMsRaw : DEFAULT_IP_LOOKUP_TIMEOUT_MS,
+    resolver: typeof source.resolver === "function" ? source.resolver : null,
+    resolverTimeoutMs: Number.isFinite(resolverTimeoutMsRaw) ? resolverTimeoutMsRaw : DEFAULT_RESOLVER_TIMEOUT_MS,
+    watermark: normalizeLayer(source.watermark, {
+      opacity: DEFAULT_WATERMARK_OPACITY,
+      rotateDeg: DEFAULT_WATERMARK_ROTATE_DEG,
+      cellWidth: DEFAULT_WATERMARK_CELL_WIDTH,
+      cellHeight: DEFAULT_WATERMARK_CELL_HEIGHT
+    }),
+    strip: normalizeLayer(source.strip, {})
+  };
+};
+var resolveScreenshotWatermarkifyMeta = async (page, options = {}) => {
+  const timezoneOffsetHours = options.timezoneOffsetHours ?? DEFAULT_TIMEZONE_OFFSET;
+  const url = normalizeText(page?.url?.()) || "about:blank";
+  const title = normalizeText(await page.title().catch(() => "")) || "\u672A\u547D\u540D\u9875\u9762";
+  const hostname = getHostname(url);
+  const query = normalizeText(options.query) || title || "\u672A\u63D0\u4F9B Query";
+  const taskId = normalizeText(options.taskId) || "-";
+  const captureTime = formatTimestampForUtcOffset(/* @__PURE__ */ new Date(), timezoneOffsetHours);
+  const [enrichment, stripLogoSrc] = await Promise.all([
+    resolveEnrichment(page, {
+      url,
+      hostname,
+      title,
+      query,
+      taskId
+    }, options),
+    resolveStripLogoSrc()
+  ]);
+  const ip = enrichment.ip || "-";
+  const location = enrichment.location || "-";
+  return {
+    watermarkText: buildWatermarkStamp({
+      taskId,
+      captureTime,
+      ip,
+      location
+    }),
+    stripSegments: buildStripSegments({
+      taskId,
+      captureTime,
+      ip,
+      location
+    }),
+    watermark: options.watermark,
+    strip: options.strip,
+    stripLogoSrc
+  };
+};
+var installScreenshotWatermarkify = async (page, meta) => {
+  const hasWatermark = meta?.watermark?.enabled !== false && normalizeText(meta?.watermarkText);
+  const hasStrip = meta?.strip?.enabled !== false && Array.isArray(meta?.stripSegments) && meta.stripSegments.length > 0;
+  if (!page || !meta || !hasWatermark && !hasStrip) {
+    return async () => {
+    };
+  }
+  await page.evaluate(({ hostId, watermarkifyMeta, defaults }) => {
+    const previousHost = document.getElementById(hostId);
+    if (previousHost && typeof previousHost.__pkCleanup === "function") {
+      previousHost.__pkCleanup();
+    }
+    previousHost?.remove();
+    const mountPoint = document.body || document.documentElement;
+    if (!mountPoint) return;
+    const createNode = (tagName, className) => {
+      const node = document.createElement(tagName);
+      if (className) node.className = className;
+      return node;
+    };
+    const safeText = (value) => String(value || "").trim();
+    const host = document.createElement("div");
+    host.id = hostId;
+    host.style.position = "fixed";
+    host.style.inset = "0";
+    host.style.width = "100vw";
+    host.style.height = "100vh";
+    host.style.pointerEvents = "none";
+    host.style.zIndex = "2147483646";
+    const shadow = host.attachShadow({ mode: "open" });
+    const style = document.createElement("style");
+    style.textContent = `
+            :host {
+                all: initial;
+                position: fixed;
+                inset: 0;
+                width: 100vw;
+                height: 100vh;
+                pointer-events: none;
+                z-index: 2147483646;
+            }
+
+            .root {
+                position: absolute;
+                inset: 0;
+                width: 100%;
+                height: 100%;
+                overflow: hidden;
+                pointer-events: none;
+                font-family: MiSans, "SF Pro Display", "PingFang SC", "Helvetica Neue", Arial, sans-serif;
+            }
+
+            .watermark {
+                position: absolute;
+                inset: 0;
+                overflow: hidden;
+                pointer-events: none;
+            }
+
+            .wmStamp {
+                position: absolute;
+                left: 0;
+                top: 0;
+                transform-origin: left center;
+                pointer-events: none;
+                white-space: nowrap;
+            }
+
+            .wmStampText {
+                color: rgba(17, 17, 17, var(--wm-opacity, 0.15));
+                font-size: 19px;
+                font-weight: 720;
+                line-height: 1;
+                letter-spacing: 0.032em;
+                text-shadow: 0 1px 0 rgba(255, 255, 255, 0.44);
+                -webkit-text-stroke: 0.22px rgba(255, 255, 255, 0.12);
+                font-variant-numeric: tabular-nums;
+                filter: saturate(0.92);
+            }
+
+            .strip {
+                position: absolute;
+                left: 0;
+                right: 0;
+                bottom: 0;
+                min-height: 78px;
+                padding: 0 22px 0 20px;
+                display: flex;
+                align-items: center;
+                overflow: hidden;
+                border-top: 1px solid rgba(17, 17, 17, 0.1);
+                background:
+                    linear-gradient(180deg, rgba(255, 255, 255, 0.995) 0%, rgba(248, 248, 247, 0.985) 100%);
+                box-shadow:
+                    0 -22px 48px rgba(15, 23, 42, 0.1),
+                    inset 0 1px 0 rgba(255, 255, 255, 0.92);
+                backdrop-filter: blur(16px);
+                -webkit-backdrop-filter: blur(16px);
+            }
+
+            .strip::before {
+                content: "";
+                position: absolute;
+                left: 20px;
+                right: 52%;
+                top: 0;
+                height: 2px;
+                border-radius: 999px;
+                background: linear-gradient(
+                    90deg,
+                    rgba(17, 17, 17, 0.98) 0%,
+                    rgba(17, 17, 17, 0.68) 24%,
+                    rgba(17, 17, 17, 0.08) 58%,
+                    rgba(17, 17, 17, 0) 100%
+                );
+            }
+
+            .stripInner {
+                position: relative;
+                z-index: 1;
+                display: flex;
+                align-items: center;
+                gap: 16px;
+                width: 100%;
+                min-width: 0;
+            }
+
+            .stripLogo {
+                position: relative;
+                width: 28px;
+                height: 28px;
+                flex: none;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+            }
+
+            .stripLogoImg {
+                width: 28px;
+                height: 28px;
+                object-fit: contain;
+                display: block;
+            }
+
+            .segments {
+                display: flex;
+                align-items: center;
+                gap: 0;
+                flex: 1 1 auto;
+                min-width: 0;
+                white-space: nowrap;
+            }
+
+            .segment {
+                position: relative;
+                display: inline-flex;
+                align-items: center;
+                gap: 10px;
+                min-width: 0;
+                flex: none;
+                padding-right: 16px;
+                margin-right: 16px;
+            }
+
+            .segment:not(:last-child)::after {
+                content: "";
+                position: absolute;
+                top: 50%;
+                right: 0;
+                width: 1px;
+                height: 25px;
+                transform: translateY(-50%);
+                background: linear-gradient(
+                    180deg,
+                    rgba(148, 163, 184, 0) 0%,
+                    rgba(148, 163, 184, 0.34) 24%,
+                    rgba(148, 163, 184, 0.34) 76%,
+                    rgba(148, 163, 184, 0) 100%
+                );
+            }
+
+            .segmentTaskId {
+                flex: 1 1 auto;
+                max-width: none;
+                min-width: 0;
+            }
+
+            .label {
+                width: 52px;
+                color: rgba(17, 17, 17, 0.42);
+                font-size: 12px;
+                font-weight: 600;
+                line-height: 1;
+                letter-spacing: 0.01em;
+                flex: none;
+                display: inline-flex;
+                align-items: center;
+                justify-content: flex-start;
+            }
+
+            .value {
+                color: #111111;
+                font-size: 18px;
+                font-weight: 710;
+                line-height: 1;
+                min-width: 0;
+                overflow: hidden;
+                text-overflow: ellipsis;
+                font-variant-numeric: tabular-nums;
+                display: inline-flex;
+                align-items: center;
+            }
+
+            .segmentTaskId .value {
+                color: #101010;
+                font-size: 15px;
+                font-weight: 760;
+                letter-spacing: -0.01em;
+            }
+
+            .segmentTime .value {
+                color: #202020;
+                font-size: 17px;
+                font-weight: 700;
+            }
+
+            .segmentLocation .value,
+            .segmentIp .value {
+                color: #2a2a2a;
+                font-size: 17px;
+                font-weight: 700;
+            }
+
+        `;
+    const root = createNode("div", "root");
+    const watermarkNode = createNode("div", "watermark");
+    const stripNode = createNode("div", "strip");
+    const stripInner = createNode("div", "stripInner");
+    const stripLogo = createNode("div", "stripLogo");
+    const stripLogoImg = createNode("img", "stripLogoImg");
+    const stripSegmentsNode = createNode("div", "segments");
+    stripLogoImg.alt = "";
+    stripLogoImg.decoding = "async";
+    stripLogoImg.referrerPolicy = "no-referrer";
+    stripLogoImg.src = safeText(watermarkifyMeta?.stripLogoSrc) || defaults.logoUrl;
+    stripLogo.appendChild(stripLogoImg);
+    stripInner.appendChild(stripLogo);
+    stripInner.appendChild(stripSegmentsNode);
+    stripNode.appendChild(stripInner);
+    root.appendChild(watermarkNode);
+    root.appendChild(stripNode);
+    shadow.appendChild(style);
+    shadow.appendChild(root);
+    mountPoint.appendChild(host);
+    const buildSegmentNode = (segment) => {
+      const kind = String(segment?.kind || "").trim();
+      const label = String(segment?.label || "").trim();
+      const value = String(segment?.value || "").trim();
+      const rawValue = String(segment?.rawValue || value).trim();
+      const classSuffix = kind ? ` segment${kind.slice(0, 1).toUpperCase()}${kind.slice(1)}` : "";
+      const segmentNode = createNode("span", `segment${classSuffix}`);
+      const labelNode = createNode("span", "label");
+      const valueNode = createNode("span", "value");
+      labelNode.textContent = label;
+      valueNode.textContent = value;
+      segmentNode.title = rawValue ? `${label} ${rawValue}` : label;
+      segmentNode.appendChild(labelNode);
+      segmentNode.appendChild(valueNode);
+      return segmentNode;
+    };
+    const renderStrip = () => {
+      const stripSegments = Array.isArray(watermarkifyMeta?.stripSegments) ? watermarkifyMeta.stripSegments : [];
+      if (!watermarkifyMeta?.strip?.enabled || stripSegments.length === 0) {
+        stripNode.remove();
+        return;
+      }
+      const fragment = document.createDocumentFragment();
+      for (const segment of stripSegments) {
+        fragment.appendChild(buildSegmentNode(segment));
+      }
+      stripSegmentsNode.replaceChildren(fragment);
+    };
+    const waitForLogo = async () => {
+      if (!stripLogoImg.getAttribute("src")) {
+        return;
+      }
+      await new Promise((resolve) => {
+        let settled = false;
+        const done = () => {
+          if (settled) return;
+          settled = true;
+          resolve();
+        };
+        const fail = () => {
+          if (settled) return;
+          stripLogo.remove();
+          done();
+        };
+        const timeoutDone = () => {
+          if (settled) return;
+          done();
+        };
+        if (stripLogoImg.complete && stripLogoImg.naturalWidth > 0) {
+          done();
+          return;
+        }
+        if (stripLogoImg.complete && stripLogoImg.naturalWidth === 0) {
+          fail();
+          return;
+        }
+        stripLogoImg.addEventListener("load", done, { once: true });
+        stripLogoImg.addEventListener("error", fail, { once: true });
+        setTimeout(timeoutDone, 2500);
+      });
+    };
+    const renderWatermark = () => {
+      const stampText = safeText(watermarkifyMeta?.watermarkText);
+      if (!watermarkifyMeta?.watermark?.enabled || !stampText) {
+        watermarkNode.remove();
+        return;
+      }
+      const cellWidth = Math.max(680, Number(watermarkifyMeta.watermark.cellWidth) || defaults.cellWidth);
+      const cellHeight = Math.max(260, Number(watermarkifyMeta.watermark.cellHeight) || defaults.cellHeight);
+      const rotateDeg = Number(watermarkifyMeta.watermark.rotateDeg) || defaults.rotateDeg;
+      const opacity = Math.min(0.22, Math.max(0.05, Number(watermarkifyMeta.watermark.opacity) || defaults.opacity));
+      const width = watermarkNode.clientWidth || window.innerWidth || document.documentElement.clientWidth || cellWidth;
+      const height = watermarkNode.clientHeight || window.innerHeight || document.documentElement.clientHeight || cellHeight;
+      const rowOffset = Math.round(cellWidth * 0.24);
+      const startX = -Math.round(cellWidth * 0.16);
+      const startY = -Math.round(cellHeight * 0.12);
+      const cols = Math.ceil((width + cellWidth * 1.1) / cellWidth) + 1;
+      const rows = Math.ceil((height + cellHeight * 0.9) / cellHeight) + 1;
+      const fragment = document.createDocumentFragment();
+      for (let row = 0; row < rows; row += 1) {
+        for (let col = 0; col < cols; col += 1) {
+          const stamp = createNode("div", "wmStamp");
+          const stampTextNode = createNode("div", "wmStampText");
+          const x = startX + col * cellWidth + (row % 2 ? rowOffset : 0);
+          const y = startY + row * cellHeight + (row % 2 ? 14 : -8);
+          stamp.style.transform = `translate(${x}px, ${y}px) rotate(${rotateDeg}deg)`;
+          stampTextNode.style.setProperty("--wm-opacity", String(opacity));
+          stampTextNode.textContent = stampText;
+          stamp.appendChild(stampTextNode);
+          fragment.appendChild(stamp);
+        }
+      }
+      watermarkNode.replaceChildren(fragment);
+    };
+    let resizeFrame = 0;
+    const queueWatermarkRender = () => {
+      if (!watermarkNode.isConnected) return;
+      cancelAnimationFrame(resizeFrame);
+      resizeFrame = requestAnimationFrame(() => {
+        renderWatermark();
+      });
+    };
+    const handleResize = () => {
+      queueWatermarkRender();
+    };
+    host.__pkCleanup = () => {
+      cancelAnimationFrame(resizeFrame);
+      window.removeEventListener("resize", handleResize);
+    };
+    renderStrip();
+    renderWatermark();
+    queueWatermarkRender();
+    window.addEventListener("resize", handleResize, { passive: true });
+    return waitForLogo();
+  }, {
+    hostId: SCREENSHOT_WATERMARKIFY_HOST_ID,
+    watermarkifyMeta: meta,
+    defaults: {
+      opacity: DEFAULT_WATERMARK_OPACITY,
+      rotateDeg: DEFAULT_WATERMARK_ROTATE_DEG,
+      cellWidth: DEFAULT_WATERMARK_CELL_WIDTH,
+      cellHeight: DEFAULT_WATERMARK_CELL_HEIGHT,
+      logoUrl: DEFAULT_STRIP_LOGO_URL
+    }
+  });
+  return async () => {
+    await page.evaluate((hostId) => {
+      const host = document.getElementById(hostId);
+      if (host && typeof host.__pkCleanup === "function") {
+        host.__pkCleanup();
+      }
+      host?.remove();
+    }, SCREENSHOT_WATERMARKIFY_HOST_ID).catch(() => {
+    });
+  };
+};
+
+// src/share.js
 var logger11 = createInternalLogger("Share");
 var DEFAULT_TIMEOUT_MS2 = 50 * 1e3;
 var DEFAULT_PAYLOAD_SNAPSHOT_MAX_LEN = 500;
@@ -4568,14 +5456,14 @@ var toSnapshot = (value, maxLen) => {
   if (!text) return "";
   return text.replace(/\s+/g, " ").trim().slice(0, maxLen);
 };
-var toInline = (value, maxLen = 200) => {
+var toInline2 = (value, maxLen = 200) => {
   const text = String(value || "");
   if (!text) return "";
   return text.replace(/\s+/g, " ").trim().slice(0, maxLen);
 };
 var toJsonInline = (value, maxLen = 260) => {
   try {
-    return toInline(JSON.stringify(value), maxLen);
+    return toInline2(JSON.stringify(value), maxLen);
   } catch {
     return "[\u4E0D\u53EF\u5E8F\u5217\u5316]";
   }
@@ -4963,6 +5851,9 @@ var Share = {
     const buffer = options.buffer ?? defaultBuffer;
     const restore = options.restore ?? false;
     const maxHeight = options.maxHeight ?? 8e3;
+    const screenshotWatermarkify = normalizeScreenshotWatermarkify(options.watermarkify ?? true);
+    let cleanupScreenshotWatermarkify = async () => {
+    };
     try {
       const maxScrollHeight = await page.evaluate(() => {
         let maxHeight2 = document.body.scrollHeight;
@@ -4990,6 +5881,11 @@ var Share = {
         height: targetHeight
       });
       await (0, import_delay2.default)(1e3);
+      if (screenshotWatermarkify.enabled) {
+        const watermarkifyMeta = await resolveScreenshotWatermarkifyMeta(page, screenshotWatermarkify);
+        cleanupScreenshotWatermarkify = await installScreenshotWatermarkify(page, watermarkifyMeta);
+        await (0, import_delay2.default)(120);
+      }
       const buffer_ = await capturePageScreenshot(page, {
         fullPage: true,
         type: "png",
@@ -4997,6 +5893,7 @@ var Share = {
       });
       return buffer_.toString("base64");
     } finally {
+      await cleanupScreenshotWatermarkify();
       if (restore) {
         await page.evaluate(() => {
           document.querySelectorAll(".__pk_expanded__").forEach((el) => {