offsite 0.0.61 → 0.0.62

package/apps/server/dist/main.mjs

@@ -2,7 +2,7 @@ import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { appendFileSync, chmodSync, closeSync, createReadStream, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, watch, writeFileSync } from "node:fs";
 import http, { createServer } from "node:http";
 import path from "node:path";
-import { createGzip } from "node:zlib";
+import zlib, { createGzip } from "node:zlib";
 import { consola } from "consola";
 import { WebSocketServer } from "ws";
 import { z } from "zod";
@@ -25,9 +25,17 @@ import { integer, real, snakeCase, text } from "drizzle-orm/sqlite-core";
 import sharp from "sharp";
 import { promisify } from "node:util";
 import webPush from "web-push";
-import { createProxyServer } from "http-proxy-3";
-import { OUTGOING_PASSES } from "http-proxy-3/dist/lib/http-proxy/passes/web-outgoing.js";
+import dns from "node:dns";
+import { BlockList, isIP } from "node:net";
+import { CookieJar, getPublicSuffix } from "tough-cookie";
 import { spawn as spawn$1 } from "@lydell/node-pty";
+import { once } from "node:events";
+import https from "node:https";
+import { buffer } from "node:stream/consumers";
+import { pipeline } from "node:stream/promises";
+import { defaultTreeAdapter, html, parse, serialize } from "parse5";
+import { MagicString } from "magic-string";
+import { parseSync } from "oxc-parser";
 // ../core/src/media.ts
 const mediaTypes = /* @__PURE__ */ new Map([
 	[".png", "image/png"],
@@ -2771,6 +2779,7 @@ const pushSubscriptions = snakeCase.table("push_subscriptions", {
 });
 // src/services/files.ts
 const FILE_LIMIT = 2e4;
+const SNIFF_LENGTH = 8e3;
 const OUTPUT_LIMIT$1 = 262144;
 const READ_LIMIT$1 = 1048576;
 const MEDIA_LINK_LIFETIME = 36e5;
@@ -2882,6 +2891,18 @@ function linkProjectDownload(cwd, file) {
 	if (!statSync(full).isFile()) throw new Error(`${file} is not a file`);
 	return addLink(full, "application/octet-stream");
 }
+function setBrowseHeaders(response, contentType) {
+	response.setHeader("content-type", contentType);
+	response.setHeader("cache-control", "no-cache");
+	if (/^(text\/html|image\/svg|application\/xml)/.test(contentType)) response.setHeader("content-security-policy", "sandbox allow-scripts allow-forms allow-popups allow-modals allow-downloads");
+}
+function sniffType(file) {
+	const head = Buffer.alloc(SNIFF_LENGTH);
+	const handle = openSync(file, "r");
+	const read = readSync(handle, head, 0, SNIFF_LENGTH, 0);
+	closeSync(handle);
+	return head.subarray(0, read).includes(0) ? "application/octet-stream" : "text/plain; charset=utf-8";
+}
 function addLink(file, mediaType) {
 	for (const [token, link] of mediaLinks) if (link.expiresAt <= Date.now()) mediaLinks.delete(token);
 	const token = randomBytes(32).toString("base64url");
@@ -5553,6 +5574,114 @@ var Run = class {
 		});
 	}
 };
+// src/lib/proxy/sites.ts
+const sites = /* @__PURE__ */ new Map();
+const siteNames = /* @__PURE__ */ new Map();
+const privateAddresses = new BlockList();
+for (const range of [
+	["0.0.0.0", 8],
+	["10.0.0.0", 8],
+	["100.64.0.0", 10],
+	["127.0.0.0", 8],
+	["169.254.0.0", 16],
+	["172.16.0.0", 12],
+	["192.0.0.0", 24],
+	["192.168.0.0", 16],
+	["198.18.0.0", 15],
+	["224.0.0.0", 4],
+	["240.0.0.0", 4]
+]) privateAddresses.addSubnet(range[0], range[1], "ipv4");
+for (const range of [
+	["::", 128],
+	["::1", 128],
+	["fc00::", 7],
+	["fe80::", 10],
+	["ff00::", 8]
+]) privateAddresses.addSubnet(range[0], range[1], "ipv6");
+function proxiedPath(key, target) {
+	return `/api/proxy/${key}/${target.protocol === "https:" ? "https" : "http"}/${target.host}${target.pathname}${target.search}${target.hash}`;
+}
+function linkRewriter(key, base) {
+	return (value) => {
+		const text = value.trim();
+		if (text === "" || text.startsWith("#")) return value;
+		if (text.startsWith(`/api/proxy/${key}/`)) return text;
+		const target = URL.parse(text, base);
+		if (target === null || target.protocol !== "http:" && target.protocol !== "https:") return value;
+		return proxiedPath(key, target);
+	};
+}
+function findSite(key) {
+	return sites.get(key) ?? null;
+}
+async function openSite(address, fromPage) {
+	const target = new URL(address);
+	if (target.protocol !== "http:" && target.protocol !== "https:") throw new Error(`${address} is not an http or https address`);
+	const local = await isLocalHost(hostOf(target));
+	if (local && fromPage) throw new Error("A website cannot open an address on this machine");
+	const name = local ? `local ${target.hostname}` : `public ${getPublicSuffix(target.hostname) ?? target.hostname}`;
+	const existing = siteNames.get(name);
+	if (existing !== void 0) return proxiedPath(existing.key, target);
+	const site = {
+		key: randomBytes(16).toString("hex"),
+		local,
+		jar: new CookieJar(void 0, {
+			allowSpecialUseDomain: true,
+			rejectPublicSuffixes: !local
+		}),
+		storage: /* @__PURE__ */ new Map()
+	};
+	sites.set(site.key, site);
+	siteNames.set(name, site);
+	return proxiedPath(site.key, target);
+}
+function hostOf(target) {
+	return target.hostname.replace(/^\[|\]$/g, "");
+}
+function checkAddress(site, address, port, ownPort) {
+	if (!isPrivate(address)) return;
+	if (!site.local) throw new Error("Websites cannot reach addresses on this machine");
+	if (port === ownPort) throw new Error("Pages cannot reach Offsite itself");
+}
+function guardedLookup(site, port, ownPort) {
+	return (hostname, options, callback) => {
+		dns.lookup(hostname, {
+			...options,
+			all: true
+		}, (error, addresses) => {
+			if (error !== null) {
+				callback(error, "", 0);
+				return;
+			}
+			try {
+				for (const item of addresses) checkAddress(site, item.address, port, ownPort);
+			} catch (caught) {
+				callback(caught, "", 0);
+				return;
+			}
+			if (options.all === true) {
+				callback(null, addresses);
+				return;
+			}
+			const first = addresses[0];
+			if (first === void 0) {
+				callback(/* @__PURE__ */ new Error(`${hostname} has no address`), "", 0);
+				return;
+			}
+			callback(null, first.address, first.family);
+		});
+	};
+}
+function isPrivate(address) {
+	const family = isIP(address);
+	if (family === 4) return privateAddresses.check(address, "ipv4");
+	if (family === 6) return privateAddresses.check(address, "ipv6");
+	throw new Error(`${address} is not an IP address`);
+}
+async function isLocalHost(hostname) {
+	if (isIP(hostname) !== 0) return isPrivate(hostname);
+	return (await dns.promises.lookup(hostname, { all: true })).some((item) => isPrivate(item.address));
+}
 // src/services/message-search.ts
 const READ_LIMIT = 30;
 const CODEX_READ_LIMIT = 10;
@@ -5687,140 +5816,6 @@ function bestMatch(query, sessionId, messages) {
 	}
 	return best;
 }
