Add Surge MITM and scripts

script/modules/url/escape.go

@@ -0,0 +1,55 @@
+package url
+
+import "strings"
+
+var tblEscapeURLQuery = [128]byte{
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+}
+
+// The code below is mostly borrowed from the standard Go url package
+
+const upperhex = "0123456789ABCDEF"
+
+func escape(s string, table *[128]byte, spaceToPlus bool) string {
+	spaceCount, hexCount := 0, 0
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		if c > 127 || table[c] == 0 {
+			if c == ' ' && spaceToPlus {
+				spaceCount++
+			} else {
+				hexCount++
+			}
+		}
+	}
+
+	if spaceCount == 0 && hexCount == 0 {
+		return s
+	}
+
+	var sb strings.Builder
+	hexBuf := [3]byte{'%', 0, 0}
+
+	sb.Grow(len(s) + 2*hexCount)
+
+	for i := 0; i < len(s); i++ {
+		switch c := s[i]; {
+		case c == ' ' && spaceToPlus:
+			sb.WriteByte('+')
+		case c > 127 || table[c] == 0:
+			hexBuf[1] = upperhex[c>>4]
+			hexBuf[2] = upperhex[c&15]
+			sb.Write(hexBuf[:])
+		default:
+			sb.WriteByte(c)
+		}
+	}
+	return sb.String()
+}

script/modules/url/module.go

@@ -0,0 +1,41 @@
+package url
+
+import (
+	"github.com/sagernet/sing-box/script/jsc"
+	"github.com/sagernet/sing-box/script/modules/require"
+
+	"github.com/dop251/goja"
+)
+
+const ModuleName = "url"
+
+var _ jsc.Module = (*Module)(nil)
+
+type Module struct {
+	runtime                      *goja.Runtime
+	classURL                     jsc.Class[*Module, *URL]
+	classURLSearchParams         jsc.Class[*Module, *URLSearchParams]
+	classURLSearchParamsIterator jsc.Class[*Module, *jsc.Iterator[*Module, searchParam]]
+}
+
+func Require(runtime *goja.Runtime, module *goja.Object) {
+	m := &Module{
+		runtime: runtime,
+	}
+	m.classURL = createURL(m)
+	m.classURLSearchParams = createURLSearchParams(m)
+	m.classURLSearchParamsIterator = jsc.CreateIterator[*Module, searchParam](m)
+	exports := module.Get("exports").(*goja.Object)
+	exports.Set("URL", m.classURL.ToValue())
+	exports.Set("URLSearchParams", m.classURLSearchParams.ToValue())
+}
+
+func Enable(runtime *goja.Runtime) {
+	exports := require.Require(runtime, ModuleName).ToObject(runtime)
+	runtime.Set("URL", exports.Get("URL"))
+	runtime.Set("URLSearchParams", exports.Get("URLSearchParams"))
+}
+
+func (m *Module) Runtime() *goja.Runtime {
+	return m.runtime
+}

script/modules/url/module_test.go

@@ -0,0 +1,37 @@
+package url_test
+
+import (
+	_ "embed"
+	"testing"
+
+	"github.com/sagernet/sing-box/script/jstest"
+	"github.com/sagernet/sing-box/script/modules/url"
+
+	"github.com/dop251/goja"
+)
+
+var (
+	//go:embed testdata/url_test.js
+	urlTest string
+
+	//go:embed testdata/url_search_params_test.js
+	urlSearchParamsTest string
+)
+
+func TestURL(t *testing.T) {
+	registry := jstest.NewRegistry()
+	registry.RegisterNodeModule(url.ModuleName, url.Require)
+	vm := goja.New()
+	registry.Enable(vm)
+	url.Enable(vm)
+	vm.RunScript("url_test.js", urlTest)
+}
+
+func TestURLSearchParams(t *testing.T) {
+	registry := jstest.NewRegistry()
+	registry.RegisterNodeModule(url.ModuleName, url.Require)
+	vm := goja.New()
+	registry.Enable(vm)
+	url.Enable(vm)
+	vm.RunScript("url_search_params_test.js", urlSearchParamsTest)
+}

script/modules/url/testdata/url_search_params_test.js

