roxxie-proxy-u-prod 0.1.0

package/source/packages/scramjet/packages/core/src/client/dom/attr.ts

@@ -0,0 +1,94 @@
+import { ScramjetClient } from "@client/index";
+import {
+	Number,
+	Object_keys,
+	Reflect_apply,
+	Reflect_get,
+	Reflect_has,
+	Reflect_ownKeys,
+} from "@/shared/snapshot";
+
+export default function (client: ScramjetClient) {
+	client.Trap("Element.prototype.attributes", {
+		get(ctx) {
+			const map = ctx.get() as NamedNodeMap;
+			const proxy = new Proxy(map, {
+				get(target, prop, _receiver) {
+					const value = Reflect_get(target, prop);
+
+					if (prop === "length") {
+						return Object_keys(proxy).length;
+					}
+
+					if (prop === "getNamedItem") {
+						return (name: string) => proxy[name];
+					}
+					if (prop === "getNamedItemNS") {
+						return (namespace: string, name: string) =>
+							proxy[`${namespace}:${name}`];
+					}
+
+					if (prop in NamedNodeMap.prototype && typeof value === "function") {
+						return new Proxy(value, {
+							apply(target, that, args) {
+								if (that === proxy) {
+									return Reflect_apply(target, map, args);
+								}
+
+								return Reflect_apply(target, that, args);
+							},
+						});
+					}
+
+					if (
+						(typeof prop === "string" || typeof prop === "number") &&
+						!isNaN(Number(prop))
+					) {
+						const position = Object_keys(proxy)[prop];
+
+						return map[position];
+					}
+
+					if (!this.has(target, prop)) return undefined;
+
+					return value;
+				},
+				ownKeys(target) {
+					const keys = Reflect_ownKeys(target);
+
+					return keys.filter((key) => this.has(target, key));
+				},
+				has(target, prop) {
+					if (typeof prop === "symbol") return Reflect_has(target, prop);
+					if (prop.startsWith("scramjet-attr-")) return false;
+					if (map[prop]?.name?.startsWith("scramjet-attr-")) return false;
+
+					return Reflect_has(target, prop);
+				},
+			});
+
+			return proxy;
+		},
+	});
+
+	client.Trap(["Attr.prototype.value", "Attr.prototype.nodeValue"], {
+		get(ctx) {
+			// eslint-disable-next-line scramjet-core/no-poisoned-ctx-value
+			if (ctx.this?.ownerElement) {
+				// eslint-disable-next-line scramjet-core/no-poisoned-ctx-value
+				return ctx.this.ownerElement.getAttribute(ctx.this.name);
+			}
+
+			return ctx.get();
+		},
+		set(ctx, value) {
+			// eslint-disable-next-line scramjet-core/no-poisoned-ctx-value
+			if (ctx.this?.ownerElement) {
+				// eslint-disable-next-line scramjet-core/no-poisoned-ctx-value
+				return ctx.this.ownerElement.setAttribute(ctx.this.name, value);
+			}
+
+			return ctx.set(value);
+		},
+	});
+}

package/source/packages/scramjet/packages/core/src/client/dom/beacon.ts

@@ -0,0 +1,11 @@
+import { ScramjetClient } from "@client/index";
+import { String } from "@/shared/snapshot";
+
+export default function (client: ScramjetClient, _self: Self) {
+	client.Proxy("Navigator.prototype.sendBeacon", {
+		apply(ctx) {
+			const url = String(ctx.args[0]);
+			ctx.args[0] = client.rewriteUrl(url);
+		},
+	});
+}

package/source/packages/scramjet/packages/core/src/client/dom/cookie.ts