-// src/services/proxy.ts
-const proxies = /* @__PURE__ */ new Map();
-const pageScriptPath = "/__offsite/browser.js";
-function pageScript(origin) {
-	return `(() => {
-  if (window.parent === window || window.navigation === undefined) {
-    return
-  }
-  const post = (message) =>
-    window.parent.postMessage({ offsite: 'browser', ...message }, '*')
-  const report = () =>
-    post({
-      event: 'location',
-      url: ${JSON.stringify(origin)} + location.pathname + location.search + location.hash,
-      proxied: location.href,
-      back: navigation.canGoBack,
-      forward: navigation.canGoForward,
-    })
-  addEventListener('pageshow', report)
-  navigation.addEventListener('currententrychange', report)
-  navigation.addEventListener('navigate', (event) => {
-    if (!event.destination.sameDocument && event.downloadRequest === null) {
-      post({ event: 'navigate' })
-    }
-  })
-  addEventListener('message', (event) => {
-    if (event.source !== window.parent || event.data?.offsite !== 'browser') {
-      return
-    }
-    if (event.data.command === 'back') {
-      navigation.back()
-    }
-    if (event.data.command === 'forward') {
-      navigation.forward()
-    }
-    if (event.data.command === 'reload') {
-      location.reload()
-    }
-  })
-})()
-`;
-}
-function proxyPort(origin) {
-	const target = new URL(origin);
-	if (target.protocol !== "http:" && target.protocol !== "https:") throw new Error(`${origin} is not an http or https address`);
-	const existing = proxies.get(target.origin);
-	if (existing !== void 0) return existing;
-	const started = startProxy(target);
-	proxies.set(target.origin, started);
-	started.catch(() => proxies.delete(target.origin));
-	return started;
-}
-function startProxy(target) {
-	const options = {
-		target,
-		changeOrigin: true,
-		ws: true,
-		secure: false,
-		autoRewrite: true,
-		protocolRewrite: "http",
-		cookieDomainRewrite: "",
-		selfHandleResponse: true
-	};
-	const proxy = createProxyServer(options);
-	proxy.on("proxyReq", (outgoing, request) => {
-		rewriteOrigin(target, outgoing, request);
-		if (request.headers.accept?.startsWith("text/html") === true) outgoing.removeHeader("accept-encoding");
-	});
-	proxy.on("proxyReqWs", (outgoing, request) => rewriteOrigin(target, outgoing, request));
-	proxy.on("proxyRes", async (incoming, request, response) => {
-		try {
-			await rewriteRedirect(target, incoming, request);
-		} catch (error) {
-			response.writeHead(502, { "content-type": "text/plain; charset=utf-8" });
-			response.end(`Could not follow the redirect from ${target.origin}: ${error instanceof Error ? error.message : String(error)}`);
-			return;
-		}
-		delete incoming.headers["x-frame-options"];
-		delete incoming.headers["content-security-policy"];
-		if (incoming.headers["set-cookie"] !== void 0) incoming.headers["set-cookie"] = incoming.headers["set-cookie"].map((cookie) => cookie.replace(/;\s*secure/i, "").replace(/;\s*samesite=none/i, ""));
-		const page = request.method === "GET" && request.headers.accept?.startsWith("text/html") === true && incoming.statusCode !== 204 && incoming.statusCode !== 304 && /^text\/html/i.test(incoming.headers["content-type"] ?? "") && incoming.headers["content-encoding"] === void 0;
-		if (page) delete incoming.headers["content-length"];
-		for (const pass of Object.values(OUTGOING_PASSES)) pass(request, response, incoming, options);
-		if (!page) {
-			incoming.pipe(response);
-			return;
-		}
-		const chunks = [];
-		incoming.on("data", (chunk) => chunks.push(chunk));
-		incoming.on("end", () => response.end(Buffer.from(Buffer.concat(chunks).toString("latin1").replace(/^(\xEF\xBB\xBF)?\s*(<!doctype[^>]*>)?/i, `$&<script src="${pageScriptPath}"><\/script>`), "latin1")));
-	});
-	proxy.on("error", (error, _request, response) => {
-		if (!(response instanceof http.ServerResponse)) {
-			response.destroy();
-			return;
-		}
-		if (!response.headersSent) response.writeHead(502, { "content-type": "text/plain; charset=utf-8" });
-		response.end(`Could not reach ${target.origin}: ${error.message}`);
-	});
-	const server = http.createServer((request, response) => {
-		if (request.url === pageScriptPath) {
-			response.writeHead(200, { "content-type": "text/javascript; charset=utf-8" });
-			response.end(pageScript(target.origin));
-			return;
-		}
-		proxy.web(request, response);
-	});
-	server.on("upgrade", (request, socket, head) => proxy.ws(request, socket, head));
-	return new Promise((resolve, reject) => {
-		server.once("error", reject);
-		server.listen(0, args.host, () => {
-			const address = server.address();
-			if (address === null || typeof address === "string") {
-				reject(/* @__PURE__ */ new Error(`the proxy for ${target.origin} has no port`));
-				return;
-			}
-			resolve(address.port);
-		});
-	});
-}
-async function rewriteRedirect(target, incoming, request) {
-	const location = incoming.headers.location;
-	if (location === void 0 || !/^30[1278]$/.test(String(incoming.statusCode))) return;
-	const next = new URL(location, target);
-	if (next.origin === target.origin || next.protocol !== "http:" && next.protocol !== "https:") return;
-	if (request.headers.host === void 0) throw new Error("the redirected request has no host");
-	const proxied = new URL(`http://${request.headers.host}`);
-	proxied.port = String(await proxyPort(next.origin));
-	incoming.headers.location = `${proxied.origin}${next.pathname}${next.search}${next.hash}`;
-}
-function rewriteOrigin(target, outgoing, request) {
-	if (request.headers.origin !== void 0) outgoing.setHeader("origin", target.origin);
-	if (request.headers.referer !== void 0) outgoing.setHeader("referer", request.headers.referer.replace(`http://${request.headers.host}`, target.origin));
-}
 // src/services/runs.ts
 const locks = /* @__PURE__ */ new Map();
 function stopAll() {
@@ -6961,7 +6956,7 @@ function attach(client) {
 		layout: layout(),
 		instance
 	});
-	for (const tab of tabs) forward(connection, tab.id, true, Buffer.concat(terminals.get(tab.id)?.history ?? []));
+	for (const tab of tabs) forward$1(connection, tab.id, true, Buffer.concat(terminals.get(tab.id)?.history ?? []));
 }
 function resize(connection, message) {
 	const terminal = terminals.get(message.id);
@@ -7097,7 +7092,7 @@ function output(id, terminal, data) {
 		terminal.historySize -= terminal.history[0].length;
 		terminal.history.shift();
 	}
-	for (const connection of connections.values()) forward(connection, id, false, data);
+	for (const connection of connections.values()) forward$1(connection, id, false, data);
 	scan(id, terminal, data);
 	if ([...connections.values()].some((connection) => connection.client.socket.bufferedAmount > OUTPUT_LIMIT)) {
 		terminal.pty.pause();
@@ -7202,7 +7197,7 @@ function publish() {
 		tabs
 	});
 }
-function forward(connection, id, replay, data) {
+function forward$1(connection, id, replay, data) {
 	connection.client.socket.send(encodeFrame(replay ? 3 : 2, id, data));
 }
 function send(connection, event) {
@@ -7433,7 +7428,7 @@ const handlers = {
 	"files.download": (params) => linkProjectDownload(projectPath(params.projectId), params.path),
 	"files.upload": (params) => saveUpload(params.name, Buffer.from(params.data, "base64")),
 	"files.browse": () => browseToken,
-	"browser.proxy": (params) => proxyPort(params.origin),
+	"browser.open": (params) => openSite(params.url, params.fromPage),
 	"tasks.output": (params) => taskOutput(params.sessionId, params.path),
 	"git.status": (params) => gitRepos(projectPath(params.projectId)),
 	"git.diff": (params) => projectDiff(projectPath(params.projectId)),
@@ -7537,6 +7532,1155 @@ async function answer(client, text) {
 		});
 	}
 }
