@sns-myagent/cli 0.2.0

package/src/tools/puppeteer/04_stealth_iframe.txt

@@ -0,0 +1,174 @@
+const iframeWindowProxies = new WeakMap();
+
+const isFrameIndexKey = (key) => {
+	if (typeof key !== "string" || key === "") return false;
+	const number = +key;
+	return number >= 0 && number < 4294967295 && Math_floor(number) === number && `${number}` === key;
+};
+
+const getPropertyDescriptor = (object, key) => {
+	let current = object;
+	while (current) {
+		const descriptor = Object_getOwnPropertyDescriptor(current, key);
+		if (descriptor) return descriptor;
+		current = Object_getPrototypeOf(current);
+	}
+};
+
+const descriptorWithValue = (target, key, value, writable) => {
+	const descriptor = Reflect_getOwnPropertyDescriptor(target, key);
+	if (descriptor && descriptor.configurable === false) return descriptor;
+	const next = descriptor ? Object_assign({}, descriptor) : { configurable: true, enumerable: true };
+	Reflect_deleteProperty(next, "get");
+	Reflect_deleteProperty(next, "set");
+	next.value = value;
+	if (!Reflect_has(next, "writable")) next.writable = writable;
+	return next;
+};
+const iframeContentWindowDescriptor =
+	typeof HTMLIFrameElement === "undefined"
+		? undefined
+		: getPropertyDescriptor(HTMLIFrameElement.prototype, "contentWindow");
+const iframeSrcdocDescriptor =
+	typeof HTMLIFrameElement === "undefined"
+		? undefined
+		: getPropertyDescriptor(HTMLIFrameElement.prototype, "srcdoc");
+
+const getNativeContentWindow = (iframe) => {
+	if (iframeContentWindowDescriptor && iframeContentWindowDescriptor.get) {
+		return Reflect_apply(iframeContentWindowDescriptor.get, iframe, []);
+	}
+	return undefined;
+};
+
+const addContentWindowProxy = (iframe) => {
+	let state = Reflect_apply(Page_WeakMap_get, iframeWindowProxies, [iframe]);
+	if (state) return state.proxy;
+
+	state = { proxy: undefined, target: undefined, wasConnected: false, setProxyTarget: undefined };
+
+	const isDiscarded = () => {
+		if (iframe.isConnected) state.wasConnected = true;
+		return state.wasConnected && !iframe.isConnected;
+	};
+
+	const currentFrameElement = () => {
+		if (iframe.isConnected) {
+			state.wasConnected = true;
+			return iframe;
+		}
+		return state.wasConnected ? null : iframe;
+	};
+
+	const contentWindowProxy = {
+		get(target, key) {
+			if (key === "self" || key === "window" || key === "frames" || key === "globalThis") return state.proxy;
+			if (key === "frameElement") return currentFrameElement();
+			if (key === "closed" && isDiscarded()) return true;
+			if (isFrameIndexKey(key)) return undefined;
+			if (key === "length") return 0;
+			return Reflect_get(target, key);
+		},
+		getOwnPropertyDescriptor(target, key) {
+			if (key === "self" || key === "window" || key === "frames" || key === "globalThis") {
+				return descriptorWithValue(target, key, state.proxy, true);
+			}
+			if (key === "frameElement") {
+				return descriptorWithValue(target, key, currentFrameElement(), false);
+			}
+			if (key === "closed" && isDiscarded()) {
+				return descriptorWithValue(target, key, true, false);
+			}
+			if (isFrameIndexKey(key)) return undefined;
+			if (key === "length") return descriptorWithValue(target, key, 0, false);
+			return Reflect_getOwnPropertyDescriptor(target, key);
+		},
+		has(target, key) {
+			if (key === "self" || key === "window" || key === "frames" || key === "globalThis" || key === "frameElement") return true;
+			if (isFrameIndexKey(key)) return false;
+			return Reflect_has(target, key);
+		},
+		ownKeys(target) {
+			const keys = Reflect_ownKeys(target);
+			const filtered = [];
+			for (let index = 0; index < keys.length; index++) {
+				if (!isFrameIndexKey(keys[index])) filtered.push(keys[index]);
+			}
+			return filtered;
+		},
+	};
+
+	const setProxyTarget = (target) => {
+		if (state.target === target && state.proxy) return state.proxy;
+		state.target = target;
+		state.proxy = new Window_Proxy(target, contentWindowProxy);
+		return state.proxy;
+	};
+	state.setProxyTarget = setProxyTarget;
+	const initialContentWindow = getNativeContentWindow(iframe);
+	if (initialContentWindow) setProxyTarget(initialContentWindow);
+	if (iframe.isConnected) state.wasConnected = true;
+	Reflect_apply(Page_WeakMap_set, iframeWindowProxies, [iframe, state]);
+
+
+	return state.proxy;
+};
+if (
+	iframeContentWindowDescriptor &&
+	iframeContentWindowDescriptor.get &&
+	iframeContentWindowDescriptor.configurable !== false
+) {
+	const contentWindowAccessors = {
+		get contentWindow() {
+			const state = Reflect_apply(Page_WeakMap_get, iframeWindowProxies, [this]);
+			if (!state) return getNativeContentWindow(this);
+			if (this.isConnected) state.wasConnected = true;
+			if (state.wasConnected && !this.isConnected) return null;
+			const nativeContentWindow = getNativeContentWindow(this);
+			if (!nativeContentWindow) return nativeContentWindow;
+			return state.setProxyTarget(nativeContentWindow);
+		},
+	};
+	const contentWindowGetter = Object_getOwnPropertyDescriptor(contentWindowAccessors, "contentWindow").get;
+	patchToString(contentWindowGetter, "get contentWindow");
+	Object_defineProperty(HTMLIFrameElement.prototype, "contentWindow", {
+		get: contentWindowGetter,
+		set: iframeContentWindowDescriptor.set,
+		enumerable: iframeContentWindowDescriptor.enumerable,
+		configurable: iframeContentWindowDescriptor.configurable,
+	});
+}
+
+
+if (
+	iframeSrcdocDescriptor &&
+	iframeSrcdocDescriptor.configurable !== false
+) {
+	const srcdocAccessors = {
+		get srcdoc() {
+			if (iframeSrcdocDescriptor.get) {
+				return Reflect_apply(iframeSrcdocDescriptor.get, this, []);
+			}
+			const value = this.getAttribute("srcdoc");
+			return value === null ? "" : value;
+		},
+		set srcdoc(newValue) {
+			addContentWindowProxy(this);
+			if (iframeSrcdocDescriptor.set) {
+				return Reflect_apply(iframeSrcdocDescriptor.set, this, [newValue]);
+			}
+			return this.setAttribute("srcdoc", newValue);
+		},
+	};
+	const srcdocDescriptor = Object_getOwnPropertyDescriptor(srcdocAccessors, "srcdoc");
+	const srcdocGetter = srcdocDescriptor.get;
+	const srcdocSetter = srcdocDescriptor.set;
+	patchToString(srcdocGetter, "get srcdoc");
+	patchToString(srcdocSetter, "set srcdoc");
+	Object_defineProperty(HTMLIFrameElement.prototype, "srcdoc", {
+		get: srcdocGetter,
+		set: srcdocSetter,
+		enumerable: iframeSrcdocDescriptor.enumerable,
+		configurable: iframeSrcdocDescriptor.configurable,
+	});
+}