@@ -0,0 +1,21 @@
+import { ScramjetClient } from "@client/index";
+
+export default function (client: ScramjetClient, self: Self) {
+	client.Trap("Document.prototype.cookie", {
+		get() {
+			return client.context.cookieJar.getCookies(client.url, true);
+		},
+		set(ctx, value: string) {
+			client.context.cookieJar.setCookies(value, client.url);
+			client.init.sendSetCookie([
+				{
+					url: client.url,
+					cookie: value,
+				},
+			]);
+		},
+	});
+
+	// @ts-ignore
+	delete self.cookieStore;
+}

package/source/packages/scramjet/packages/core/src/client/dom/css.ts

@@ -0,0 +1,106 @@
+import { rewriteCss, unrewriteCss } from "@rewriters/css";
+import { ScramjetClient } from "@client/index";
+import { Reflect_apply, Reflect_get, Reflect_set } from "@/shared/snapshot";
+
+export default function (client: ScramjetClient) {
+	client.Proxy("CSSStyleDeclaration.prototype.setProperty", {
+		apply(ctx) {
+			if (!ctx.args[1]) return;
+			ctx.args[1] = rewriteCss(ctx.args[1], client.context, client.meta);
+		},
+	});
+
+	client.Proxy("CSSStyleDeclaration.prototype.getPropertyValue", {
+		apply(ctx) {
+			const v = ctx.call();
+			if (!v) return v;
+			ctx.return(unrewriteCss(v, client.context));
+		},
+	});
+
+	client.Trap("CSSStyleDeclaration.prototype.cssText", {
+		set(ctx, value: string) {
+			ctx.set(rewriteCss(value, client.context, client.meta));
+		},
+		get(ctx) {
+			return unrewriteCss(ctx.get(), client.context);
+		},
+	});
+
+	client.Proxy("CSSStyleSheet.prototype.insertRule", {
+		apply(ctx) {
+			ctx.args[0] = rewriteCss(ctx.args[0], client.context, client.meta);
+		},
+	});
+
+	client.Proxy("CSSStyleSheet.prototype.replace", {
+		apply(ctx) {
+			ctx.args[0] = rewriteCss(ctx.args[0], client.context, client.meta);
+		},
+	});
+
+	client.Proxy("CSSStyleSheet.prototype.replaceSync", {
+		apply(ctx) {
+			ctx.args[0] = rewriteCss(ctx.args[0], client.context, client.meta);
+		},
+	});
+
+	client.Trap("CSSRule.prototype.cssText", {
+		set(ctx, value: string) {
+			ctx.set(rewriteCss(value, client.context, client.meta));
+		},
+		get(ctx) {
+			return unrewriteCss(ctx.get(), client.context);
+		},
+	});
+
+	client.Proxy("CSSStyleValue.parse", {
+		apply(ctx) {
+			if (!ctx.args[1]) return;
+			ctx.args[1] = rewriteCss(ctx.args[1], client.context, client.meta);
+		},
+	});
+
+	client.Trap("HTMLElement.prototype.style", {
+		get(ctx) {
+			// unfortunate and dumb hack. we have to trap every property of this
+			// since the prototype chain is fucked
+
+			const style = ctx.get() as CSSStyleDeclaration;
+
+			return new Proxy(style, {
+				get(target, prop) {
+					const value = Reflect_get(target, prop);
+
+					if (typeof value === "function") {
+						return new Proxy(value, {
+							apply(target, that, args) {
+								return Reflect_apply(target, style, args);
+							},
+						});
+					}
+
+					if (prop in CSSStyleDeclaration.prototype) return value;
+					if (!value) return value;
+
+					return unrewriteCss(value, client.context);
+				},
+				set(target, prop, value) {
+					if (prop == "cssText" || value == "" || typeof value !== "string") {
+						return Reflect_set(target, prop, value);
+					}
+
+					return Reflect_set(
+						target,
+						prop,
+						rewriteCss(value, client.context, client.meta)
+					);
+				},
+			});
+		},
+		set(ctx, value: string) {
+			// this will actually run the trap for cssText. don't rewrite it here
+			ctx.set(value);
+		},
+	});
+}