@@ -0,0 +1,385 @@
+"use strict";
+
+const assert = require("assert.js");
+
+let params;
+
+function testCtor(value, expected) {
+  assert.sameValue(new URLSearchParams(value).toString(), expected);
+}
+
+testCtor("user=abc&query=xyz", "user=abc&query=xyz");
+testCtor("?user=abc&query=xyz", "user=abc&query=xyz");
+
+testCtor(
+  {
+    num: 1,
+    user: "abc",
+    query: ["first", "second"],
+    obj: { prop: "value" },
+    b: true,
+  },
+  "num=1&user=abc&query=first%2Csecond&obj=%5Bobject+Object%5D&b=true"
+);
+
+const map = new Map();
+map.set("user", "abc");
+map.set("query", "xyz");
+testCtor(map, "user=abc&query=xyz");
+
+testCtor(
+  [
+    ["user", "abc"],
+    ["query", "first"],
+    ["query", "second"],
+  ],
+  "user=abc&query=first&query=second"
+);
+
+// Each key-value pair must have exactly two elements
+assert.throwsNodeError(() => new URLSearchParams([["single_value"]]), TypeError, "ERR_INVALID_TUPLE");
+assert.throwsNodeError(() => new URLSearchParams([["too", "many", "values"]]), TypeError, "ERR_INVALID_TUPLE");
+
+params = new URLSearchParams("a=b&cc=d");
+params.forEach((value, name, searchParams) => {
+  if (name === "a") {
+    assert.sameValue(value, "b");
+  }
+  if (name === "cc") {
+    assert.sameValue(value, "d");
+  }
+  assert.sameValue(searchParams, params);
+});
+
+params.forEach((value, name, searchParams) => {
+    if (name === "a") {
+        assert.sameValue(value, "b");
+        searchParams.set("cc", "d1");
+    }
+    if (name === "cc") {
+        assert.sameValue(value, "d1");
+    }
+    assert.sameValue(searchParams, params);
+});
+
+assert.throwsNodeError(() => params.forEach(123), TypeError, "ERR_INVALID_ARG_TYPE");
+
+assert.throwsNodeError(() => params.forEach.call(1, 2), TypeError, "ERR_INVALID_THIS");
+
+params = new URLSearchParams("a=1=2&b=3");
+assert.sameValue(params.size, 2);
+assert.sameValue(params.get("a"), "1=2");
+assert.sameValue(params.get("b"), "3");
+
+params = new URLSearchParams("&");
+assert.sameValue(params.size, 0);
+
+params = new URLSearchParams("& ");
+assert.sameValue(params.size, 1);
+assert.sameValue(params.get(" "), "");
+
+params = new URLSearchParams(" &");
+assert.sameValue(params.size, 1);
+assert.sameValue(params.get(" "), "");
+
+params = new URLSearchParams("=");
+assert.sameValue(params.size, 1);
+assert.sameValue(params.get(""), "");
+
+params = new URLSearchParams("&=2");
+assert.sameValue(params.size, 1);
+assert.sameValue(params.get(""), "2");
+
+params = new URLSearchParams("?user=abc");
+assert.throwsNodeError(() => params.append(), TypeError, "ERR_MISSING_ARGS");
+params.append("query", "first");
+assert.sameValue(params.toString(), "user=abc&query=first");
+
+params = new URLSearchParams("first=one&second=two&third=three");
+assert.throwsNodeError(() => params.delete(), TypeError, "ERR_MISSING_ARGS");
+params.delete("second", "fake-value");
+assert.sameValue(params.toString(), "first=one&second=two&third=three");
+params.delete("third", "three");
+assert.sameValue(params.toString(), "first=one&second=two");
+params.delete("second");
+assert.sameValue(params.toString(), "first=one");
+
+params = new URLSearchParams("user=abc&query=xyz");
+assert.throwsNodeError(() => params.get(), TypeError, "ERR_MISSING_ARGS");
+assert.sameValue(params.get("user"), "abc");
+assert.sameValue(params.get("non-existant"), null);
+
+params = new URLSearchParams("query=first&query=second");
+assert.throwsNodeError(() => params.getAll(), TypeError, "ERR_MISSING_ARGS");
+const all = params.getAll("query");
+assert.sameValue(all.includes("first"), true);
+assert.sameValue(all.includes("second"), true);
+assert.sameValue(all.length, 2);
+const getAllUndefined = params.getAll(undefined);
+assert.sameValue(getAllUndefined.length, 0);
+const getAllNonExistant = params.getAll("does_not_exists");
+assert.sameValue(getAllNonExistant.length, 0);
+
+params = new URLSearchParams("user=abc&query=xyz");
+assert.throwsNodeError(() => params.has(), TypeError, "ERR_MISSING_ARGS");
+assert.sameValue(params.has(undefined), false);
+assert.sameValue(params.has("user"), true);
+assert.sameValue(params.has("user", "abc"), true);
+assert.sameValue(params.has("user", "abc", "extra-param"), true);
+assert.sameValue(params.has("user", "efg"), false);
+assert.sameValue(params.has("user", undefined), true);
+
+params = new URLSearchParams();
+params.append("foo", "bar");
+params.append("foo", "baz");
+params.append("abc", "def");
+assert.sameValue(params.toString(), "foo=bar&foo=baz&abc=def");
+params.set("foo", "def");
+params.set("xyz", "opq");
+assert.sameValue(params.toString(), "foo=def&abc=def&xyz=opq");
+
+params = new URLSearchParams("query=first&query=second&user=abc&double=first,second");
+const URLSearchIteratorPrototype = params.entries().__proto__;
+assert.sameValue(typeof URLSearchIteratorPrototype, "object");
+
+assert.sameValue(params[Symbol.iterator], params.entries);
+
+{
+    const entries = params.entries();
+    assert.sameValue(entries.toString(), "[object URLSearchParams Iterator]");
+    assert.sameValue(entries.__proto__, URLSearchIteratorPrototype);
+
+    let item = entries.next();
+    assert.sameValue(item.value.toString(), ["query", "first"].toString());
+    assert.sameValue(item.done, false);
+
+    item = entries.next();
+    assert.sameValue(item.value.toString(), ["query", "second"].toString());
+    assert.sameValue(item.done, false);
+
+    item = entries.next();
+    assert.sameValue(item.value.toString(), ["user", "abc"].toString());
+    assert.sameValue(item.done, false);
+
+    item = entries.next();
+    assert.sameValue(item.value.toString(), ["double", "first,second"].toString());
+    assert.sameValue(item.done, false);
+
+    item = entries.next();
+    assert.sameValue(item.value, undefined);
+    assert.sameValue(item.done, true);
+}
+
+params = new URLSearchParams("query=first&query=second&user=abc");
+{
+    const keys = params.keys();
+    assert.sameValue(keys.__proto__, URLSearchIteratorPrototype);
+
+    let item = keys.next();
+    assert.sameValue(item.value, "query");
+    assert.sameValue(item.done, false);
+
+    item = keys.next();
+    assert.sameValue(item.value, "query");
+    assert.sameValue(item.done, false);
+
+    item = keys.next();
+    assert.sameValue(item.value, "user");
+    assert.sameValue(item.done, false);
+
+    item = keys.next();
+    assert.sameValue(item.value, undefined);
+    assert.sameValue(item.done, true);
+}
+
+params = new URLSearchParams("query=first&query=second&user=abc");
+{
+    const values = params.values();
+    assert.sameValue(values.__proto__, URLSearchIteratorPrototype);
+
+    let item = values.next();
+    assert.sameValue(item.value, "first");
+    assert.sameValue(item.done, false);
+
+    item = values.next();
+    assert.sameValue(item.value, "second");
+    assert.sameValue(item.done, false);
+
+    item = values.next();
+    assert.sameValue(item.value, "abc");
+    assert.sameValue(item.done, false);
+
+    item = values.next();
+    assert.sameValue(item.value, undefined);
+    assert.sameValue(item.done, true);
+}
+
+
+params = new URLSearchParams("query[]=abc&type=search&query[]=123");
+params.sort();
+assert.sameValue(params.toString(), "query%5B%5D=abc&query%5B%5D=123&type=search");
+
+params = new URLSearchParams("query=first&query=second&user=abc");
+assert.sameValue(params.size, 3);
+
+params = new URLSearchParams("%");
+assert.sameValue(params.has("%"), true);
+assert.sameValue(params.toString(), "%25=");
+
+{
+    const params = new URLSearchParams("");
+    assert.sameValue(params.size, 0);
+    assert.sameValue(params.toString(), "");
+    assert.sameValue(params.get(undefined), null);
+    params.set(undefined, true);
+    assert.sameValue(params.has(undefined), true);
+    assert.sameValue(params.has("undefined"), true);
+    assert.sameValue(params.get("undefined"), "true");
+    assert.sameValue(params.get(undefined), "true");
+    assert.sameValue(params.getAll(undefined).toString(), ["true"].toString());
+    params.delete(undefined);
+    assert.sameValue(params.has(undefined), false);
+    assert.sameValue(params.has("undefined"), false);
+
+    assert.sameValue(params.has(null), false);
+    params.set(null, "nullval");
+    assert.sameValue(params.has(null), true);
+    assert.sameValue(params.has("null"), true);
+    assert.sameValue(params.get(null), "nullval");
+    assert.sameValue(params.get("null"), "nullval");
+    params.delete(null);
+    assert.sameValue(params.has(null), false);
+    assert.sameValue(params.has("null"), false);
+}
+
+function* functionGeneratorExample() {
+  yield ["user", "abc"];
+  yield ["query", "first"];
+  yield ["query", "second"];
+}
+
+params = new URLSearchParams(functionGeneratorExample());
+assert.sameValue(params.toString(), "user=abc&query=first&query=second");
+
+assert.sameValue(params.__proto__.constructor, URLSearchParams);
+assert.sameValue(params instanceof URLSearchParams, true);
+
+{
+    const params = new URLSearchParams("1=2&1=3");
+    assert.sameValue(params.get(1), "2");
+    assert.sameValue(params.getAll(1).toString(), ["2", "3"].toString());
+    assert.sameValue(params.getAll("x").toString(), [].toString());
+}
+
+// Sync
+{
+    const url = new URL("https://test.com/");
+    const params = url.searchParams;
+    assert.sameValue(params.size, 0);
+    url.search = "a=1";
+    assert.sameValue(params.size, 1);
+    assert.sameValue(params.get("a"), "1");
+}
+
+{
+    const url = new URL("https://test.com/?a=1");
+    const params = url.searchParams;
+    assert.sameValue(params.size, 1);
+    url.search = "";
+    assert.sameValue(params.size, 0);
+    url.search = "b=2";
+    assert.sameValue(params.size, 1);
+}
+
+{
+    const url = new URL("https://test.com/");
+    const params = url.searchParams;
+    params.append("a", "1");
+    assert.sameValue(url.toString(), "https://test.com/?a=1");
+}
+
+{
+    const url = new URL("https://test.com/");
+    url.searchParams.append("a", "1");
+    url.searchParams.append("b", "1");
+    assert.sameValue(url.toString(), "https://test.com/?a=1&b=1");
+}
+
+{
+    const url = new URL("https://test.com/");
+    const params = url.searchParams;
+    url.searchParams.append("a", "1");
+    assert.sameValue(url.search, "?a=1");
+}
+
+{
+    const url = new URL("https://test.com/?a=1");
+    const params = url.searchParams;
+    params.append("a", "2");
+    assert.sameValue(url.search, "?a=1&a=2");
+}
+
+{
+    const url = new URL("https://test.com/");
+    const params = url.searchParams;
+    params.set("a", "1");
+    assert.sameValue(url.search, "?a=1");
+}
+
+{
+    const url = new URL("https://test.com/");
+    url.searchParams.set("a", "1");
+    url.searchParams.set("b", "1");
+    assert.sameValue(url.toString(), "https://test.com/?a=1&b=1");
+}
+
+{
+    const url = new URL("https://test.com/?a=1&b=2");
+    const params = url.searchParams;
+    params.delete("a");
+    assert.sameValue(url.search, "?b=2");
+}
+
+{
+    const url = new URL("https://test.com/?b=2&a=1");
+    const params = url.searchParams;
+    params.sort();
+    assert.sameValue(url.search, "?a=1&b=2");
+}
+
+{
+    const url = new URL("https://test.com/?a=1");
+    const params = url.searchParams;
+    params.delete("a");
+    assert.sameValue(url.search, "");
+
+    params.set("a", 2);
+    assert.sameValue(url.search, "?a=2");
+}
+
+// FAILING: no custom properties on wrapped Go structs
+/*
+{
+    const params = new URLSearchParams("");
+    assert.sameValue(Object.isExtensible(params), true);
+    assert.sameValue(Reflect.defineProperty(params, "customField", {value: 42, configurable: true}), true);
+    assert.sameValue(params.customField, 42);
+    const desc = Reflect.getOwnPropertyDescriptor(params, "customField");
+    assert.sameValue(desc.value, 42);
+    assert.sameValue(desc.writable, false);
+    assert.sameValue(desc.enumerable, false);
+    assert.sameValue(desc.configurable, true);
+}
+*/
+
+// Escape
+{
+    const myURL = new URL('https://example.org/abc?fo~o=~ba r%z');
+
+    assert.sameValue(myURL.search, "?fo~o=~ba%20r%z");
+
+    // Modify the URL via searchParams...
+    myURL.searchParams.sort();
+
+    assert.sameValue(myURL.search, "?fo%7Eo=%7Eba+r%25z");
+}