package/src/tools/puppeteer/05_stealth_webgl.txt

@@ -0,0 +1,233 @@
+const webglPlatformSource =
+	String(navigator.userAgentData?.platform || navigator.platform || "") +
+	" " +
+	String(navigator.userAgent || "");
+const webglPlatformText = webglPlatformSource.toLowerCase();
+const webglPlatformKind = webglPlatformText.includes("android")
+	? "android"
+	: webglPlatformText.includes("iphone") ||
+		  webglPlatformText.includes("ipad") ||
+		  webglPlatformText.includes("ipod")
+		? "ios"
+		: webglPlatformText.includes("mac")
+			? "mac"
+			: webglPlatformText.includes("win")
+				? "windows"
+				: webglPlatformText.includes("cros")
+					? "cros"
+					: "linux";
+
+const webglFallbackProfiles = {
+	android: {
+		vendor: "Qualcomm",
+		renderer: "Adreno (TM) 640",
+	},
+	ios: {
+		vendor: "Apple Inc.",
+		renderer: "Apple GPU",
+	},
+	mac: {
+		vendor: "Google Inc. (Intel Inc.)",
+		renderer: "ANGLE (Intel Inc., Intel(R) Iris(TM) Plus Graphics 640 OpenGL Engine, OpenGL 4.1)",
+	},
+	windows: {
+		vendor: "Google Inc. (Intel)",
+		renderer: "ANGLE (Intel, Intel(R) UHD Graphics 620 Direct3D11 vs_5_0 ps_5_0, D3D11)",
+	},
+	cros: {
+		vendor: "Google Inc. (Intel)",
+		renderer: "ANGLE (Intel, Mesa Intel(R) UHD Graphics 620 (KBL GT2), OpenGL 4.6)",
+	},
+	linux: {
+		vendor: "Google Inc. (Intel)",
+		renderer: "ANGLE (Intel, Mesa Intel(R) UHD Graphics 620 (KBL GT2), OpenGL 4.6)",
+	},
+};
+const webglFallbackProfile = webglFallbackProfiles[webglPlatformKind] || webglFallbackProfiles.linux;
+const webglContextProfiles = new WeakMap();
+const webglIsObjectKey = (value) =>
+	(typeof value === "object" && value !== null) || typeof value === "function";
+
+const webglLooksSoftware = (value) => {
+	const text = String(value || "").toLowerCase();
+	return (
+		text.includes("swiftshader") ||
+		text.includes("llvmpipe") ||
+		text.includes("lavapipe") ||
+		text.includes("software") ||
+		text.includes("mesa offscreen") ||
+		text.includes("google inc. (google)")
+	);
+};
+
+const webglMatchesPlatform = (renderer) => {
+	const text = String(renderer || "").toLowerCase();
+	if (webglPlatformKind === "windows") {
+		return !text.includes("apple") && !text.includes("mesa") && !text.includes("opengl engine");
+	}
+	if (webglPlatformKind === "mac") {
+		return !text.includes("direct3d") && !text.includes("d3d") && !text.includes("mesa");
+	}
+	if (webglPlatformKind === "android") {
+		return (
+			text.includes("adreno") ||
+			text.includes("mali") ||
+			text.includes("powervr") ||
+			text.includes("qualcomm")
+		);
+	}
+	if (webglPlatformKind === "ios") {
+		return text.includes("apple");
+	}
+	return !text.includes("direct3d") && !text.includes("d3d") && !text.includes("apple");
+};
+
+const webglGetContextProfile = (target, thisArg) => {
+	if (!webglIsObjectKey(thisArg)) return webglFallbackProfile;
+	const cached = Reflect_apply(Page_WeakMap_get, webglContextProfiles, [thisArg]);
+	if (cached) return cached;
+
+	let nativeVendor;
+	let nativeRenderer;
+	try {
+		nativeVendor = Reflect_apply(target, thisArg, [0x9245]);
+		nativeRenderer = Reflect_apply(target, thisArg, [0x9246]);
+	} catch {}
+
+	const nativeProfile =
+		typeof nativeVendor === "string" &&
+		typeof nativeRenderer === "string" &&
+		nativeVendor &&
+		nativeRenderer &&
+		!webglLooksSoftware(nativeVendor) &&
+		!webglLooksSoftware(nativeRenderer) &&
+		webglMatchesPlatform(nativeRenderer)
+			? { vendor: nativeVendor, renderer: nativeRenderer }
+			: webglFallbackProfile;
+
+	Reflect_apply(Page_WeakMap_set, webglContextProfiles, [thisArg, nativeProfile]);
+	return nativeProfile;
+};
+
+const webglGetParameterHandler = {
+	apply(target, thisArg, args) {
+		const nativeValue = Reflect_apply(target, thisArg, args);
+		const param = args[0];
+		if (param === 0x1f00 && typeof nativeValue === "string") return "WebKit";
+		if (param === 0x1f01 && typeof nativeValue === "string") return "WebKit WebGL";
+		if ((param === 0x9245 || param === 0x9246) && typeof nativeValue === "string") {
+			const profile = webglGetContextProfile(target, thisArg);
+			return param === 0x9245 ? profile.vendor : profile.renderer;
+		}
+		return nativeValue;
+	},
+};
+
+const webglFloatPrecisionTypes = {
+	0x8df0: true,
+	0x8df1: true,
+	0x8df2: true,
+};
+
+const webglClonePrecisionFormat = (result, values) => {
+	const ownKeys = Reflect_ownKeys(result);
+	let hasRangeMin = false;
+	let hasRangeMax = false;
+	let hasPrecision = false;
+	for (let index = 0; index < ownKeys.length; index += 1) {
+		if (ownKeys[index] === "rangeMin") hasRangeMin = true;
+		if (ownKeys[index] === "rangeMax") hasRangeMax = true;
+		if (ownKeys[index] === "precision") hasPrecision = true;
+	}
+	if (!hasRangeMin || !hasRangeMax || !hasPrecision) return result;
+
+	const clone = Object_create(Object_getPrototypeOf(result));
+	for (let index = 0; index < ownKeys.length; index += 1) {
+		const key = ownKeys[index];
+		const descriptor = Object_getOwnPropertyDescriptor(result, key);
+		if (!descriptor) return result;
+		if (key === "rangeMin" || key === "rangeMax" || key === "precision") {
+			if (!("value" in descriptor)) return result;
+			descriptor.value = values[key];
+		}
+		try {
+			Object_defineProperty(clone, key, descriptor);
+		} catch {
+			return result;
+		}
+	}
+	return clone;
+};
+
+const webglGetShaderPrecisionFormatHandler = {
+	apply(target, thisArg, args) {
+		const result = Reflect_apply(target, thisArg, args);
+		const precisionType = args[1];
+		if (
+			!result ||
+			webglPlatformKind === "android" ||
+			webglPlatformKind === "ios" ||
+			!webglFloatPrecisionTypes[precisionType]
+		) {
+			return result;
+		}
+
+		const rangeMin = result.rangeMin;
+		const rangeMax = result.rangeMax;
+		const precision = result.precision;
+		if (
+			typeof rangeMin !== "number" ||
+			typeof rangeMax !== "number" ||
+			typeof precision !== "number"
+		) {
+			return result;
+		}
+
+		const values = {
+			rangeMin: Math_max(rangeMin, 127),
+			rangeMax: Math_max(rangeMax, 127),
+			precision: Math_max(precision, 23),
+		};
+		if (
+			values.rangeMin === rangeMin &&
+			values.rangeMax === rangeMax &&
+			values.precision === precision
+		) {
+			return result;
+		}
+		return webglClonePrecisionFormat(result, values);
+	},
+};
+
+const webglInstallMethodProxy = (proto, name, handler) => {
+	if (!proto) return;
+	const descriptor = Object_getOwnPropertyDescriptor(proto, name);
+	if (!descriptor || typeof descriptor.value !== "function") return;
+	const proxy = new Window_Proxy(descriptor.value, handler);
+	patchToString(proxy, name);
+	try {
+		Object_defineProperty(proto, name, {
+			value: proxy,
+			writable: descriptor.writable,
+			configurable: descriptor.configurable,
+			enumerable: descriptor.enumerable,
+		});
+	} catch {}
+};
+
+if (window.WebGLRenderingContext) {
+	webglInstallMethodProxy(WebGLRenderingContext.prototype, "getParameter", webglGetParameterHandler);
+	webglInstallMethodProxy(
+		WebGLRenderingContext.prototype,
+		"getShaderPrecisionFormat",
+		webglGetShaderPrecisionFormatHandler,
+	);
+}
+if (window.WebGL2RenderingContext) {
+	webglInstallMethodProxy(WebGL2RenderingContext.prototype, "getParameter", webglGetParameterHandler);
+	webglInstallMethodProxy(
+		WebGL2RenderingContext.prototype,
+		"getShaderPrecisionFormat",
+		webglGetShaderPrecisionFormatHandler,
+	);
+}