package/source/packages/scramjet/packages/core/src/client/dom/document.ts

@@ -0,0 +1,140 @@
+import { IncrementalHtmlRewriter, rewriteHtml } from "@rewriters/html";
+import { ScramjetClient } from "@client/index";
+import { String, _URL } from "@/shared/snapshot";
+import { createReferrerString } from "@/fetch/util";
+
+export default function (client: ScramjetClient, _self: Self) {
+	function resetDocumentWriter(document: Document) {
+		client.box.writeRewriters.delete(document);
+	}
+
+	function getDocumentWriter(document: Document) {
+		let writer = client.box.writeRewriters.get(document);
+		if (!writer) {
+			writer = new IncrementalHtmlRewriter(client.context, client.meta, {
+				loadScripts: false,
+				inline: true,
+				source: client.url.href,
+				apisource: "Document.prototype.write",
+			});
+			client.box.writeRewriters.set(document, writer);
+		}
+
+		return writer;
+	}
+
+	client.Proxy("Document.prototype.open", {
+		apply(ctx) {
+			resetDocumentWriter(ctx.this);
+		},
+	});
+
+	client.Proxy("Document.prototype.write", {
+		apply(ctx) {
+			const writer = getDocumentWriter(ctx.this);
+			ctx.return(
+				client.natives.call(
+					"Document.prototype.write",
+					ctx.this,
+					writer.write(ctx.args.join(""))
+				)
+			);
+		},
+	});
+
+	client.Proxy("Document.prototype.writeln", {
+		apply(ctx) {
+			const writer = getDocumentWriter(ctx.this);
+			ctx.return(
+				client.natives.call(
+					"Document.prototype.write",
+					ctx.this,
+					writer.write(ctx.args.join("") + "\n")
+				)
+			);
+		},
+	});
+
+	client.Proxy("Document.prototype.close", {
+		apply(ctx) {
+			const writer = client.box.writeRewriters.get(ctx.this);
+			if (!writer) {
+				return;
+			}
+
+			try {
+				const remaining = writer.end();
+				if (remaining) {
+					client.natives.call("Document.prototype.write", ctx.this, remaining);
+				}
+			} finally {
+				resetDocumentWriter(ctx.this);
+			}
+		},
+	});
+
+	client.Proxy("Document.prototype.parseHTMLUnsafe", {
+		apply(ctx) {
+			const html = String(ctx.args[0]);
+			ctx.args[0] = rewriteHtml(html, client.context, client.meta, {
+				loadScripts: false,
+				inline: true,
+				source: client.url.href,
+				apisource: "Document.prototype.parseHTMLUnsafe",
+			});
+		},
+	});
+
+	client.Trap("Document.prototype.domain", {
+		get() {
+			return client.url.hostname;
+		},
+		set() {
+			return false;
+		},
+	});
+
+	client.Trap("Document.prototype.documentURI", {
+		get() {
+			return client.url.href;
+		},
+		set() {
+			return false;
+		},
+	});
+
+	client.Trap("Document.prototype.URL", {
+		get() {
+			return client.url.href;
+		},
+		set() {
+			return false;
+		},
+	});
+
+	client.Trap("Document.prototype.referrer", {
+		get() {
+			if (!client.history) return "";
+			if (client.history.length < 2) return "";
+			const lastState = client.history[client.history.length - 2];
+			const referrerURL = new _URL(lastState.url);
+			return createReferrerString(
+				referrerURL,
+				client.url,
+				lastState.refererPolicy
+			);
+		},
+	});
+
+	client.Proxy(
+		["Document.prototype.querySelector", "Document.prototype.querySelectorAll"],
+		{
+			apply(ctx) {
+				ctx.args[0] = String(ctx.args[0]).replace(
+					/((?:^|\s)\b\w+\[(?:src|href|data-href))[\^]?(=['"]?(?:https?[:])?\/\/)/,
+					"$1*$2"
+				);
+			},
+		}
+	);
+}