+// src/lib/proxy/css.ts
+function rewriteCss(source, rewrite) {
+	return source.replace(/url\(\s*(['"]?)(.*?)\1\s*\)/gi, (_match, quote, value) => `url(${quote}${rewrite(value)}${quote})`).replace(/@import\s+(['"])(.*?)\1/gi, (_match, quote, value) => `@import ${quote}${rewrite(value)}${quote}`);
+}
+// src/lib/proxy/script.ts
+const CACHE_LIMIT = 500;
+const MARKERS = /\b(?:location|top|parent|import)\b/;
+const WINDOWS = /* @__PURE__ */ new Set([
+	"window",
+	"self",
+	"globalThis",
+	"frames"
+]);
+const FUNCTIONS = /* @__PURE__ */ new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+]);
+const PATTERNS = /* @__PURE__ */ new Set([
+	"ObjectPattern",
+	"ArrayPattern",
+	"RestElement",
+	"AssignmentPattern",
+	"Property"
+]);
+const NAMES = /* @__PURE__ */ new Set([
+	"ImportSpecifier",
+	"ImportDefaultSpecifier",
+	"ImportNamespaceSpecifier",
+	"ExportSpecifier",
+	"LabeledStatement",
+	"BreakStatement",
+	"ContinueStatement"
+]);
+const KEYS = /* @__PURE__ */ new Set([
+	"Property",
+	"MethodDefinition",
+	"PropertyDefinition"
+]);
+const cache = /* @__PURE__ */ new Map();
+function rewriteScript(source, rewrite, scope) {
+	if (!MARKERS.test(source)) return source;
+	const id = createHash("sha1").update(scope).update(source).digest("base64");
+	const known = cache.get(id);
+	if (known !== void 0) return known;
+	const rewritten = rewriteSource(source, rewrite);
+	if (cache.size >= CACHE_LIMIT) cache.clear();
+	cache.set(id, rewritten);
+	return rewritten;
+}
+function rewriteHandler(source, rewrite) {
+	const rewritten = rewriteSource(`function handler(event){${source}
+}`, rewrite);
+	return rewritten.slice(24, rewritten.length - 2);
+}
+function rewriteSource(source, rewrite) {
+	const parsed = parseSync("page.js", source, {
+		lang: "js",
+		sourceType: "unambiguous"
+	});
+	if (parsed.errors.some((error) => error.severity === "Error")) return source;
+	const output = new MagicString(source);
+	walk(parsed.program, null, false, {
+		source,
+		output,
+		rewrite
+	});
+	return output.toString();
+}
+function walk(node, parent, binding, context) {
+	visit(node, parent, binding, context);
+	for (const field of Object.keys(node)) {
+		const value = node[field];
+		const position = {
+			node,
+			field,
+			parent
+		};
+		if (Array.isArray(value)) {
+			for (const item of value) if (isNode(item)) walk(item, position, inBinding(node, field, binding), context);
+		} else if (isNode(value)) walk(value, position, inBinding(node, field, binding), context);
+	}
+}
+function visit(node, parent, binding, context) {
+	const output = context.output;
+	if ((node.type === "ImportDeclaration" || node.type === "ExportNamedDeclaration" || node.type === "ExportAllDeclaration") && isNode(node.source)) {
+		const specifier = String(node.source.value);
+		if (specifier.startsWith("/") || /^[a-z][a-z\d+.-]*:/i.test(specifier)) output.overwrite(node.source.start, node.source.end, JSON.stringify(context.rewrite(specifier)));
+		return;
+	}
+	if (node.type === "ImportExpression" && isNode(node.source)) {
+		wrap(output, node.source, "__oi");
+		return;
+	}
+	if (node.type === "AssignmentExpression") {
+		if (node.operator === "=" && isNode(node.left) && isNode(node.right) && isLocationTarget(node.left)) {
+			const current = context.source.slice(node.left.start, node.left.end);
+			output.appendRight(node.right.start, `__ou(${current},`);
+			output.appendLeft(node.right.end, ")");
+		}
+		return;
+	}
+	if (node.type === "Identifier") {
+		visitIdentifier(node, parent, binding, output);
+		return;
+	}
+	if (node.type === "MemberExpression" && !binding) visitMember(node, parent, output);
+}
+function visitIdentifier(node, parent, binding, output) {
+	const name = String(node.name);
+	if (name !== "location" && name !== "top" && name !== "parent") return;
+	const wrapper = name === "location" ? "__ol" : "__ow";
+	if (parent?.node.type === "Property" && parent.field === "value" && parent.node.shorthand === true && !binding) {
+		output.appendRight(node.start, `${name}:${wrapper}(`);
+		output.appendLeft(node.end, ")");
+		return;
+	}
+	if (binding || !isRead(node, parent)) return;
+	wrap(output, node, wrapper);
+}
+function visitMember(node, parent, output) {
+	if (!isNode(node.property) || !isNode(node.object)) return;
+	if (node.computed === true) return;
+	const name = String(node.property.name);
+	if (name === "url" && node.object.type === "MetaProperty" && isRead(node, parent)) {
+		wrap(output, node, "__om");
+		return;
+	}
+	if (name === "location" && isRead(node, parent) && !insideChain(parent)) {
+		wrap(output, node, "__ol");
+		return;
+	}
+	if ((name === "top" || name === "parent") && node.object.type === "Identifier" && WINDOWS.has(String(node.object.name)) && isRead(node, parent) && !insideChain(parent)) wrap(output, node, "__ow");
+}
+function isRead(node, parent) {
+	if (parent === null) return true;
+	const owner = parent.node;
+	const field = parent.field;
+	if (owner.type === "MemberExpression" && field === "property") return owner.computed === true;
+	if (KEYS.has(owner.type) && field === "key") return owner.computed === true;
+	if (NAMES.has(owner.type)) return false;
+	if (owner.type === "CallExpression" && field === "callee") return false;
+	if (owner.type === "UpdateExpression") return false;
+	if (owner.type === "AssignmentExpression" && field === "left") return false;
+	if (owner.type === "UnaryExpression") return owner.operator !== "delete" && owner.operator !== "typeof";
+	return true;
+}
+function inBinding(node, field, binding) {
+	if (node.type === "VariableDeclarator") return field === "id";
+	if (FUNCTIONS.has(node.type)) return field === "params" || field === "id";
+	if (node.type === "ClassExpression" || node.type === "ClassDeclaration") return field === "id";
+	if (node.type === "CatchClause") return field === "param";
+	if (node.type === "ForInStatement" || node.type === "ForOfStatement") return field === "left";
+	if (node.type === "AssignmentExpression") return field === "left";
+	if (node.type === "AssignmentPattern" && field === "right") return false;
+	if (node.type === "Property" && field === "key") return false;
+	return binding && PATTERNS.has(node.type);
+}
+function isLocationTarget(node) {
+	if (node.type === "Identifier") return node.name === "location";
+	return node.type === "MemberExpression" && node.computed !== true && isNode(node.property) && node.property.name === "location";
+}
+function insideChain(parent) {
+	return parent !== null && parent.node.type === "MemberExpression" && parent.field === "object" && hasChain(parent);
+}
+function hasChain(parent) {
+	if (parent === null) return false;
+	if (parent.node.type === "ChainExpression") return true;
+	return hasChain(parent.parent);
+}
+function wrap(output, node, name) {
+	output.appendRight(node.start, `${name}(`);
+	output.appendLeft(node.end, ")");
+}
+function isNode(value) {
+	return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+// src/lib/proxy/html.ts
+const LINKS = /* @__PURE__ */ new Set([
+	"href",
+	"src",
+	"action",
+	"formaction",
+	"poster",
+	"data",
+	"background"
+]);
+const LINK_TAGS = /* @__PURE__ */ new Set([
+	"a",
+	"area",
+	"audio",
+	"base",
+	"body",
+	"button",
+	"embed",
+	"form",
+	"iframe",
+	"img",
+	"input",
+	"link",
+	"object",
+	"script",
+	"source",
+	"td",
+	"track",
+	"video"
+]);
+const REMOVED = /* @__PURE__ */ new Set([
+	"integrity",
+	"crossorigin",
+	"nonce",
+	"ping"
+]);
+const NAVIGATING = /* @__PURE__ */ new Set([
+	"a",
+	"area",
+	"base",
+	"form"
+]);
+const SCRIPT_TYPES = /* @__PURE__ */ new Set([
+	"",
+	"module",
+	"text/javascript",
+	"application/javascript",
+	"text/ecmascript",
+	"application/ecmascript"
+]);
+const META_REMOVED = /* @__PURE__ */ new Set([
+	"content-security-policy",
+	"content-security-policy-report-only",
+	"x-frame-options"
+]);
+function rewriteHtml(source, key, base, script) {
+	const document = parse(source);
+	rewriteChildren(document, {
+		key,
+		base,
+		rewrite: linkRewriter(key, base)
+	});
+	const head = findHead(document);
+	const runtime = defaultTreeAdapter.createElement("script", html.NS.HTML, []);
+	defaultTreeAdapter.insertText(runtime, script);
+	const first = head.childNodes[0];
+	if (first === void 0) defaultTreeAdapter.appendChild(head, runtime);
+	else defaultTreeAdapter.insertBefore(head, runtime, first);
+	return serialize(document);
+}
+function findHead(node) {
+	for (const child of node.childNodes) if ("tagName" in child) {
+		if (child.tagName === "head") return child;
+		if (child.tagName === "html") return findHead(child);
+	}
+	throw new Error("the page has no head");
+}
+function rewriteChildren(node, page) {
+	const remove = [];
+	for (const child of node.childNodes) {
+		if (!("tagName" in child)) continue;
+		if (rewriteElement(child, page)) {
+			remove.push(child);
+			continue;
+		}
+		rewriteChildren(child, page);
+		if ("content" in child) rewriteChildren(child.content, page);
+	}
+	for (const child of remove) defaultTreeAdapter.detachNode(child);
+}
+function rewriteElement(element, page) {
+	const tag = element.tagName;
+	if (tag === "meta") {
+		const equiv = attribute(element, "http-equiv")?.value.toLowerCase();
+		if (equiv !== void 0 && META_REMOVED.has(equiv)) return true;
+		if (attribute(element, "name")?.value.toLowerCase() === "referrer") return true;
+		if (equiv === "refresh") rewriteRefresh(element, page);
+	}
+	if (tag === "base") {
+		const href = attribute(element, "href")?.value;
+		const next = href === void 0 ? null : URL.parse(href, page.base);
+		if (next !== null) {
+			page.base = next;
+			page.rewrite = linkRewriter(page.key, next);
+		}
+	}
+	element.attrs = element.attrs.filter((item) => !REMOVED.has(item.name));
+	if (NAVIGATING.has(tag)) element.attrs = element.attrs.filter((item) => item.name !== "target" || !/^_(top|parent|blank)$/i.test(item.value.trim()));
+	for (const item of element.attrs) if (LINKS.has(item.name) && LINK_TAGS.has(tag)) item.value = page.rewrite(item.value);
+	else if (item.name === "srcset" || item.name === "imagesrcset") item.value = rewriteSrcset(item.value, page.rewrite);
+	else if (item.name === "style") item.value = rewriteCss(item.value, page.rewrite);
+	else if (item.name.startsWith("on")) item.value = rewriteHandler(item.value, page.rewrite);
+	if (tag === "style") rewriteText(element, (text) => rewriteCss(text, page.rewrite));
+	if (tag === "script") rewriteInlineScript(element, page);
+	return false;
+}
+function rewriteInlineScript(element, page) {
+	const type = (attribute(element, "type")?.value ?? "").trim().toLowerCase();
+	if (type === "importmap") {
+		rewriteText(element, (text) => JSON.stringify(rewriteMapLinks(JSON.parse(text), page)));
+		return;
+	}
+	if (SCRIPT_TYPES.has(type)) rewriteText(element, (text) => rewriteScript(text, page.rewrite, `${page.key} ${page.base.origin}`));
+}
+function rewriteMapLinks(value, page) {
+	if (typeof value === "string") return page.rewrite(value);
+	if (typeof value !== "object" || value === null) return value;
+	return Object.fromEntries(Object.entries(value).map((entry) => [entry[0], rewriteMapLinks(entry[1], page)]));
+}
+function rewriteText(element, rewrite) {
+	for (const child of element.childNodes) if ("value" in child) child.value = rewrite(child.value);
+}
+function rewriteRefresh(element, page) {
+	const content = attribute(element, "content");
+	if (content === void 0) return;
+	content.value = content.value.replace(/(url\s*=\s*['"]?)([^'"]+)/i, (_match, label, url) => `${label}${page.rewrite(url)}`);
+}
+function rewriteSrcset(value, rewrite) {
+	return value.split(/,\s+/).map((candidate) => {
+		const parts = candidate.trim().split(/\s+/);
+		const url = parts[0];
+		if (url === void 0 || url === "") return candidate;
+		return [rewrite(url), ...parts.slice(1)].join(" ");
+	}).join(", ");
+}
+function attribute(element, name) {
+	return element.attrs.find((item) => item.name === name);
+}
+// src/lib/proxy/page-script.ts
+function pageScript(config) {
+	const json = JSON.stringify(config).replaceAll("<", "\\u003c");
+	return `(${PAGE_SCRIPT})(${json})`;
+}
+const PAGE_SCRIPT = String.raw`function (config) {
+  if (self.__ol) return
+  const inWindow = typeof document !== 'undefined'
+  const realLocation = self.location
+  const origin = config.origin ?? realLocation.origin
+  const prefix = '/api/proxy/' + config.key + '/'
+  const realFetch = self.fetch.bind(self)
+  const native = { get: inWindow && Element.prototype.getAttribute, set: inWindow && Element.prototype.setAttribute }
+  const realPost = inWindow && window.postMessage.bind(window)
+  const panel = inWindow && window.parent !== window && window.parent === window.top ? window.parent : null
+  const skipped = /^\s*(data|blob|javascript|about|mailto|tel|sms|file):/i
+  const schemes = { 'http:': 'http', 'https:': 'https', 'ws:': 'http', 'wss:': 'https' }
+
+  function hide(name, value) {
+    Object.defineProperty(self, name, { value, enumerable: false, configurable: true, writable: true })
+  }
+  function decode(value) {
+    const text = String(value)
+    const index = text.indexOf(prefix)
+    if (index === -1 || (index !== 0 && !text.startsWith(origin))) return null
+    const rest = text.slice(index + prefix.length)
+    const slash = rest.indexOf('/')
+    const scheme = rest.slice(0, slash)
+    if (scheme !== 'http' && scheme !== 'https') return null
+    return scheme + '://' + rest.slice(slash + 1)
+  }
+  function original(value) {
+    return decode(value) ?? value
+  }
+  function pageUrl() {
+    return decode(realLocation.href) ?? config.url
+  }
+  function baseUrl() {
+    const base = inWindow && document.querySelector('base[href]')
+    return base ? (decode(native.get.call(base, 'href')) ?? pageUrl()) : pageUrl()
+  }
+  function encode(value, base) {
+    const text = String(value)
+    if (text === '' || text.startsWith('#') || skipped.test(text) || decode(text) !== null) return text
+    const url = URL.parse(text, base ?? baseUrl())
+    if (url === null || schemes[url.protocol] === undefined) return text
+    return prefix + schemes[url.protocol] + '/' + url.host + url.pathname + url.search + url.hash
+  }
+  function absolute(value) {
+    const encoded = encode(value)
+    return encoded.startsWith('/') ? origin + encoded : encoded
+  }
+  function encodeSet(value) {
+    return String(value).split(/,\s+/).map(function (item) {
+      const parts = item.trim().split(/\s+/)
+      parts[0] = encode(parts[0])
+      return parts.join(' ')
+    }).join(', ')
+  }
+  function socketUrl(value) {
+    return (origin.startsWith('https') ? 'wss://' : 'ws://') + origin.replace(/^https?:\/\//, '') + encode(value)
+  }
+  function postPanel(message) {
+    if (panel) panel.postMessage(Object.assign({ offsite: 'browser' }, message), '*')
+  }
+  function navigate(value, replace) {
+    const next = URL.parse(String(value), baseUrl())
+    if (next === null) return
+    const web = next.protocol === 'http:' || next.protocol === 'https:'
+    if (panel && web && next.host !== new URL(pageUrl()).host) {
+      postPanel({ event: 'open', url: next.href })
+      return
+    }
+    if (replace) realLocation.replace(encode(next.href))
+    else realLocation.assign(encode(next.href))
+  }
+
+  const fakeLocation = {}
+  for (const part of ['href', 'protocol', 'host', 'hostname', 'port', 'pathname', 'search', 'hash', 'origin']) {
+    Object.defineProperty(fakeLocation, part, {
+      enumerable: true,
+      get() {
+        return new URL(pageUrl())[part]
+      },
+      set(value) {
+        if (part === 'origin') return
+        if (part === 'hash') {
+          realLocation.hash = value
+          return
+        }
+        if (part === 'href') {
+          navigate(value)
+          return
+        }
+        const next = new URL(pageUrl())
+        next[part] = value
+        navigate(next.href)
+      },
+    })
+  }
+  fakeLocation.assign = function (value) { navigate(value) }
+  fakeLocation.replace = function (value) { navigate(value, true) }
+  fakeLocation.reload = function () { realLocation.reload() }
+  fakeLocation.toString = function () { return pageUrl() }
+  fakeLocation.valueOf = function () { return fakeLocation }
+  fakeLocation[Symbol.toPrimitive] = function () { return pageUrl() }
+  fakeLocation.ancestorOrigins = []
+
+  function pageTop() {
+    if (!inWindow || window.parent === window) return self
+    let current = window
+    while (current.parent !== window.top) current = current.parent
+    return current
+  }
+  hide('__ol', function (value) { return value === realLocation ? fakeLocation : value })
+  hide('__ow', function (value) {
+    if (!inWindow) return value
+    if (value === window.top) return pageTop()
+    return value
+  })
+  hide('__ou', function (current, value) {
+    if (current === realLocation || (inWindow && current === window.top.location)) return encode(value)
+    return value
+  })
+  hide('__oi', function (value) {
+    const text = String(value)
+    return /^(\/|https?:)/.test(text) ? absolute(text) : text
+  })
+  hide('__om', original)
+
+  function patch(owner, name, wrap) {
+    const descriptor = Object.getOwnPropertyDescriptor(owner, name)
+    if (descriptor === undefined) return
+    Object.defineProperty(owner, name, Object.assign({}, descriptor, wrap(descriptor)))
+  }
+  function getter(owner, name, read) {
+    patch(owner, name, function (descriptor) {
+      return { get() { return read(descriptor.get.call(this), this) } }
+    })
+  }
+
+  self.fetch = function (input, init) {
+    const options = Object.assign({}, init, { credentials: 'omit' })
+    if (options.mode === 'same-origin') options.mode = 'cors'
+    if (input instanceof RealRequest) return realFetch(input, options)
+    return realFetch(absolute(input), options)
+  }
+  const RealRequest = self.Request
+  self.Request = class Request extends RealRequest {
+    constructor(input, init) {
+      super(input instanceof RealRequest ? input : absolute(input), init)
+    }
+  }
+  getter(RealRequest.prototype, 'url', original)
+  getter(Response.prototype, 'url', original)
+  const realOpen = XMLHttpRequest.prototype.open
+  XMLHttpRequest.prototype.open = function (method, url) {
+    const rest = Array.prototype.slice.call(arguments, 2)
+    return realOpen.call(this, method, encode(url), ...rest)
+  }
+  patch(XMLHttpRequest.prototype, 'withCredentials', function () {
+    return { get() { return false }, set() {} }
+  })
+  getter(XMLHttpRequest.prototype, 'responseURL', original)
+  self.WebSocket = new Proxy(self.WebSocket, {
+    construct(target, args) {
+      args[0] = socketUrl(args[0])
+      return Reflect.construct(target, args)
+    },
+  })
+  if (self.EventSource) {
+    self.EventSource = new Proxy(self.EventSource, {
+      construct(target, args) {
+        return new target(encode(args[0]))
+      },
+    })
+  }
+  function workerUrl(value, options) {
+    const text = String(value)
+    if (skipped.test(text)) return text
+    const target = URL.parse(text, baseUrl())
+    if (target === null) return text
+    const runtime = origin + prefix + 'runtime.js?url=' + encodeURIComponent(target.href) + '&origin=' + encodeURIComponent(origin)
+    const script = absolute(target.href)
+    const code = options && options.type === 'module'
+      ? 'import ' + JSON.stringify(runtime) + ';import ' + JSON.stringify(script) + ';'
+      : 'importScripts(' + JSON.stringify(runtime) + ');importScripts(' + JSON.stringify(script) + ');'
+    return URL.createObjectURL(new Blob([code], { type: 'text/javascript' }))
+  }
+  for (const name of ['Worker', 'SharedWorker']) {
+    if (self[name]) {
+      self[name] = new Proxy(self[name], {
+        construct(target, args) {
+          args[0] = workerUrl(args[0], args[1])
+          return Reflect.construct(target, args)
+        },
+      })
+    }
+  }
+  if (!inWindow) {
+    if (self.importScripts) {
+      const realImport = self.importScripts.bind(self)
+      self.importScripts = function () {
+        realImport(...Array.from(arguments, function (item) { return absolute(item) }))
+      }
+    }
+    return
+  }
+
+  delete Navigator.prototype.serviceWorker
+  Object.defineProperty(window, 'indexedDB', { value: undefined, configurable: true })
+  Object.defineProperty(window, 'caches', {
+    configurable: true,
+    value: {
+      keys() { return Promise.resolve([]) },
+      has() { return Promise.resolve(false) },
+      delete() { return Promise.resolve(false) },
+      match() { return Promise.resolve(undefined) },
+      open() { return Promise.reject(new DOMException('Cache storage is off', 'SecurityError')) },
+    },
+  })
+  Object.defineProperty(Navigator.prototype, 'locks', {
+    configurable: true,
+    value: {
+      request(name, options, callback) {
+        const run = callback ?? options
+        return Promise.resolve().then(function () { return run({ name, mode: 'exclusive' }) })
+      },
+      query() { return Promise.resolve({ held: [], pending: [] }) },
+    },
+  })
+  const blankFrames = new Proxy(window, {
+    get(target, name) {
+      if (name === 'document') throw new DOMException('Helper frames are blocked', 'SecurityError')
+      const value = Reflect.get(target, name)
+      return typeof value === 'function' && value.prototype === undefined ? value.bind(target) : value
+    },
+  })
+  getter(HTMLIFrameElement.prototype, 'contentWindow', function (value, frame) {
+    const blank = native.get.call(frame, 'src') === null && native.get.call(frame, 'srcdoc') === null
+    return blank && value !== null ? blankFrames : value
+  })
+  const realBeacon = navigator.sendBeacon.bind(navigator)
+  navigator.sendBeacon = function (url, data) { return realBeacon(encode(url), data) }
+
+  const properties = [
+    [HTMLAnchorElement, 'href'], [HTMLAreaElement, 'href'], [HTMLLinkElement, 'href'], [HTMLBaseElement, 'href'],
+    [HTMLImageElement, 'src'], [HTMLScriptElement, 'src'], [HTMLIFrameElement, 'src'], [HTMLMediaElement, 'src'],
+    [HTMLSourceElement, 'src'], [HTMLEmbedElement, 'src'], [HTMLInputElement, 'src'], [HTMLTrackElement, 'src'],
+    [HTMLFormElement, 'action'], [HTMLButtonElement, 'formAction'], [HTMLInputElement, 'formAction'],
+    [HTMLObjectElement, 'data'], [HTMLVideoElement, 'poster'],
+  ]
+  for (const item of properties) {
+    patch(item[0].prototype, item[1], function (descriptor) {
+      return {
+        get() { return original(descriptor.get.call(this)) },
+        set(value) { descriptor.set.call(this, encode(value)) },
+      }
+    })
+  }
+  const RealAudio = window.Audio
+  window.Audio = function Audio(source) {
+    return source === undefined ? new RealAudio() : new RealAudio(encode(source))
+  }
+  window.Audio.prototype = RealAudio.prototype
+  for (const owner of [HTMLImageElement, HTMLSourceElement]) {
+    patch(owner.prototype, 'srcset', function (descriptor) {
+      return {
+        get() { return descriptor.get.call(this) },
+        set(value) { descriptor.set.call(this, encodeSet(value)) },
+      }
+    })
+  }
+  for (const owner of [HTMLScriptElement, HTMLLinkElement]) {
+    patch(owner.prototype, 'integrity', function () {
+      return { get() { return '' }, set() {} }
+    })
+  }
+  for (const part of ['protocol', 'host', 'hostname', 'port', 'pathname', 'search', 'hash', 'origin']) {
+    for (const owner of [HTMLAnchorElement, HTMLAreaElement]) {
+      getter(owner.prototype, part, function (value, element) {
+        const url = URL.parse(element.href)
+        return url === null ? value : url[part]
+      })
+    }
+  }
+
+  const linkTags = new Set(['A', 'AREA', 'AUDIO', 'BASE', 'BUTTON', 'EMBED', 'FORM', 'IFRAME', 'IMG', 'INPUT', 'LINK', 'OBJECT', 'SCRIPT', 'SOURCE', 'TRACK', 'VIDEO'])
+  const linkNames = new Set(['href', 'src', 'action', 'formaction', 'poster', 'data'])
+  Element.prototype.setAttribute = function (name, value) {
+    const lower = String(name).toLowerCase()
+    if (lower === 'integrity' || lower === 'crossorigin') return
+    if (linkNames.has(lower) && linkTags.has(this.tagName)) {
+      native.set.call(this, name, encode(value))
+      return
+    }
+    if (lower === 'srcset') {
+      native.set.call(this, name, encodeSet(value))
+      return
+    }
+    native.set.call(this, name, value)
+  }
+  Element.prototype.getAttribute = function (name) {
+    const value = native.get.call(this, name)
+    if (value === null) return null
+    const url = decode(value)
+    if (url === null) return value
+    const parsed = URL.parse(url)
+    if (parsed === null || parsed.origin !== new URL(pageUrl()).origin) return url
+    return parsed.pathname + parsed.search + parsed.hash
+  }
+  function encodeSelector(selector) {
+    return String(selector).replace(/\[(src|href)(\^?=)(["']?)([^"'\]]+)\3\]/g, function (match, name, operator, quote, value) {
+      if (!/^(\/|https?:\/\/)/.test(value)) return match
+      return '[' + name + operator + '"' + encode(value) + '"]'
+    })
+  }
+  for (const owner of [Document, DocumentFragment, Element]) {
+    for (const name of ['querySelector', 'querySelectorAll']) {
+      const realQuery = owner.prototype[name]
+      owner.prototype[name] = function (selector) {
+        return realQuery.call(this, encodeSelector(selector))
+      }
+    }
+  }
+  for (const name of ['matches', 'closest']) {
+    const realMatch = Element.prototype[name]
+    Element.prototype[name] = function (selector) {
+      return realMatch.call(this, encodeSelector(selector))
+    }
+  }
+  function encodeCss(text) {
+    return String(text).replace(/url\(\s*(['"]?)(.*?)\1\s*\)/g, function (match, quote, url) {
+      return 'url(' + quote + encode(url) + quote + ')'
+    })
+  }
+  for (const name of ['insertRule', 'replace', 'replaceSync']) {
+    const realRule = CSSStyleSheet.prototype[name]
+    CSSStyleSheet.prototype[name] = function (text, index) {
+      return realRule.call(this, encodeCss(text), index)
+    }
+  }
+  function fixElement(element) {
+    const style = native.get.call(element, 'style')
+    if (style !== null) {
+      const next = encodeCss(style)
+      if (next !== style) native.set.call(element, 'style', next)
+    }
+    if (element.tagName === 'STYLE') {
+      const text = element.textContent
+      const next = encodeCss(text)
+      if (next !== text) element.textContent = next
+      return
+    }
+    if (!linkTags.has(element.tagName)) return
+    for (const name of linkNames) {
+      const value = native.get.call(element, name)
+      if (value !== null) {
+        const next = encode(value)
+        if (next !== value) native.set.call(element, name, next)
+      }
+    }
+    const set = native.get.call(element, 'srcset')
+    if (set !== null && !set.includes(prefix)) native.set.call(element, 'srcset', encodeSet(set))
+  }
+  new MutationObserver(function (records) {
+    for (const record of records) {
+      if (record.type === 'attributes' || record.target.nodeName === 'STYLE') fixElement(record.target)
+      for (const node of record.addedNodes) {
+        if (node.nodeType !== 1) continue
+        fixElement(node)
+        for (const child of node.querySelectorAll('[src],[href],[action],[srcset],[poster],[data],[style],style')) fixElement(child)
+      }
+    }
+  }).observe(document, { childList: true, subtree: true, attributes: true, attributeFilter: ['style'] })
+
+  getter(Document.prototype, 'URL', pageUrl)
+  getter(Document.prototype, 'documentURI', pageUrl)
+  getter(Node.prototype, 'baseURI', baseUrl)
+  getter(Document.prototype, 'referrer', original)
+  patch(Document.prototype, 'domain', function () {
+    return { get() { return new URL(pageUrl()).hostname }, set() {} }
+  })
+  Object.defineProperty(window, 'origin', { get() { return new URL(pageUrl()).origin }, configurable: true })
+  getter(MessageEvent.prototype, 'origin', function (value) {
+    return value === 'null' ? new URL(pageUrl()).origin : value
+  })
+  window.postMessage = function (message, target, transfer) {
+    if (typeof target === 'object' && target !== null) return realPost(message, Object.assign({}, target, { targetOrigin: '*' }))
+    return realPost(message, '*', transfer)
+  }
+
+  const cookies = new Map()
+  for (const item of config.cookies.split('; ')) {
+    const index = item.indexOf('=')
+    if (index > 0) cookies.set(item.slice(0, index), item.slice(index + 1))
+  }
+  patch(Document.prototype, 'cookie', function () {
+    return {
+      get() { return Array.from(cookies, function (item) { return item[0] + '=' + item[1] }).join('; ') },
+      set(value) {
+        const text = String(value)
+        const pair = text.split(';')[0]
+        const index = pair.indexOf('=')
+        const name = pair.slice(0, index).trim()
+        const age = /;\s*max-age=(-?\d+)/i.exec(text)
+        const expires = /;\s*expires=([^;]+)/i.exec(text)
+        const gone = (age && Number(age[1]) <= 0) || (expires && Date.parse(expires[1]) <= Date.now())
+        if (gone) cookies.delete(name)
+        else cookies.set(name, pair.slice(index + 1).trim())
+        realFetch(prefix + 'cookie', { method: 'POST', body: JSON.stringify({ url: pageUrl(), cookie: text }) })
+      },
+    }
+  })
+
+  function storageArea(initial, save) {
+    const data = new Map(Object.entries(initial))
+    const area = {
+      getItem(name) { return data.has(String(name)) ? data.get(String(name)) : null },
+      setItem(name, value) { data.set(String(name), String(value)); save(data) },
+      removeItem(name) { data.delete(String(name)); save(data) },
+      clear() { data.clear(); save(data) },
+      key(index) { return Array.from(data.keys())[index] ?? null },
+      get length() { return data.size },
+    }
+    return new Proxy(area, {
+      get(target, name) {
+        if (name in target) return Reflect.get(target, name)
+        return typeof name === 'string' ? data.get(name) : undefined
+      },
+      set(target, name, value) { target.setItem(name, value); return true },
+      deleteProperty(target, name) { target.removeItem(name); return true },
+      has(target, name) { return name in target || data.has(name) },
+      ownKeys() { return Array.from(data.keys()) },
+      getOwnPropertyDescriptor(target, name) {
+        return data.has(name) ? { value: data.get(name), enumerable: true, configurable: true, writable: true } : undefined
+      },
+    })
+  }
+  let saveTimer = null
+  let pending = null
+  function sendStorage(keepalive) {
+    if (pending === null) return
+    const body = JSON.stringify({ origin: new URL(pageUrl()).origin, data: pending })
+    pending = null
+    realFetch(prefix + 'storage', { method: 'POST', body, keepalive: keepalive && body.length < 60000 })
+  }
+  const local = storageArea(config.storage, function (data) {
+    pending = Object.fromEntries(data)
+    clearTimeout(saveTimer)
+    saveTimer = setTimeout(function () { sendStorage(false) }, 50)
+  })
+  const session = storageArea({}, function () {})
+  Object.defineProperty(window, 'localStorage', { get() { return local }, configurable: true })
+  Object.defineProperty(window, 'sessionStorage', { get() { return session }, configurable: true })
+  addEventListener('pagehide', function () { sendStorage(true) })
+
+  function report(replaced) {
+    postPanel({ event: 'location', url: pageUrl(), replaced: replaced === true })
+  }
+  for (const name of ['pushState', 'replaceState']) {
+    const realHistory = History.prototype[name]
+    History.prototype[name] = function (state, title, url) {
+      const result = realHistory.call(this, state, title, url === undefined || url === null ? url : encode(url))
+      report(name === 'replaceState')
+      return result
+    }
+  }
+  const realWindowOpen = window.open
+  window.open = function (url, target, features) {
+    if (url === undefined || url === null || url === '') return realWindowOpen.call(window, url, target, features)
+    if (features) return realWindowOpen.call(window, encode(url), target, features)
+    navigate(url)
+    return window
+  }
+  if (panel === null) return
+  report()
+  addEventListener('popstate', report)
+  addEventListener('hashchange', report)
+  addEventListener('pageshow', report)
+  addEventListener('pagehide', function () { postPanel({ event: 'loading' }) })
+  addEventListener('click', function (event) {
+    if (event.defaultPrevented || event.button !== 0 || event.ctrlKey || event.metaKey || event.shiftKey) return
+    const anchor = event.target instanceof Element ? event.target.closest('a[href]') : null
+    if (anchor === null || anchor.hasAttribute('download')) return
+    const next = URL.parse(anchor.href)
+    if (next === null || !/^https?:$/.test(next.protocol)) return
+    if (next.host === new URL(pageUrl()).host) return
+    event.preventDefault()
+    navigate(next.href)
+  })
+  addEventListener('message', function (event) {
+    if (event.source !== panel || !event.data || event.data.offsite !== 'browser') return
+    event.stopImmediatePropagation()
+    if (event.data.command === 'back') history.back()
+    if (event.data.command === 'forward') history.forward()
+    if (event.data.command === 'reload') realLocation.reload()
+  })
+}`;
+// src/lib/proxy/proxy.ts
+const ROUTE = /^\/api\/proxy\/([^/]+)\/(.*)$/;
+const TARGET = /^(https?)\/([^/?#]+)(.*)$/;
+const SANDBOX = "sandbox allow-scripts allow-forms allow-popups allow-modals allow-downloads allow-presentation allow-pointer-lock";
+const UPSTREAM_TIMEOUT = 6e4;
+const MAX_BODY = 8388608;
+const MAX_HEADERS = 262144;
+const REQUEST_HEADERS_DROPPED = /* @__PURE__ */ new Set([
+	"accept-encoding",
+	"cdn-loop",
+	"connection",
+	"cookie",
+	"forwarded",
+	"host",
+	"keep-alive",
+	"origin",
+	"proxy-authorization",
+	"proxy-connection",
+	"referer",
+	"sec-fetch-site",
+	"sec-fetch-user",
+	"te",
+	"trailer",
+	"transfer-encoding",
+	"true-client-ip",
+	"upgrade",
+	"via",
+	"x-forwarded-for",
+	"x-forwarded-host",
+	"x-forwarded-port",
+	"x-forwarded-proto",
+	"x-real-ip"
+]);
+const RESPONSE_HEADERS_DROPPED = /* @__PURE__ */ new Set([
+	"alt-svc",
+	"clear-site-data",
+	"connection",
+	"content-security-policy",
+	"content-security-policy-report-only",
+	"expect-ct",
+	"feature-policy",
+	"keep-alive",
+	"link",
+	"location",
+	"nel",
+	"origin-agent-cluster",
+	"permissions-policy",
+	"public-key-pins",
+	"referrer-policy",
+	"refresh",
+	"report-to",
+	"reporting-endpoints",
+	"service-worker-allowed",
+	"set-cookie",
+	"strict-transport-security",
+	"transfer-encoding",
+	"x-frame-options"
+]);
+const pageWrite = z.object({
+	url: z.string(),
+	cookie: z.string()
+});
+const storageWrite = z.object({
+	origin: z.string(),
+	data: z.record(z.string(), z.string())
+});
+function serveProxy(request, response) {
+	answerProxy(request, response).catch((error) => {
+		fail(response, 502, error instanceof Error ? error.message : String(error));
+	});
+}
+async function answerProxy(request, response) {
+	const route = ROUTE.exec(request.url ?? "");
+	const site = route === null ? null : findSite(route[1] ?? "");
+	response.setHeader("access-control-allow-origin", request.headers.origin ?? "*");
+	response.setHeader("access-control-allow-credentials", "true");
+	response.setHeader("access-control-expose-headers", "*");
+	if (route === null || site === null) {
+		fail(response, 404, "This page expired. Press reload to open it again.");
+		return;
+	}
+	response.setHeader("content-security-policy", pagePolicy(site, request));
+	response.setHeader("referrer-policy", "unsafe-url");
+	if (request.method === "OPTIONS") {
+		response.setHeader("access-control-allow-methods", request.headers["access-control-request-method"] ?? "*");
+		response.setHeader("access-control-allow-headers", request.headers["access-control-request-headers"] ?? "*");
+		response.statusCode = 204;
+		response.end();
+		return;
+	}
+	const rest = route[2] ?? "";
+	if (rest.startsWith("runtime.js")) {
+		serveRuntime(site, rest, response);
+		return;
+	}
+	if (rest === "cookie" || rest === "storage") {
+		await savePageData(site, rest, request, response);
+		return;
+	}
+	const target = readTarget(rest);
+	if (target === null) {
+		fail(response, 404, "not found");
+		return;
+	}
+	await forward(site, target, request, response);
+}
+function proxySocket(request, socket, head) {
+	socket.on("error", () => socket.destroy());
+	try {
+		connectSocket(request, socket, head);
+	} catch {
+		socket.destroy();
+	}
+}
+function connectSocket(request, socket, head) {
+	const route = ROUTE.exec(request.url ?? "");
+	const site = route === null ? null : findSite(route[1] ?? "");
+	const target = route === null ? null : readTarget(route[2] ?? "");
+	if (site === null || target === null) {
+		socket.destroy();
+		return;
+	}
+	const headers = upstreamHeaders(site, target, request);
+	headers.connection = "Upgrade";
+	headers.upgrade = request.headers.upgrade;
+	const upstream = openUpstream(site, target, request, headers);
+	upstream.on("upgrade", (answer, remote, remoteHead) => {
+		const lines = [`HTTP/1.1 101 ${answer.statusMessage}`];
+		for (let index = 0; index < answer.rawHeaders.length; index += 2) lines.push(`${answer.rawHeaders[index]}: ${answer.rawHeaders[index + 1]}`);
+		socket.write(`${lines.join("\r\n")}\r\n\r\n`);
+		if (remoteHead.length > 0) socket.write(remoteHead);
+		if (head.length > 0) remote.write(head);
+		remote.on("error", () => socket.destroy());
+		socket.on("close", () => remote.destroy());
+		remote.pipe(socket).pipe(remote);
+	});
+	upstream.on("response", () => socket.destroy());
+	upstream.on("error", () => socket.destroy());
+	upstream.end();
+}
+async function forward(site, target, request, response) {
+	const headers = upstreamHeaders(site, target, request);
+	headers["accept-encoding"] = "gzip, deflate, br";
+	const upstream = openUpstream(site, target, request, headers);
+	response.on("close", () => upstream.destroy());
+	const answer = once(upstream, "response");
+	upstream.on("error", () => void 0);
+	request.pipe(upstream);
+	const incoming = (await answer)[0];
+	upstream.setTimeout(0);
+	for (const cookie of incoming.headers["set-cookie"] ?? []) await site.jar.setCookie(cookie, target.href, { ignoreError: true });
+	const kind = rewriteKind(incoming, request);
+	response.statusCode = incoming.statusCode ?? 502;
+	copyHeaders(incoming, response, kind !== null);
+	const location = incoming.headers.location;
+	if (location !== void 0) {
+		const next = URL.parse(location, target);
+		if (next === null) throw new Error(`${target.origin} sent a bad redirect`);
+		response.setHeader("location", proxiedPath(site.key, next));
+	}
+	if (kind === null) {
+		await pipeline(incoming, response);
+		return;
+	}
+	const text = decodeBody(await readBody(incoming), incoming);
+	response.setHeader("content-type", contentType(kind));
+	response.end(await rewriteBody(site, target, kind, text));
+}
+function openUpstream(site, target, request, headers) {
+	const secure = target.protocol === "https:";
+	const port = Number(target.port) || (secure ? 443 : 80);
+	const ownPort = request.socket.localPort ?? 0;
+	const hostname = hostOf(target);
+	if (target.host === request.headers.host) throw new Error("Pages cannot reach Offsite itself");
+	if (isIP(hostname) !== 0) checkAddress(site, hostname, port, ownPort);
+	const upstream = (secure ? https : http).request(target, {
+		method: request.method,
+		headers,
+		lookup: guardedLookup(site, port, ownPort),
+		maxHeaderSize: MAX_HEADERS,
+		timeout: UPSTREAM_TIMEOUT,
+		rejectUnauthorized: !site.local
+	});
+	upstream.on("timeout", () => upstream.destroy(/* @__PURE__ */ new Error(`${target.host} took too long to answer`)));
+	return upstream;
+}
+function upstreamHeaders(site, target, request) {
+	const headers = {};
+	for (const name of Object.keys(request.headers)) if (!REQUEST_HEADERS_DROPPED.has(name) && !name.startsWith("cf-")) headers[name] = request.headers[name];
+	headers.host = target.host;
+	const cookie = site.jar.getCookieStringSync(target.href);
+	if (cookie !== "") headers.cookie = cookie;
+	const referer = refererOf(site, request);
+	if (referer !== null) headers.referer = referer;
+	else if (request.method !== "GET" && request.method !== "HEAD") headers.referer = `${target.origin}/`;
+	if (request.headers.origin !== void 0) headers.origin = referer === null ? target.origin : new URL(referer).origin;
+	return headers;
+}
+function refererOf(site, request) {
+	const referer = request.headers.referer;
+	const prefix = `/api/proxy/${site.key}/`;
+	if (referer === void 0 || !referer.includes(prefix)) return null;
+	return readTarget(referer.slice(referer.indexOf(prefix) + prefix.length))?.href ?? null;
+}
+function readTarget(rest) {
+	const match = TARGET.exec(rest);
+	if (match === null) return null;
+	return URL.parse(`${match[1]}://${match[2]}${match[3]}`);
+}
+function pagePolicy(site, request) {
+	const host = request.headers.host;
+	if (host === void 0) throw new Error("the request has no host");
+	const sources = [
+		"http",
+		"https",
+		"ws",
+		"wss"
+	].map((scheme) => `${scheme}://${host}/api/proxy/${site.key}/`).join(" ");
+	return `${SANDBOX}; default-src ${sources} 'unsafe-inline' 'unsafe-eval' data: blob:; form-action ${sources}; base-uri ${sources}`;
+}
+function rewriteKind(incoming, request) {
+	if (request.headers["sec-fetch-dest"] === "empty") return null;
+	const type = incoming.headers["content-type"]?.split(";")[0]?.trim() ?? "";
+	if (type === "text/html" || type === "application/xhtml+xml") return "html";
+	if (type === "text/css") return "css";
+	if (/\b(java|ecma)script\b/.test(type)) return "script";
+	return null;
+}
+function contentType(kind) {
+	if (kind === "html") return "text/html; charset=utf-8";
+	if (kind === "css") return "text/css; charset=utf-8";
+	return "text/javascript; charset=utf-8";
+}
+async function rewriteBody(site, target, kind, text) {
+	const rewrite = linkRewriter(site.key, target);
+	if (kind === "css") return rewriteCss(text, rewrite);
+	if (kind === "script") return rewriteScript(text, rewrite, `${site.key} ${target.origin}`);
+	const script = pageScript({
+		key: site.key,
+		url: target.href,
+		cookies: site.jar.getCookieStringSync(target.href, { http: false }),
+		storage: site.storage.get(target.origin) ?? {},
+		origin: null
+	});
+	return rewriteHtml(text, site.key, target, script);
+}
+function copyHeaders(incoming, response, rewritten) {
+	for (const name of Object.keys(incoming.headers)) {
+		const value = incoming.headers[name];
+		if (value === void 0 || RESPONSE_HEADERS_DROPPED.has(name) || name.startsWith("access-control-") || name.startsWith("cross-origin-")) continue;
+		if (rewritten && (name === "content-length" || name === "content-encoding" || name === "content-md5" || name === "etag")) continue;
+		response.setHeader(name, value);
+	}
+	if (rewritten) {
+		const cache = incoming.headers["cache-control"];
+		response.setHeader("cache-control", cache === void 0 ? "no-transform" : `${cache}, no-transform`);
+	}
+}
+async function readBody(incoming) {
+	const encoding = incoming.headers["content-encoding"];
+	if (encoding === void 0 || encoding === "identity") return buffer(incoming);
+	if (encoding === "gzip") return buffer(incoming.pipe(zlib.createGunzip()));
+	if (encoding === "deflate") return buffer(incoming.pipe(zlib.createInflate()));
+	if (encoding === "br") return buffer(incoming.pipe(zlib.createBrotliDecompress()));
+	throw new Error(`the site sent unknown compression: ${encoding}`);
+}
+function decodeBody(body, incoming) {
+	const declared = /charset=["']?([\w-]+)/i.exec(incoming.headers["content-type"] ?? "")?.[1] ?? /<meta[^>]+charset=["']?([\w-]+)/i.exec(body.subarray(0, 1024).toString("latin1"))?.[1] ?? "utf-8";
+	try {
+		return new TextDecoder(declared).decode(body);
+	} catch {
+		return new TextDecoder("utf-8").decode(body);
+	}
+}
+function serveRuntime(site, rest, response) {
+	const query = new URL(rest, "http://localhost").searchParams;
+	const url = query.get("url");
+	const origin = query.get("origin");
+	if (url === null || origin === null) {
+		fail(response, 400, "the runtime needs a url and an origin");
+		return;
+	}
+	response.setHeader("content-type", "text/javascript; charset=utf-8");
+	response.end(pageScript({
+		key: site.key,
+		url,
+		cookies: "",
+		storage: {},
+		origin
+	}));
+}
+async function savePageData(site, kind, request, response) {
+	if (request.method !== "POST") {
+		fail(response, 405, "use POST");
+		return;
+	}
+	const body = await buffer(request);
+	if (body.length > MAX_BODY) {
+		fail(response, 413, "too much page data");
+		return;
+	}
+	const data = JSON.parse(body.toString());
+	if (kind === "cookie") {
+		const write = pageWrite.parse(data);
+		await site.jar.setCookie(write.cookie, write.url, {
+			ignoreError: true,
+			http: false
+		});
+	}
+	if (kind === "storage") {
+		const write = storageWrite.parse(data);
+		site.storage.set(write.origin, write.data);
+	}
+	response.statusCode = 204;
+	response.end();
+}
+function fail(response, status, message) {
+	if (response.headersSent) {
+		response.destroy();
+		return;
+	}
+	response.statusCode = status;
+	response.setHeader("content-type", "text/plain; charset=utf-8");
+	response.end(message);
+}
 // src/storage/auth.ts
 const CODE_LIFETIME = 3e5;
 const DEVICE_LIFETIME = 2592e6;
@@ -7588,7 +8732,6 @@ function hash(secret) {
 // src/main.ts
 const UNPAIR_CHECK = 5e3;
 const TICKET_LIFETIME = 6e4;
-const SNIFF_LENGTH = 8e3;
 const openBody = z.object({ path: z.string() });
 const contentTypes = {
 	".html": "text/html; charset=utf-8",
@@ -7660,6 +8803,10 @@ const server = createServer((request, response) => {
 		serveBrowse(url.pathname, request, response);
 		return;
 	}
+	if (url.pathname.startsWith("/api/proxy/")) {
+		serveProxy(request, response);
+		return;
+	}
 	if (url.pathname === `/api/open/${openSecret}`) {
 		answerOpen(request, response);
 		return;
@@ -7682,6 +8829,10 @@ const sockets = new WebSocketServer({
 const paired = /* @__PURE__ */ new Map();
 server.on("upgrade", (request, socket, head) => {
 	const url = new URL(request.url ?? "/", "http://localhost");
+	if (url.pathname.startsWith("/api/proxy/")) {
+		proxySocket(request, socket, head);
+		return;
+	}
 	const device = args.auth ? redeemTicket(url.searchParams.get("ticket")) : null;
 	if (url.pathname !== "/ws" || args.auth && device === null) {
 		socket.destroy();
@@ -7816,19 +8967,9 @@ function serveBrowse(pathname, request, response) {
 		response.end(`${file} is not a file`);
 		return;
 	}
-	response.setHeader("content-type", browseType(file));
-	response.setHeader("cache-control", "no-cache");
+	setBrowseHeaders(response, browseTypes.get(path.extname(file).toLowerCase()) ?? sniffType(file));
 	streamFile(file, stats.size, request, response);
 }
-function browseType(file) {
-	const known = browseTypes.get(path.extname(file).toLowerCase());
-	if (known !== void 0) return known;
-	const head = Buffer.alloc(SNIFF_LENGTH);
-	const handle = openSync(file, "r");
-	const read = readSync(handle, head, 0, SNIFF_LENGTH, 0);
-	closeSync(handle);
-	return head.subarray(0, read).includes(0) ? "application/octet-stream" : "text/plain; charset=utf-8";
-}
 async function answerOpen(request, response) {
 	if (request.method !== "POST") {
 		response.statusCode = 405;