package/src/tools/puppeteer/06_stealth_screen.txt

@@ -0,0 +1,260 @@
+;(() => {
+  if (typeof Window_Proxy !== "function" || typeof Reflect_apply !== "function") return;
+
+  const screenObject = window.screen;
+  if (!screenObject) return;
+
+  const isFiniteNumber = (value) =>
+    typeof value === "number" &&
+    value === value &&
+    value !== Infinity &&
+    value !== -Infinity;
+
+  const readValue = (object, prop, fallback) => {
+    try {
+      const value = object[prop];
+      return value === undefined ? fallback : value;
+    } catch {
+      return fallback;
+    }
+  };
+
+  const finiteNumber = (value, fallback) =>
+    isFiniteNumber(value) ? value : fallback;
+
+  const positiveNumber = (value, fallback) =>
+    isFiniteNumber(value) && value > 0 ? value : fallback;
+
+  const integerNumber = (value, fallback) =>
+    isFiniteNumber(value) ? Math_floor(value) : fallback;
+
+  const positiveInteger = (value, fallback) =>
+    isFiniteNumber(value) && value > 0 ? Math_floor(value) : fallback;
+
+  const findDescriptorOwner = (object, prop) => {
+    let owner = object;
+    while (owner) {
+      let descriptor;
+      try {
+        descriptor = Object_getOwnPropertyDescriptor(owner, prop);
+      } catch {
+        return undefined;
+      }
+      if (descriptor) return [owner, descriptor];
+      try {
+        owner = Object_getPrototypeOf(owner);
+      } catch {
+        return undefined;
+      }
+    }
+    return undefined;
+  };
+
+  const patchGetter = (object, prop, getValue) => {
+    const found = findDescriptorOwner(object, prop);
+    if (!found) return false;
+
+    const owner = found[0];
+    const descriptor = found[1];
+    if (descriptor.configurable !== true || typeof descriptor.get !== "function") {
+      return false;
+    }
+
+    const originalGet = descriptor.get;
+    const patchedGet = new Window_Proxy(originalGet, {
+      apply(target, thisArg, args) {
+        const nativeValue = Reflect_apply(target, thisArg, args);
+        return getValue(nativeValue, thisArg);
+      },
+    });
+    patchToString(patchedGet, "get " + prop);
+    try {
+      Object_defineProperty(owner, prop, {
+        configurable: descriptor.configurable,
+        enumerable: descriptor.enumerable,
+        get: patchedGet,
+        set: descriptor.set,
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  const patchStableNumber = (object, prop, value) => {
+    const current = readValue(object, prop, undefined);
+    if (current === value) return;
+    patchGetter(object, prop, () => value);
+  };
+
+  const initialInnerWidth = positiveInteger(readValue(window, "innerWidth", 0), 0);
+  const initialInnerHeight = positiveInteger(readValue(window, "innerHeight", 0), 0);
+  const initialOuterWidth = positiveInteger(
+    readValue(window, "outerWidth", Math_max(initialInnerWidth, 1)),
+    Math_max(initialInnerWidth, 1),
+  );
+  const initialOuterHeight = positiveInteger(
+    readValue(window, "outerHeight", Math_max(initialInnerHeight, 1)),
+    Math_max(initialInnerHeight, 1),
+  );
+  // Real Chrome reserves vertical space for the tab strip + URL bar, so
+  // outerHeight is always taller than innerHeight (~88px on a stock window).
+  // Headless reports outerHeight === innerHeight, which is a well-known tell, so
+  // synthesize a realistic chrome height when the window has no visible chrome.
+  const browserChromeHeight = 88;
+  const targetOuterHeight =
+    initialOuterHeight > initialInnerHeight
+      ? initialOuterHeight
+      : initialInnerHeight + browserChromeHeight;
+  const requiredWidth = Math_max(initialInnerWidth, initialOuterWidth, 1);
+  const requiredHeight = Math_max(initialInnerHeight, initialOuterHeight, targetOuterHeight, 1);
+
+  const screenWidth = Math_max(
+    positiveInteger(readValue(screenObject, "width", requiredWidth), requiredWidth),
+    requiredWidth,
+  );
+  const screenHeight = Math_max(
+    positiveInteger(readValue(screenObject, "height", requiredHeight), requiredHeight),
+    requiredHeight,
+  );
+
+  let screenAvailWidth = positiveInteger(
+    readValue(screenObject, "availWidth", screenWidth),
+    screenWidth,
+  );
+  if (screenAvailWidth < requiredWidth || screenAvailWidth > screenWidth) {
+    screenAvailWidth = screenWidth;
+  }
+
+  let screenAvailHeight = positiveInteger(
+    readValue(screenObject, "availHeight", screenHeight),
+    screenHeight,
+  );
+  if (screenAvailHeight < requiredHeight || screenAvailHeight > screenHeight) {
+    screenAvailHeight = screenHeight;
+  }
+
+  const screenAvailLeft = integerNumber(readValue(screenObject, "availLeft", 0), 0);
+  const screenAvailTop = integerNumber(readValue(screenObject, "availTop", 0), 0);
+  const screenColorDepth = positiveInteger(readValue(screenObject, "colorDepth", 24), 24);
+  const screenPixelDepth = positiveInteger(
+    readValue(screenObject, "pixelDepth", screenColorDepth),
+    screenColorDepth,
+  );
+
+  for (const entry of [
+    ["width", screenWidth],
+    ["height", screenHeight],
+    ["availWidth", screenAvailWidth],
+    ["availHeight", screenAvailHeight],
+    ["availLeft", screenAvailLeft],
+    ["availTop", screenAvailTop],
+    ["colorDepth", screenColorDepth],
+    ["pixelDepth", screenPixelDepth],
+  ]) {
+    patchStableNumber(screenObject, entry[0], entry[1]);
+  }
+
+  const outerWidthNeedsPatch =
+    !isFiniteNumber(readValue(window, "outerWidth", undefined)) ||
+    readValue(window, "outerWidth", 0) <= 0 ||
+    Math_floor(readValue(window, "outerWidth", 0)) < initialInnerWidth;
+  if (outerWidthNeedsPatch) {
+    patchGetter(window, "outerWidth", (nativeValue) =>
+      Math_max(
+        positiveInteger(nativeValue, initialOuterWidth),
+        positiveInteger(readValue(window, "innerWidth", requiredWidth), requiredWidth),
+      ),
+    );
+  }
+
+  const outerHeightNeedsPatch =
+    !isFiniteNumber(readValue(window, "outerHeight", undefined)) ||
+    readValue(window, "outerHeight", 0) <= 0 ||
+    Math_floor(readValue(window, "outerHeight", 0)) <= initialInnerHeight;
+  if (outerHeightNeedsPatch) {
+    patchGetter(window, "outerHeight", (nativeValue) =>
+      Math_max(
+        positiveInteger(nativeValue, initialOuterHeight),
+        positiveInteger(readValue(window, "innerHeight", requiredHeight), requiredHeight) +
+          browserChromeHeight,
+      ),
+    );
+  }
+
+  const initialDevicePixelRatio = positiveNumber(
+    readValue(window, "devicePixelRatio", 1),
+    1,
+  );
+  if (readValue(window, "devicePixelRatio", undefined) !== initialDevicePixelRatio) {
+    patchGetter(window, "devicePixelRatio", () => initialDevicePixelRatio);
+  }
+
+  const visualViewportObject = readValue(window, "visualViewport", null);
+  if (visualViewportObject) {
+    const initialScale = positiveNumber(readValue(visualViewportObject, "scale", 1), 1);
+    if (readValue(visualViewportObject, "scale", undefined) !== initialScale) {
+      patchGetter(visualViewportObject, "scale", (nativeValue) =>
+        positiveNumber(nativeValue, initialScale),
+      );
+    }
+
+    const getViewportScale = () =>
+      positiveNumber(readValue(visualViewportObject, "scale", initialScale), initialScale);
+
+    const getViewportWidthFallback = () =>
+      positiveNumber(readValue(window, "innerWidth", requiredWidth), requiredWidth) /
+      getViewportScale();
+
+    const getViewportHeightFallback = () =>
+      positiveNumber(readValue(window, "innerHeight", requiredHeight), requiredHeight) /
+      getViewportScale();
+
+    if (positiveNumber(readValue(visualViewportObject, "width", 0), 0) <= 0) {
+      patchGetter(visualViewportObject, "width", (nativeValue) =>
+        positiveNumber(nativeValue, getViewportWidthFallback()),
+      );
+    }
+
+    if (positiveNumber(readValue(visualViewportObject, "height", 0), 0) <= 0) {
+      patchGetter(visualViewportObject, "height", (nativeValue) =>
+        positiveNumber(nativeValue, getViewportHeightFallback()),
+      );
+    }
+
+    const getViewportOffsetLeft = () =>
+      finiteNumber(readValue(visualViewportObject, "offsetLeft", 0), 0);
+    const getViewportOffsetTop = () =>
+      finiteNumber(readValue(visualViewportObject, "offsetTop", 0), 0);
+
+    if (!isFiniteNumber(readValue(visualViewportObject, "offsetLeft", undefined))) {
+      patchGetter(visualViewportObject, "offsetLeft", (nativeValue) =>
+        finiteNumber(nativeValue, 0),
+      );
+    }
+
+    if (!isFiniteNumber(readValue(visualViewportObject, "offsetTop", undefined))) {
+      patchGetter(visualViewportObject, "offsetTop", (nativeValue) =>
+        finiteNumber(nativeValue, 0),
+      );
+    }
+
+    if (!isFiniteNumber(readValue(visualViewportObject, "pageLeft", undefined))) {
+      patchGetter(visualViewportObject, "pageLeft", (nativeValue) =>
+        finiteNumber(
+          nativeValue,
+          finiteNumber(readValue(window, "scrollX", 0), 0) + getViewportOffsetLeft(),
+        ),
+      );
+    }
+
+    if (!isFiniteNumber(readValue(visualViewportObject, "pageTop", undefined))) {
+      patchGetter(visualViewportObject, "pageTop", (nativeValue) =>
+        finiteNumber(
+          nativeValue,
+          finiteNumber(readValue(window, "scrollY", 0), 0) + getViewportOffsetTop(),
+        ),
+      );
+    }
+  }
+})();