script/modules/url/testdata/url_test.js

@@ -0,0 +1,229 @@
+"use strict";
+
+const assert = require("assert.js");
+
+function testURLCtor(str, expected) {
+  assert.sameValue(new URL(str).toString(), expected);
+}
+
+function testURLCtorBase(ref, base, expected, message) {
+  assert.sameValue(new URL(ref, base).toString(), expected, message);
+}
+
+testURLCtorBase("https://example.org/", undefined, "https://example.org/");
+testURLCtorBase("/foo", "https://example.org/", "https://example.org/foo");
+testURLCtorBase("http://Example.com/", "https://example.org/", "http://example.com/");
+testURLCtorBase("https://Example.com/", "https://example.org/", "https://example.com/");
+testURLCtorBase("foo://Example.com/", "https://example.org/", "foo://Example.com/");
+testURLCtorBase("foo:Example.com/", "https://example.org/", "foo:Example.com/");
+testURLCtorBase("#hash", "https://example.org/", "https://example.org/#hash");
+
+testURLCtor("HTTP://test.com", "http://test.com/");
+testURLCtor("HTTPS://á.com", "https://xn--1ca.com/");
+testURLCtor("HTTPS://á.com:123", "https://xn--1ca.com:123/");
+testURLCtor("https://test.com#asdfá", "https://test.com/#asdf%C3%A1");
+testURLCtor("HTTPS://á.com:123/á", "https://xn--1ca.com:123/%C3%A1");
+testURLCtor("fish://á.com", "fish://%C3%A1.com");
+testURLCtor("https://test.com/?a=1 /2", "https://test.com/?a=1%20/2");
+testURLCtor("https://test.com/á=1?á=1&ü=2#é", "https://test.com/%C3%A1=1?%C3%A1=1&%C3%BC=2#%C3%A9");
+
+assert.throws(() => new URL("test"), TypeError);
+assert.throws(() => new URL("ssh://EEE:ddd"), TypeError);
+
+{
+    let u = new URL("https://example.org/");
+    assert.sameValue(u.__proto__.constructor, URL);
+    assert.sameValue(u instanceof URL, true);
+}
+
+{
+    let u = new URL("https://example.org/");
+    assert.sameValue(u.searchParams, u.searchParams);
+}
+
+let myURL;
+
+// Hash
+myURL = new URL("https://example.org/foo#bar");
+myURL.hash = "baz";
+assert.sameValue(myURL.href, "https://example.org/foo#baz");
+
+myURL.hash = "#baz";
+assert.sameValue(myURL.href, "https://example.org/foo#baz");
+
+myURL.hash = "#á=1 2";
+assert.sameValue(myURL.href, "https://example.org/foo#%C3%A1=1%202");
+
+myURL.hash = "#a/#b";
+// FAILING: the second # gets escaped
+//assert.sameValue(myURL.href, "https://example.org/foo#a/#b");
+assert.sameValue(myURL.search, "");
+// FAILING: the second # gets escaped
+//assert.sameValue(myURL.hash, "#a/#b");
+
+// Host
+myURL = new URL("https://example.org:81/foo");
+myURL.host = "example.com:82";
+assert.sameValue(myURL.href, "https://example.com:82/foo");
+
+// Hostname
+myURL = new URL("https://example.org:81/foo");
+myURL.hostname = "example.com:82";
+assert.sameValue(myURL.href, "https://example.org:81/foo");
+
+myURL.hostname = "á.com";
+assert.sameValue(myURL.href, "https://xn--1ca.com:81/foo");
+
+// href
+myURL = new URL("https://example.org/foo");
+myURL.href = "https://example.com/bar";
+assert.sameValue(myURL.href, "https://example.com/bar");
+
+// Password
+myURL = new URL("https://abc:xyz@example.com");
+myURL.password = "123";
+assert.sameValue(myURL.href, "https://abc:123@example.com/");
+
+// pathname
+myURL = new URL("https://example.org/abc/xyz?123");
+myURL.pathname = "/abcdef";
+assert.sameValue(myURL.href, "https://example.org/abcdef?123");
+
+myURL.pathname = "";
+assert.sameValue(myURL.href, "https://example.org/?123");
+
+myURL.pathname = "á";
+assert.sameValue(myURL.pathname, "/%C3%A1");
+assert.sameValue(myURL.href, "https://example.org/%C3%A1?123");
+
+// port
+
+myURL = new URL("https://example.org:8888");
+assert.sameValue(myURL.port, "8888");
+
+function testSetPort(port, expected) {
+  const url = new URL("https://example.org:8888");
+  url.port = port;
+  assert.sameValue(url.port, expected);
+}
+
+testSetPort(0, "0");
+testSetPort(-0, "0");
+
+// Default ports are automatically transformed to the empty string
+// (HTTPS protocol's default port is 443)
+testSetPort("443", "");
+testSetPort(443, "");
+
+// Empty string is the same as default port
+testSetPort("", "");
+
+// Completely invalid port strings are ignored
+testSetPort("abcd", "8888");
+testSetPort("-123", "");
+testSetPort(-123, "");
+testSetPort(-123.45, "");
+testSetPort(undefined, "8888");
+testSetPort(null, "8888");
+testSetPort(+Infinity, "8888");
+testSetPort(-Infinity, "8888");
+testSetPort(NaN, "8888");
+
+// Leading numbers are treated as a port number
+testSetPort("5678abcd", "5678");
+testSetPort("a5678abcd", "");
+
+// Non-integers are truncated
+testSetPort(1234.5678, "1234");
+
+// Out-of-range numbers which are not represented in scientific notation
+// will be ignored.
+testSetPort(1e10, "8888");
+testSetPort("123456", "8888");
+testSetPort(123456, "8888");
+testSetPort(4.567e21, "4");
+
+// toString() takes precedence over valueOf(), even if it returns a valid integer
+testSetPort(
+  {
+    toString() {
+      return "2";
+    },
+    valueOf() {
+      return 1;
+    },
+  },
+  "2"
+);
+
+// Protocol
+function testSetProtocol(url, protocol, expected) {
+  url.protocol = protocol;
+  assert.sameValue(url.protocol, expected);
+}
+testSetProtocol(new URL("https://example.org"), "ftp", "ftp:");
+testSetProtocol(new URL("https://example.org"), "ftp:", "ftp:");
+testSetProtocol(new URL("https://example.org"), "FTP:", "ftp:");
+testSetProtocol(new URL("https://example.org"), "ftp: blah", "ftp:");
+// special to non-special
+testSetProtocol(new URL("https://example.org"), "foo", "https:");
+// non-special to special
+testSetProtocol(new URL("fish://example.org"), "https", "fish:");
+
+// Search
+myURL = new URL("https://example.org/abc?123");
+myURL.search = "abc=xyz";
+assert.sameValue(myURL.href, "https://example.org/abc?abc=xyz");
+
+myURL.search = "a=1 2";
+assert.sameValue(myURL.href, "https://example.org/abc?a=1%202");
+
+myURL.search = "á=ú";
+assert.sameValue(myURL.search, "?%C3%A1=%C3%BA");
+assert.sameValue(myURL.href, "https://example.org/abc?%C3%A1=%C3%BA");
+
+myURL.hash = "hash";
+myURL.search = "a=#b";
+assert.sameValue(myURL.href, "https://example.org/abc?a=%23b#hash");
+assert.sameValue(myURL.search, "?a=%23b");
+assert.sameValue(myURL.hash, "#hash");
+
+// Username
+myURL = new URL("https://abc:xyz@example.com/");
+myURL.username = "123";
+assert.sameValue(myURL.href, "https://123:xyz@example.com/");
+
+// Origin, read-only
+assert.throws(() => {
+  myURL.origin = "abc";
+}, TypeError);
+
+// href
+myURL = new URL("https://example.org");
+myURL.href = "https://example.com";
+assert.sameValue(myURL.href, "https://example.com/");
+
+assert.throws(() => {
+  myURL.href = "test";
+}, TypeError);
+
+// Search Params
+myURL = new URL("https://example.com/");
+myURL.searchParams.append("user", "abc");
+assert.sameValue(myURL.toString(), "https://example.com/?user=abc");
+myURL.searchParams.append("first", "one");
+assert.sameValue(myURL.toString(), "https://example.com/?user=abc&first=one");
+myURL.searchParams.delete("user");
+assert.sameValue(myURL.toString(), "https://example.com/?first=one");
+
+{
+    const url = require("url");
+
+    assert.sameValue(url.domainToASCII('español.com'), "xn--espaol-zwa.com");
+    assert.sameValue(url.domainToASCII('中文.com'), "xn--fiq228c.com");
+    assert.sameValue(url.domainToASCII('xn--iñvalid.com'), "");
+
+    assert.sameValue(url.domainToUnicode('xn--espaol-zwa.com'), "español.com");
+    assert.sameValue(url.domainToUnicode('xn--fiq228c.com'), "中文.com");
+    assert.sameValue(url.domainToUnicode('xn--iñvalid.com'), "");
+}

