oma-coding-agent 1.1.4

package/src/tools/plan-mode-guard.ts

@@ -0,0 +1,142 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { HL_FILE_HASH_LENGTH, HL_FILE_HASH_SEP, HL_FILE_PREFIX, HL_FILE_SUFFIX } from "@oh-my-pi/hashline";
+import { resolveLocalRoot, resolveLocalUrlToPath, resolveVaultUrlToPath } from "../internal-urls";
+import type { ToolSession } from ".";
+import { normalizeLocalScheme, resolveToCwd } from "./path-utils";
+import { ToolError } from "./tool-errors";
+
+const VAULT_SCHEME_PREFIX = "vault:";
+const LOCAL_SCHEME_PREFIX = "local:";
+const HL_TRAILING_TAG_RE = new RegExp(`${HL_FILE_HASH_SEP}[0-9A-Fa-f]{${HL_FILE_HASH_LENGTH}}$`);
+
+/** Resolve the absolute path of the session's `local://` artifact sandbox.
+ *  Returns `null` when the session has no artifact wiring (e.g. tests). */
+function localSandboxRoot(session: ToolSession): string | null {
+	try {
+		return path.resolve(
+			resolveLocalRoot({
+				getArtifactsDir: session.getArtifactsDir,
+				getSessionId: session.getSessionId,
+			}),
+		);
+	} catch {
+		return null;
+	}
+}
+
+/** True when `absolutePath` resolves inside `root` (== root or under it). */
+function isWithinRoot(absolutePath: string, root: string): boolean {
+	if (absolutePath === root) return true;
+	const sep = `${root}${path.sep}`;
+	return absolutePath.startsWith(sep);
+}
+
+/** Strip the hashline `[path#TAG]` wrapper from a write/edit target so the inner
+ *  filesystem path drives both authorization and resolution. Only unwraps inputs
+ *  that match the strict hashline header shape (`[path]` or `[path#XXXX]` with a
+ *  4-hex tag); anything else returns the original string so the downstream
+ *  resolver surfaces the real error. Exported for callers (e.g. `write`) that
+ *  make scheme/bridge-routing decisions before {@link resolvePlanPath} runs. */
+export function unwrapHashlineHeaderPath(targetPath: string): string {
+	const trimmed = targetPath.trimEnd();
+	if (
+		trimmed.length < HL_FILE_PREFIX.length + HL_FILE_SUFFIX.length ||
+		trimmed[0] !== HL_FILE_PREFIX ||
+		trimmed[trimmed.length - 1] !== HL_FILE_SUFFIX
+	) {
+		return targetPath;
+	}
+	const inner = trimmed.slice(HL_FILE_PREFIX.length, trimmed.length - HL_FILE_SUFFIX.length);
+	const tagMatch = HL_TRAILING_TAG_RE.exec(inner);
+	const pathPart = tagMatch ? inner.slice(0, tagMatch.index) : inner;
+	// A valid header is exactly `PATH` or `PATH#XXXX`; reject any other shape
+	// (selectors, non-hex tags, embedded `#`) so we never silently rewrite a
+	// path the model did not author.
+	if (pathPart.length === 0 || pathPart.includes(HL_FILE_HASH_SEP)) return targetPath;
+	return pathPart;
+}
+
+/** True when `targetPath` resolves into the session-local artifact sandbox.
+ *  Routes through {@link resolvePlanPath} so the guard and the eventual write
+ *  always agree on the absolute target (including bracketed hashline headers,
+ *  `local://` URLs, and bare absolute paths). Files inside the sandbox are not
+ *  part of the working tree, so plan mode treats them as freely writable
+ *  scratch/plan space. */
+function targetsLocalSandbox(session: ToolSession, targetPath: string): boolean {
+	const root = localSandboxRoot(session);
+	if (!root) return false;
+	let resolved: string;
+	try {
+		resolved = resolvePlanPath(session, targetPath);
+	} catch {
+		return false;
+	}
+	if (!path.isAbsolute(resolved)) return false;
+	const absolute = path.resolve(resolved);
+	if (isWithinRoot(absolute, root)) return true;
+	// Compare realpath-normalized forms so that `/tmp/…` vs `/private/tmp/…`
+	// (macOS) and other symlink-collapsed roots both resolve to the same
+	// sandbox identity.
+	try {
+		const realRoot = fs.realpathSync.native(root);
+		if (isWithinRoot(absolute, realRoot)) return true;
+		const realParent = fs.realpathSync.native(path.dirname(absolute));
+		return isWithinRoot(path.join(realParent, path.basename(absolute)), realRoot);
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Resolve a write/edit target to its absolute filesystem path, honoring the
+ * `local://` and `vault://` schemes. Plain paths resolve against the session cwd.
+ * Bracketed hashline headers (`[path#TAG]`) are unwrapped first so the inner
+ * filesystem path drives resolution — keeping the plan-mode guard and the
+ * eventual write in lockstep.
+ */
+export function resolvePlanPath(session: ToolSession, targetPath: string): string {
+	const unwrapped = unwrapHashlineHeaderPath(targetPath);
+	const normalized = normalizeLocalScheme(unwrapped);
+	if (normalized.startsWith(LOCAL_SCHEME_PREFIX)) {
+		return resolveLocalUrlToPath(normalized, {
+			getArtifactsDir: session.getArtifactsDir,
+			getSessionId: session.getSessionId,
+		});
+	}
+
+	if (normalized.startsWith(VAULT_SCHEME_PREFIX)) {
+		return resolveVaultUrlToPath(normalized);
+	}
+
+	return resolveToCwd(normalized, session.cwd);
+}
+
+/**
+ * Plan mode keeps the working tree read-only while letting the agent draft its
+ * plan. Writes and edits to the `local://` artifact sandbox are allowed (that is
+ * where the plan and any scratch notes live); anything that would touch the
+ * working tree — or rename/delete a file — is rejected.
+ */
+export function enforcePlanModeWrite(
+	session: ToolSession,
+	targetPath: string,
+	options?: { move?: string; op?: "create" | "update" | "delete" },
+): void {
+	const state = session.getPlanModeState?.();
+	if (!state?.enabled) return;
+
+	if (options?.move) {
+		throw new ToolError("Plan mode: renaming files is not allowed.");
+	}
+
+	if (options?.op === "delete") {
+		throw new ToolError("Plan mode: deleting files is not allowed.");
+	}
+
+	if (targetsLocalSandbox(session, targetPath)) return;
+
+	throw new ToolError(
+		"Plan mode: the working tree is read-only. Write your plan to a local://<slug>-plan.md file instead.",
+	);
+}

package/src/tools/puppeteer/00_stealth_tampering.txt

@@ -0,0 +1,63 @@
+// Helper to generate native code string
+const makeNativeString = (name) =>
+  "function " + (name || "") + "() { [native code] }";
+
+// Patch toString for common fingerprinted functions
+const patchedFns = [
+  [window.alert, "alert"],
+  [window.prompt, "prompt"],
+  [window.confirm, "confirm"],
+  [window.fetch, "fetch"],
+  [window.XMLHttpRequest, "XMLHttpRequest"],
+  [window.WebSocket, "WebSocket"],
+  [window.localStorage?.getItem, "getItem"],
+  [window.localStorage?.setItem, "setItem"],
+  [window.navigator.geolocation?.getCurrentPosition, "getCurrentPosition"],
+  [window.navigator.geolocation?.watchPosition, "watchPosition"],
+  [window.CanvasRenderingContext2D?.prototype.getImageData, "getImageData"],
+  [window.HTMLCanvasElement?.prototype.toDataURL, "toDataURL"],
+  [window.HTMLCanvasElement?.prototype.toBlob, "toBlob"],
+];
+
+for (const [fn, name] of patchedFns) {
+  if (typeof fn === "function") {
+    const nativeStr = makeNativeString(name);
+    Object_defineProperty(fn, "toString", {
+      value: function toString() { return nativeStr; },
+      writable: false,
+      configurable: true,
+      enumerable: false,
+    });
+  }
+}
+
+// Patch Object.getOwnPropertyDescriptor to return native-looking descriptors
+Object.getOwnPropertyDescriptor = function (obj, prop) {
+  const descriptor = Object_getOwnPropertyDescriptor.call(this, obj, prop);
+  if (!descriptor) return descriptor;
+
+  // Make patched descriptors look native
+  if (descriptor.get && typeof descriptor.get === "function") {
+    const getStr = makeNativeString("get " + String(prop));
+    Object_defineProperty(descriptor.get, "toString", {
+      value: function toString() { return getStr; },
+      writable: false,
+      configurable: true,
+      enumerable: false,
+    });
+  }
+  if (descriptor.set && typeof descriptor.set === "function") {
+    const setStr = makeNativeString("set " + String(prop));
+    Object_defineProperty(descriptor.set, "toString", {
+      value: function toString() { return setStr; },
+      writable: false,
+      configurable: true,
+      enumerable: false,
+    });
+  }
+
+  return descriptor;
+};
+
+// Cleanup
+document.head.removeChild(iframe);

package/src/tools/puppeteer/01_stealth_activity.txt

@@ -0,0 +1,20 @@
+const scheduleActivity = () => {
+  const delay = 3000 + Math_random() * 4000;
+  Window_setTimeout(() => {
+    Object_defineProperty(document, "hidden", { get: () => false });
+    Object_defineProperty(document, "visibilityState", {
+      get: () => "visible",
+    });
+    Object_defineProperty(document, "webkitVisibilityState", {
+      get: () => "visible",
+    });
+    document.dispatchEvent(new Window_Event("visibilitychange"));
+    if (Math_random() < 0.4) window.dispatchEvent(new Window_Event("focus"));
+    document.hasFocus = () => true;
+    if (Math_random() < 0.3) window.dispatchEvent(new Window_Event("scroll"));
+    if (navigator.wakeLock)
+      navigator.wakeLock.request("screen").catch(() => {});
+    scheduleActivity();
+  }, delay);
+};
+scheduleActivity();

package/src/tools/puppeteer/02_stealth_hairline.txt

@@ -0,0 +1,11 @@
+const elementDescriptor = Object_getOwnPropertyDescriptor(
+  HTMLElement.prototype,
+  "offsetHeight",
+);
+Object_defineProperty(HTMLDivElement.prototype, "offsetHeight", {
+  ...elementDescriptor,
+  get: function () {
+    if (this.id === "modernizr") return 1;
+	    return Reflect_apply(elementDescriptor.get, this, []);
+  },
+});

package/src/tools/puppeteer/03_stealth_botd.txt

@@ -0,0 +1,384 @@
+const makeNativeString = (name) => "function " + (name || "") + "() { [native code] }";
+const patchToString = (fn, name) => {
+	if (typeof fn !== "function") return;
+	Object_defineProperty(fn, "toString", {
+		value: function toString() {
+			return makeNativeString(name);
+		},
+		writable: false,
+		configurable: true,
+		enumerable: false,
+	});
+};
+
+// Ensure navigator.webdriver behaves like real Chrome
+if (navigator.webdriver !== false && navigator.webdriver !== undefined) {
+	const proto = Object_getPrototypeOf(navigator);
+	if (proto && "webdriver" in proto) {
+		delete proto.webdriver;
+	}
+}
+
+// Ensure window.chrome exists and is populated with standard Chrome APIs
+if (!window.chrome) {
+	Object_defineProperty(window, "chrome", {
+		writable: true,
+		enumerable: true,
+		configurable: false,
+		value: {},
+	});
+}
+
+if (window.chrome && !("app" in window.chrome)) {
+	const STATIC_DATA = {
+		isInstalled: false,
+		InstallState: {
+			DISABLED: "disabled",
+			INSTALLED: "installed",
+			NOT_INSTALLED: "not_installed",
+		},
+		RunningState: {
+			CANNOT_RUN: "cannot_run",
+			READY_TO_RUN: "ready_to_run",
+			RUNNING: "running",
+		},
+	};
+
+	const makeError = (fn) => new TypeError(`Error in invocation of app.${fn}()`);
+
+	window.chrome.app = {
+		...STATIC_DATA,
+		get isInstalled() {
+			return false;
+		},
+		getDetails: function getDetails() {
+			if (arguments.length) throw makeError("getDetails");
+			return null;
+		},
+		getIsInstalled: function getIsInstalled() {
+			if (arguments.length) throw makeError("getIsInstalled");
+			return false;
+		},
+		runningState: function runningState() {
+			if (arguments.length) throw makeError("runningState");
+			return "cannot_run";
+		},
+	};
+
+	patchToString(window.chrome.app.getDetails, "getDetails");
+	patchToString(window.chrome.app.getIsInstalled, "getIsInstalled");
+	patchToString(window.chrome.app.runningState, "runningState");
+}
+
+if (window.chrome && !("csi" in window.chrome) && window.performance?.timing) {
+	window.chrome.csi = function csi() {
+		const { timing } = window.performance;
+		return {
+			onloadT: timing.domContentLoadedEventEnd,
+			startE: timing.navigationStart,
+			pageT: Date.now() - timing.navigationStart,
+			tran: 15,
+		};
+	};
+	patchToString(window.chrome.csi, "csi");
+}
+
+if (
+	window.chrome &&
+	!("loadTimes" in window.chrome) &&
+	window.performance?.timing &&
+	window.PerformancePaintTiming
+) {
+	const { performance } = window;
+	const ntEntryFallback = {
+		nextHopProtocol: "h2",
+		type: "other",
+	};
+
+	const protocolInfo = {
+		get connectionInfo() {
+			const ntEntry = performance.getEntriesByType("navigation")[0] || ntEntryFallback;
+			return ntEntry.nextHopProtocol;
+		},
+		get npnNegotiatedProtocol() {
+			const ntEntry = performance.getEntriesByType("navigation")[0] || ntEntryFallback;
+			return ["h2", "hq"].includes(ntEntry.nextHopProtocol) ? ntEntry.nextHopProtocol : "unknown";
+		},
+		get navigationType() {
+			const ntEntry = performance.getEntriesByType("navigation")[0] || ntEntryFallback;
+			return ntEntry.type;
+		},
+		get wasAlternateProtocolAvailable() {
+			return false;
+		},
+		get wasFetchedViaSpdy() {
+			const ntEntry = performance.getEntriesByType("navigation")[0] || ntEntryFallback;
+			return ["h2", "hq"].includes(ntEntry.nextHopProtocol);
+		},
+		get wasNpnNegotiated() {
+			const ntEntry = performance.getEntriesByType("navigation")[0] || ntEntryFallback;
+			return ["h2", "hq"].includes(ntEntry.nextHopProtocol);
+		},
+	};
+
+	const { timing } = window.performance;
+
+	const toFixed = (num, fixed) => {
+		const re = new RegExp("^-?\\d+(?:.\\d{0," + (fixed || -1) + "})?");
+		return num.toString().match(re)[0];
+	};
+
+	const timingInfo = {
+		get firstPaintAfterLoadTime() {
+			return 0;
+		},
+		get requestTime() {
+			return timing.navigationStart / 1000;
+		},
+		get startLoadTime() {
+			return timing.navigationStart / 1000;
+		},
+		get commitLoadTime() {
+			return timing.responseStart / 1000;
+		},
+		get finishDocumentLoadTime() {
+			return timing.domContentLoadedEventEnd / 1000;
+		},
+		get finishLoadTime() {
+			return timing.loadEventEnd / 1000;
+		},
+		get firstPaintTime() {
+			const fpEntry = performance.getEntriesByType("paint")[0] || {
+				startTime: timing.loadEventEnd / 1000,
+			};
+			return toFixed((fpEntry.startTime + performance.timeOrigin) / 1000, 3);
+		},
+	};
+
+	window.chrome.loadTimes = function loadTimes() {
+		return { ...protocolInfo, ...timingInfo };
+	};
+	patchToString(window.chrome.loadTimes, "loadTimes");
+}
+
+const isSecureOrigin = document.location.protocol.startsWith("https");
+if (window.chrome && !("runtime" in window.chrome) && isSecureOrigin) {
+	const STATIC_DATA = {
+		OnInstalledReason: {
+			CHROME_UPDATE: "chrome_update",
+			INSTALL: "install",
+			SHARED_MODULE_UPDATE: "shared_module_update",
+			UPDATE: "update",
+		},
+		OnRestartRequiredReason: {
+			APP_UPDATE: "app_update",
+			OS_UPDATE: "os_update",
+			PERIODIC: "periodic",
+		},
+		PlatformArch: {
+			ARM: "arm",
+			ARM64: "arm64",
+			MIPS: "mips",
+			MIPS64: "mips64",
+			X86_32: "x86-32",
+			X86_64: "x86-64",
+		},
+		PlatformNaclArch: {
+			ARM: "arm",
+			MIPS: "mips",
+			MIPS64: "mips64",
+			X86_32: "x86-32",
+			X86_64: "x86-64",
+		},
+		PlatformOs: {
+			ANDROID: "android",
+			CROS: "cros",
+			LINUX: "linux",
+			MAC: "mac",
+			OPENBSD: "openbsd",
+			WIN: "win",
+		},
+		RequestUpdateCheckStatus: {
+			NO_UPDATE: "no_update",
+			THROTTLED: "throttled",
+			UPDATE_AVAILABLE: "update_available",
+		},
+	};
+
+	const makeCustomRuntimeErrors = (preamble, method, extensionId) => ({
+		NoMatchingSignature: new TypeError(preamble + "No matching signature."),
+		MustSpecifyExtensionID: new TypeError(
+			preamble +
+				`${method} called from a webpage must specify an Extension ID (string) for its first argument.`,
+		),
+		InvalidExtensionID: new TypeError(preamble + `Invalid extension id: '${extensionId}'`),
+	});
+
+	const isValidExtensionId = (value) => value.length === 32 && value.toLowerCase().match(/^[a-p]+$/);
+
+	const sendMessageHandler = {
+		apply(target, _ctx, args) {
+			const [extensionId, options, responseCallback] = args || [];
+			const errorPreamble =
+				"Error in invocation of runtime.sendMessage(optional string extensionId, any message, optional object options, optional function responseCallback): ";
+			const Errors = makeCustomRuntimeErrors(errorPreamble, "chrome.runtime.sendMessage()", extensionId);
+
+			const noArguments = args.length === 0;
+			const tooManyArguments = args.length > 4;
+			const incorrectOptions = options && typeof options !== "object";
+			const incorrectResponseCallback = responseCallback && typeof responseCallback !== "function";
+
+			if (noArguments || tooManyArguments || incorrectOptions || incorrectResponseCallback) {
+				throw Errors.NoMatchingSignature;
+			}
+
+			if (args.length < 2) {
+				throw Errors.MustSpecifyExtensionID;
+			}
+
+			if (typeof extensionId !== "string") {
+				throw Errors.NoMatchingSignature;
+			}
+
+			if (!isValidExtensionId(extensionId)) {
+				throw Errors.InvalidExtensionID;
+			}
+
+			return undefined;
+		},
+	};
+
+	const connectHandler = {
+		apply(target, _ctx, args) {
+			const [extensionId, connectInfo] = args || [];
+			const errorPreamble =
+				"Error in invocation of runtime.connect(optional string extensionId, optional object connectInfo): ";
+			const Errors = makeCustomRuntimeErrors(errorPreamble, "chrome.runtime.connect()", extensionId);
+
+			const noArguments = args.length === 0;
+			const emptyStringArgument = args.length === 1 && extensionId === "";
+			if (noArguments || emptyStringArgument) {
+				throw Errors.MustSpecifyExtensionID;
+			}
+
+			const tooManyArguments = args.length > 2;
+			const incorrectConnectInfoType = connectInfo && typeof connectInfo !== "object";
+			if (tooManyArguments || incorrectConnectInfoType) {
+				throw Errors.NoMatchingSignature;
+			}
+
+			const extensionIdIsString = typeof extensionId === "string";
+			if (extensionIdIsString && extensionId === "") {
+				throw Errors.MustSpecifyExtensionID;
+			}
+			if (extensionIdIsString && !isValidExtensionId(extensionId)) {
+				throw Errors.InvalidExtensionID;
+			}
+
+			const validateConnectInfo = (info) => {
+				if (args.length > 1) {
+					throw Errors.NoMatchingSignature;
+				}
+				if (Object_keys(info).length === 0) {
+					throw Errors.MustSpecifyExtensionID;
+				}
+				Object_entries(info).forEach(([key, value]) => {
+					const isExpected = ["name", "includeTlsChannelId"].includes(key);
+					if (!isExpected) {
+						throw new TypeError(errorPreamble + `Unexpected property: '${key}'.`);
+					}
+					const mismatch = (propName, expected, found) =>
+						TypeError(
+							errorPreamble +
+								`Error at property '${propName}': Invalid type: expected ${expected}, found ${found}.`,
+						);
+					if (key === "name" && typeof value !== "string") {
+						throw mismatch(key, "string", typeof value);
+					}
+					if (key === "includeTlsChannelId" && typeof value !== "boolean") {
+						throw mismatch(key, "boolean", typeof value);
+					}
+				});
+			};
+
+			if (typeof extensionId === "object") {
+				validateConnectInfo(extensionId);
+				throw Errors.MustSpecifyExtensionID;
+			}
+
+			const makeConnectResponse = () => {
+				const onSomething = () => ({
+					addListener: function addListener() {},
+					dispatch: function dispatch() {},
+					hasListener: function hasListener() {},
+					hasListeners: function hasListeners() {
+						return false;
+					},
+					removeListener: function removeListener() {},
+				});
+
+				return {
+					name: "",
+					sender: undefined,
+					disconnect: function disconnect() {},
+					onDisconnect: onSomething(),
+					onMessage: onSomething(),
+					postMessage: function postMessage() {
+						if (!arguments.length) {
+							throw new TypeError("Insufficient number of arguments.");
+						}
+						throw new Error("Attempting to use a disconnected port object");
+					},
+				};
+			};
+
+			return makeConnectResponse();
+		},
+	};
+
+	window.chrome.runtime = {
+		...STATIC_DATA,
+		get id() {
+			return undefined;
+		},
+		connect: null,
+		sendMessage: null,
+	};
+
+	const sendMessageProxy = new Window_Proxy(function sendMessage() {}, sendMessageHandler);
+	const connectProxy = new Window_Proxy(function connect() {}, connectHandler);
+	patchToString(sendMessageProxy, "sendMessage");
+	patchToString(connectProxy, "connect");
+	window.chrome.runtime.sendMessage = sendMessageProxy;
+	window.chrome.runtime.connect = connectProxy;
+}
+
+// Suppress Permission.query for automation-controlled
+if (navigator.permissions?.query) {
+	if (isSecureOrigin && "Notification" in window) {
+		Object_defineProperty(Notification, "permission", {
+			get: () => "default",
+			configurable: true,
+		});
+	} else if (!isSecureOrigin) {
+		const originalQuery = navigator.permissions.query;
+		navigator.permissions.query = function (parameters) {
+			if (parameters?.name === "notifications") {
+			const status = { state: "denied", onchange: null };
+			if (typeof PermissionStatus !== "undefined") {
+				Object_setPrototypeOf(status, PermissionStatus.prototype);
+			}
+			return Promise_resolve(status);
+			}
+			return originalQuery.call(this, parameters);
+		};
+	}
+}
+
+// Remove CDC_ markers from document
+const documentProps = Object_getOwnPropertyNames(document);
+for (const prop of documentProps) {
+	if (prop.startsWith("cdc_")) {
+		delete document[prop];
+	}
+}

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

@@ -0,0 +1,81 @@
+const addContentWindowProxy = (iframe) => {
+	const contentWindowProxy = {
+		get(target, key) {
+			if (key === "self") return this;
+			if (key === "frameElement") return iframe;
+			if (key === "0") return undefined;
+			return Reflect_get(target, key);
+		},
+	};
+
+	if (!iframe.contentWindow) {
+		const proxy = new Window_Proxy(window, contentWindowProxy);
+		Object_defineProperty(iframe, "contentWindow", {
+			get() {
+				return proxy;
+			},
+			set(newValue) {
+				return newValue;
+			},
+			enumerable: true,
+			configurable: false,
+		});
+	}
+};
+
+const handleIframeCreation = (target, thisArg, args) => {
+	const iframe = Reflect_apply(target, thisArg, args);
+	const originalIframe = iframe;
+	const originalSrcdoc = originalIframe.srcdoc;
+
+	Object_defineProperty(iframe, "srcdoc", {
+		configurable: true,
+		get() {
+			return originalSrcdoc;
+		},
+		set(newValue) {
+			addContentWindowProxy(this);
+			Object_defineProperty(iframe, "srcdoc", {
+				configurable: false,
+				writable: false,
+				value: originalSrcdoc,
+			});
+			originalIframe.srcdoc = newValue;
+		},
+	});
+
+	return iframe;
+};
+
+const addIframeCreationSniffer = () => {
+	const originalCreateElement = document.createElement;
+	const handler = {
+		apply(target, thisArg, args) {
+			const isIframe = args && args.length && `${args[0]}`.toLowerCase() === "iframe";
+			if (!isIframe) {
+				return Reflect_apply(target, thisArg, args);
+			}
+			return handleIframeCreation(target, thisArg, args);
+		},
+		get(target, key) {
+			return Reflect_get(target, key);
+		},
+	};
+
+	const proxied = new Window_Proxy(originalCreateElement, handler);
+	Object_defineProperty(document, "createElement", {
+		value: proxied,
+		writable: true,
+		configurable: true,
+	});
+	Object_defineProperty(document.createElement, "toString", {
+		value: Function_toString.bind(originalCreateElement),
+		writable: false,
+		configurable: true,
+		enumerable: false,
+	});
+};
+
+try {
+	addIframeCreationSniffer();
+} catch {}