script/modules/url/url.go

@@ -0,0 +1,315 @@
+package url
+
+import (
+	"net"
+	"net/url"
+	"strings"
+
+	"github.com/sagernet/sing-box/script/jsc"
+	E "github.com/sagernet/sing/common/exceptions"
+
+	"github.com/dop251/goja"
+	"golang.org/x/net/idna"
+)
+
+type URL struct {
+	class       jsc.Class[*Module, *URL]
+	url         *url.URL
+	params      *URLSearchParams
+	paramsValue goja.Value
+}
+
+func newURL(c jsc.Class[*Module, *URL], call goja.ConstructorCall) *URL {
+	var (
+		u, base *url.URL
+		err     error
+	)
+	switch argURL := call.Argument(0).Export().(type) {
+	case *URL:
+		u = argURL.url
+	default:
+		u, err = parseURL(call.Argument(0).String())
+		if err != nil {
+			panic(c.Runtime().NewGoError(E.Cause(err, "parse URL")))
+		}
+	}
+	if len(call.Arguments) == 2 {
+		switch argBaseURL := call.Argument(1).Export().(type) {
+		case *URL:
+			base = argBaseURL.url
+		default:
+			base, err = parseURL(call.Argument(1).String())
+			if err != nil {
+				panic(c.Runtime().NewGoError(E.Cause(err, "parse base URL")))
+			}
+		}
+	}
+	if base != nil {
+		u = base.ResolveReference(u)
+	}
+	return &URL{class: c, url: u}
+}
+
+func createURL(module *Module) jsc.Class[*Module, *URL] {
+	class := jsc.NewClass[*Module, *URL](module)
+	class.DefineConstructor(newURL)
+	class.DefineField("hash", (*URL).getHash, (*URL).setHash)
+	class.DefineField("host", (*URL).getHost, (*URL).setHost)
+	class.DefineField("hostname", (*URL).getHostName, (*URL).setHostName)
+	class.DefineField("href", (*URL).getHref, (*URL).setHref)
+	class.DefineField("origin", (*URL).getOrigin, nil)
+	class.DefineField("password", (*URL).getPassword, (*URL).setPassword)
+	class.DefineField("pathname", (*URL).getPathname, (*URL).setPathname)
+	class.DefineField("port", (*URL).getPort, (*URL).setPort)
+	class.DefineField("protocol", (*URL).getProtocol, (*URL).setProtocol)
+	class.DefineField("search", (*URL).getSearch, (*URL).setSearch)
+	class.DefineField("searchParams", (*URL).getSearchParams, (*URL).setSearchParams)
+	class.DefineField("username", (*URL).getUsername, (*URL).setUsername)
+	class.DefineMethod("toString", (*URL).toString)
+	class.DefineMethod("toJSON", (*URL).toJSON)
+	class.DefineStaticMethod("canParse", canParse)
+	// class.DefineStaticMethod("createObjectURL", createObjectURL)
+	class.DefineStaticMethod("parse", parse)
+	// class.DefineStaticMethod("revokeObjectURL", revokeObjectURL)
+	return class
+}
+
+func canParse(class jsc.Class[*Module, *URL], call goja.FunctionCall) any {
+	switch call.Argument(0).Export().(type) {
+	case *URL:
+	default:
+		_, err := parseURL(call.Argument(0).String())
+		if err != nil {
+			return false
+		}
+	}
+	if len(call.Arguments) == 2 {
+		switch call.Argument(1).Export().(type) {
+		case *URL:
+		default:
+			_, err := parseURL(call.Argument(1).String())
+			if err != nil {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func parse(class jsc.Class[*Module, *URL], call goja.FunctionCall) any {
+	var (
+		u, base *url.URL
+		err     error
+	)
+	switch argURL := call.Argument(0).Export().(type) {
+	case *URL:
+		u = argURL.url
+	default:
+		u, err = parseURL(call.Argument(0).String())
+		if err != nil {
+			return goja.Null()
+		}
+	}
+	if len(call.Arguments) == 2 {
+		switch argBaseURL := call.Argument(1).Export().(type) {
+		case *URL:
+			base = argBaseURL.url
+		default:
+			base, err = parseURL(call.Argument(1).String())
+			if err != nil {
+				return goja.Null()
+			}
+		}
+	}
+	if base != nil {
+		u = base.ResolveReference(u)
+	}
+	return &URL{class: class, url: u}
+}
+
+func (r *URL) getHash() any {
+	if r.url.Fragment != "" {
+		return "#" + r.url.EscapedFragment()
+	}
+	return ""
+}
+
+func (r *URL) setHash(value goja.Value) {
+	r.url.RawFragment = strings.TrimPrefix(value.String(), "#")
+}
+
+func (r *URL) getHost() any {
+	return r.url.Host
+}
+
+func (r *URL) setHost(value goja.Value) {
+	r.url.Host = strings.TrimSuffix(value.String(), ":")
+}
+
+func (r *URL) getHostName() any {
+	return r.url.Hostname()
+}
+
+func (r *URL) setHostName(value goja.Value) {
+	r.url.Host = joinHostPort(value.String(), r.url.Port())
+}
+
+func (r *URL) getHref() any {
+	return r.url.String()
+}
+
+func (r *URL) setHref(value goja.Value) {
+	newURL, err := url.Parse(value.String())
+	if err != nil {
+		panic(r.class.Runtime().NewGoError(err))
+	}
+	r.url = newURL
+	r.params = nil
+}
+
+func (r *URL) getOrigin() any {
+	return r.url.Scheme + "://" + r.url.Host
+}
+
+func (r *URL) getPassword() any {
+	if r.url.User != nil {
+		password, _ := r.url.User.Password()
+		return password
+	}
+	return ""
+}
+
+func (r *URL) setPassword(value goja.Value) {
+	if r.url.User == nil {
+		r.url.User = url.UserPassword("", value.String())
+	} else {
+		r.url.User = url.UserPassword(r.url.User.Username(), value.String())
+	}
+}
+
+func (r *URL) getPathname() any {
+	return r.url.EscapedPath()
+}
+
+func (r *URL) setPathname(value goja.Value) {
+	r.url.RawPath = value.String()
+}
+
+func (r *URL) getPort() any {
+	return r.url.Port()
+}
+
+func (r *URL) setPort(value goja.Value) {
+	r.url.Host = joinHostPort(r.url.Hostname(), value.String())
+}
+
+func (r *URL) getProtocol() any {
+	return r.url.Scheme + ":"
+}
+
+func (r *URL) setProtocol(value goja.Value) {
+	r.url.Scheme = strings.TrimSuffix(value.String(), ":")
+}
+
+func (r *URL) getSearch() any {
+	if r.params != nil {
+		if len(r.params.params) > 0 {
+			return "?" + generateQuery(r.params.params)
+		}
+	} else if r.url.RawQuery != "" {
+		return "?" + r.url.RawQuery
+	}
+	return ""
+}
+
+func (r *URL) setSearch(value goja.Value) {
+	params, err := parseQuery(value.String())
+	if err == nil {
+		if r.params != nil {
+			r.params.params = params
+		} else {
+			r.url.RawQuery = generateQuery(params)
+		}
+	}
+}
+
+func (r *URL) getSearchParams() any {
+	var params []searchParam
+	if r.url.RawQuery != "" {
+		params, _ = parseQuery(r.url.RawQuery)
+	}
+	if r.params == nil {
+		r.params = &URLSearchParams{
+			class:  r.class.Module().classURLSearchParams,
+			params: params,
+		}
+		r.paramsValue = r.class.Module().classURLSearchParams.New(r.params)
+	}
+	return r.paramsValue
+}
+
+func (r *URL) setSearchParams(value goja.Value) {
+	if params, ok := value.Export().(*URLSearchParams); ok {
+		r.params = params
+		r.paramsValue = value
+	}
+}
+
+func (r *URL) getUsername() any {
+	if r.url.User != nil {
+		return r.url.User.Username()
+	}
+	return ""
+}
+
+func (r *URL) setUsername(value goja.Value) {
+	if r.url.User == nil {
+		r.url.User = url.User(value.String())
+	} else {
+		password, _ := r.url.User.Password()
+		r.url.User = url.UserPassword(value.String(), password)
+	}
+}
+
+func (r *URL) toString(call goja.FunctionCall) any {
+	if r.params != nil {
+		r.url.RawQuery = generateQuery(r.params.params)
+	}
+	return r.url.String()
+}
+
+func (r *URL) toJSON(call goja.FunctionCall) any {
+	return r.toString(call)
+}
+
+func parseURL(s string) (*url.URL, error) {
+	u, err := url.Parse(s)
+	if err != nil {
+		return nil, E.Cause(err, "invalid URL")
+	}
+	switch u.Scheme {
+	case "https", "http", "ftp", "wss", "ws":
+		if u.Path == "" {
+			u.Path = "/"
+		}
+		hostname := u.Hostname()
+		asciiHostname, err := idna.Punycode.ToASCII(strings.ToLower(hostname))
+		if err != nil {
+			return nil, E.Cause(err, "invalid hostname")
+		}
+		if asciiHostname != hostname {
+			u.Host = joinHostPort(asciiHostname, u.Port())
+		}
+	}
+	if u.RawQuery != "" {
+		u.RawQuery = escape(u.RawQuery, &tblEscapeURLQuery, false)
+	}
+	return u, nil
+}
+
+func joinHostPort(hostname, port string) string {
+	if port == "" {
+		return hostname
+	}
+	return net.JoinHostPort(hostname, port)
+}

script/modules/url/url_search_params.go

@@ -0,0 +1,244 @@
+package url
+
+import (
+	"fmt"
+	"net/url"
+	"sort"
+	"strings"
+
+	"github.com/sagernet/sing-box/script/jsc"
+	F "github.com/sagernet/sing/common/format"
+
+	"github.com/dop251/goja"
+)
+
+type URLSearchParams struct {
+	class  jsc.Class[*Module, *URLSearchParams]
+	params []searchParam
+}
+
+func createURLSearchParams(module *Module) jsc.Class[*Module, *URLSearchParams] {
+	class := jsc.NewClass[*Module, *URLSearchParams](module)
+	class.DefineConstructor(newURLSearchParams)
+	class.DefineField("size", (*URLSearchParams).getSize, nil)
+	class.DefineMethod("append", (*URLSearchParams).append)
+	class.DefineMethod("delete", (*URLSearchParams).delete)
+	class.DefineMethod("entries", (*URLSearchParams).entries)
+	class.DefineMethod("forEach", (*URLSearchParams).forEach)
+	class.DefineMethod("get", (*URLSearchParams).get)
+	class.DefineMethod("getAll", (*URLSearchParams).getAll)
+	class.DefineMethod("has", (*URLSearchParams).has)
+	class.DefineMethod("keys", (*URLSearchParams).keys)
+	class.DefineMethod("set", (*URLSearchParams).set)
+	class.DefineMethod("sort", (*URLSearchParams).sort)
+	class.DefineMethod("toString", (*URLSearchParams).toString)
+	class.DefineMethod("values", (*URLSearchParams).values)
+	return class
+}
+
+func newURLSearchParams(class jsc.Class[*Module, *URLSearchParams], call goja.ConstructorCall) *URLSearchParams {
+	var (
+		params []searchParam
+		err    error
+	)
+	switch argInit := call.Argument(0).Export().(type) {
+	case *URLSearchParams:
+		params = argInit.params
+	case string:
+		params, err = parseQuery(argInit)
+		if err != nil {
+			panic(class.Runtime().NewGoError(err))
+		}
+	case [][]string:
+		for _, pair := range argInit {
+			if len(pair) != 2 {
+				panic(class.Runtime().NewTypeError("Each query pair must be an iterable [name, value] tuple"))
+			}
+			params = append(params, searchParam{pair[0], pair[1]})
+		}
+	case map[string]any:
+		for name, value := range argInit {
+			stringValue, isString := value.(string)
+			if !isString {
+				panic(class.Runtime().NewTypeError("Invalid query value"))
+			}
+			params = append(params, searchParam{name, stringValue})
+		}
+	}
+	return &URLSearchParams{class, params}
+}
+
+func (s *URLSearchParams) getSize() any {
+	return len(s.params)
+}
+
+func (s *URLSearchParams) append(call goja.FunctionCall) any {
+	name := jsc.AssertString(s.class.Runtime(), call.Argument(0), "name", false)
+	value := call.Argument(1).String()
+	s.params = append(s.params, searchParam{name, value})
+	return goja.Undefined()
+}
+
+func (s *URLSearchParams) delete(call goja.FunctionCall) any {
+	name := jsc.AssertString(s.class.Runtime(), call.Argument(0), "name", false)
+	argValue := call.Argument(1)
+	if !jsc.IsNil(argValue) {
+		value := argValue.String()
+		for i, param := range s.params {
+			if param.Key == name && param.Value == value {
+				s.params = append(s.params[:i], s.params[i+1:]...)
+				break
+			}
+		}
+	} else {
+		for i, param := range s.params {
+			if param.Key == name {
+				s.params = append(s.params[:i], s.params[i+1:]...)
+				break
+			}
+		}
+	}
+	return goja.Undefined()
+}
+
+func (s *URLSearchParams) entries(call goja.FunctionCall) any {
+	return jsc.NewIterator[*Module, searchParam](s.class.Module().classURLSearchParamsIterator, s.params, func(this searchParam) any {
+		return s.class.Runtime().NewArray(this.Key, this.Value)
+	})
+}
+
+func (s *URLSearchParams) forEach(call goja.FunctionCall) any {
+	callback := jsc.AssertFunction(s.class.Runtime(), call.Argument(0), "callbackFn")
+	thisValue := call.Argument(1)
+	for _, param := range s.params {
+		for _, value := range param.Value {
+			_, err := callback(thisValue, s.class.Runtime().ToValue(value), s.class.Runtime().ToValue(param.Key), call.This)
+			if err != nil {
+				panic(s.class.Runtime().NewGoError(err))
+			}
+		}
+	}
+	return goja.Undefined()
+}
+
+func (s *URLSearchParams) get(call goja.FunctionCall) any {
+	name := jsc.AssertString(s.class.Runtime(), call.Argument(0), "name", false)
+	for _, param := range s.params {
+		if param.Key == name {
+			return param.Value
+		}
+	}
+	return goja.Null()
+}
+
+func (s *URLSearchParams) getAll(call goja.FunctionCall) any {
+	name := jsc.AssertString(s.class.Runtime(), call.Argument(0), "name", false)
+	var values []any
+	for _, param := range s.params {
+		if param.Key == name {
+			values = append(values, param.Value)
+		}
+	}
+	return s.class.Runtime().NewArray(values...)
+}
+
+func (s *URLSearchParams) has(call goja.FunctionCall) any {
+	name := jsc.AssertString(s.class.Runtime(), call.Argument(0), "name", false)
+	argValue := call.Argument(1)
+	if !jsc.IsNil(argValue) {
+		value := argValue.String()
+		for _, param := range s.params {
+			if param.Key == name && param.Value == value {
+				return true
+			}
+		}
+	} else {
+		for _, param := range s.params {
+			if param.Key == name {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func (s *URLSearchParams) keys(call goja.FunctionCall) any {
+	return jsc.NewIterator[*Module, searchParam](s.class.Module().classURLSearchParamsIterator, s.params, func(this searchParam) any {
+		return this.Key
+	})
+}
+
+func (s *URLSearchParams) set(call goja.FunctionCall) any {
+	name := jsc.AssertString(s.class.Runtime(), call.Argument(0), "name", false)
+	value := call.Argument(1).String()
+	for i, param := range s.params {
+		if param.Key == name {
+			s.params[i].Value = value
+			return goja.Undefined()
+		}
+	}
+	s.params = append(s.params, searchParam{name, value})
+	return goja.Undefined()
+}
+
+func (s *URLSearchParams) sort(call goja.FunctionCall) any {
+	sort.SliceStable(s.params, func(i, j int) bool {
+		return s.params[i].Key < s.params[j].Key
+	})
+	return goja.Undefined()
+}
+
+func (s *URLSearchParams) toString(call goja.FunctionCall) any {
+	return generateQuery(s.params)
+}
+
+func (s *URLSearchParams) values(call goja.FunctionCall) any {
+	return jsc.NewIterator[*Module, searchParam](s.class.Module().classURLSearchParamsIterator, s.params, func(this searchParam) any {
+		return this.Value
+	})
+}
+
+type searchParam struct {
+	Key   string
+	Value string
+}
+
+func parseQuery(query string) (params []searchParam, err error) {
+	query = strings.TrimPrefix(query, "?")
+	for query != "" {
+		var key string
+		key, query, _ = strings.Cut(query, "&")
+		if strings.Contains(key, ";") {
+			err = fmt.Errorf("invalid semicolon separator in query")
+			continue
+		}
+		if key == "" {
+			continue
+		}
+		key, value, _ := strings.Cut(key, "=")
+		key, err1 := url.QueryUnescape(key)
+		if err1 != nil {
+			if err == nil {
+				err = err1
+			}
+			continue
+		}
+		value, err1 = url.QueryUnescape(value)
+		if err1 != nil {
+			if err == nil {
+				err = err1
+			}
+			continue
+		}
+		params = append(params, searchParam{key, value})
+	}
+	return
+}
+
+func generateQuery(params []searchParam) string {
+	var parts []string
+	for _, param := range params {
+		parts = append(parts, F.ToString(param.Key, "=", url.QueryEscape(param.Value)))
+	}
+	return strings.Join(parts, "&")
+}