@sproutboat/toolchain 0.7.0 → 0.8.1

package/src/pin.ts

@@ -11,11 +11,11 @@
  * uWebSockets archive in `sproutboat-cli/vendor/` — then run both repos'
  * test + conformance suites. See sproutboat-cli/MIGRATION.md.
  */
-export const PORFFOR_CHANNEL = "alpha-17";
-export const PORFFOR_COMMIT_FULL = "731f1b2a150d441ed22da3d14f8b1e0daaae8ee4";
+export const PORFFOR_CHANNEL = "alpha-18";
+export const PORFFOR_COMMIT_FULL = "deda4945a526d3974ff79e499e8c1dcef0873f3a";
 export const PORFFOR_COMMIT = PORFFOR_COMMIT_FULL.slice(0, 7);
 export const PORFFOR_ARCHIVE_SHA256 =
-  "8eb65a3e77d58a23bfd2a1a60328672ad50e1ced7931f8d0ca3108e29d6cf846";
+  "4626ffba0d5bd417ba2c5b96506d40a152dbbeeaa8a698c904054bdef6bc6e64";
 export const PORFFOR_ARCHIVE_URL = `https://codeload.github.com/CanadaHonk/porffor/tar.gz/${PORFFOR_COMMIT_FULL}`;
 
 /** A compact identity string for a manifest / report (`alpha-17 (731f1b2)`). */

package/src/repeat-native.test.ts

@@ -0,0 +1,34 @@
+import { expect, test } from "bun:test";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { resolve } from "node:path";
+import { ensurePorffor } from "./acquire";
+
+// sproutd B16: the doubling String.prototype.repeat matches Bun on edge cases and
+// repeats 600 KB in well under a millisecond instead of ~2.4 ms per call.
+const source = `const cases = [["ab", 0], ["ab", 1], ["ab", 2], ["ab", 3], ["abc", 7], ["x", 1000], ["é", 5], ["😀", 3], ["", 5], ["héllo", 33]];
+const out = cases.map(([s, n]) => { const r = s.repeat(n); return [r.length, r.slice(0, 12), r.slice(-6)]; });
+const t = performance.now(); let n = 0; for (let i = 0; i < 50; i++) n += "ab".repeat(300000).length + "é".repeat(200000).length;
+console.log(JSON.stringify({ out, n }));
+console.log(Math.round(performance.now() - t));`;
+
+test("B16: String.prototype.repeat matches Bun and is linear in copies, not repetitions", async () => {
+  const dir = await mkdtemp(resolve(tmpdir(), "sb-repeat-"));
+  try {
+    const porffor = await ensurePorffor();
+    const input = resolve(dir, "case.js"), binary = resolve(dir, "case");
+    await writeFile(input, source);
+    const compile = Bun.spawnSync(["bun", resolve(porffor, "runtime/index.js"), "native", input, "-o", binary, "-s", "-O0"], { stdout: "pipe", stderr: "pipe" });
+    expect(compile.exitCode, new TextDecoder().decode(compile.stderr)).toBe(0);
+    const run = Bun.spawnSync([binary], { stdout: "pipe", stderr: "pipe", timeout: 10_000 });
+    expect(run.exitCode, new TextDecoder().decode(run.stderr)).toBe(0);
+    const reference = Bun.spawnSync(["bun", input], { stdout: "pipe" });
+    const lines = (bytes: Uint8Array) => new TextDecoder().decode(bytes).replaceAll("\x1b[33m", "").replaceAll("\x1b[0m", "").trim().split("\n");
+    const [got, ms] = lines(run.stdout);
+    expect(JSON.parse(got)).toEqual(JSON.parse(lines(reference.stdout)[0]));
+    // Per-repetition copying took ~180 ms here at -O0; doubling takes a few.
+    expect(Number(ms)).toBeLessThan(60);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}, 60_000);

package/src/streaming.ts

@@ -0,0 +1,125 @@
+/**
+ * Streamed responses for standalone sprouts (sproutd B19), patched into Porffor's
+ * uWebSockets shim (compiler/uwebsockets.js) by patchStreamingResponses.
+ *
+ * The prelude opens a stream (sb_stream_open), marks its Response with the internal
+ * x-sb-stream: <id> header and returns at once with an empty body. The writer sees the
+ * marker, sends the status and headers, and attaches the uWS response to the stream
+ * instead of ending it. The prelude then pumps the ReadableStream: each chunk goes out with
+ * sb_stream_write (chunked transfer encoding), and sb_stream_end finishes the response.
+ * Chunks that arrive before the writer attaches (they can, while microtasks drain) are kept
+ * and flushed on attach. A client that goes away marks the stream aborted, and the next
+ * write returns -1 so the prelude cancels the source.
+ *
+ * Hosts without this shim (sproutd's workers) get the weak STREAM_STUBS: sb_stream_supported
+ * returns 0 and the prelude keeps buffering the body.
+ */
+
+/** Inserted before write_response_value. C++ inside a JS template literal: no backticks, no ${. */
+export const STREAM_REGISTRY = String.raw`// sproutboat B19: streamed responses
+struct SbStream {
+  uWS::HttpResponse<false>* res = nullptr;
+  std::string pending;
+  bool attached = false, ended = false, aborted = false;
+};
+static std::unordered_map<u32, SbStream> sb_streams;
+static u32 sb_stream_next = 1;
+
+extern "C" int sb_stream_supported(void) { return 1; }
+
+extern "C" u32 sb_stream_open(void) {
+  const u32 id = sb_stream_next++;
+  sb_streams[id] = SbStream();
+  return id;
+}
+
+extern "C" int sb_stream_write(u32 id, const char* data, size_t len) {
+  auto it = sb_streams.find(id);
+  if (it == sb_streams.end() || it->second.aborted) return -1;
+  SbStream& s = it->second;
+  if (!s.attached) { s.pending.append(data, len); return 0; }
+  auto* res = s.res;
+  res->cork([res, data, len]() { res->write(std::string_view(data, len)); });
+  return 0;
+}
+
+extern "C" void sb_stream_end(u32 id) {
+  auto it = sb_streams.find(id);
+  if (it == sb_streams.end()) return;
+  SbStream& s = it->second;
+  if (!s.attached && !s.aborted) { s.ended = true; return; }
+  if (!s.aborted) {
+    auto* res = s.res;
+    res->cork([res]() { res->end(); });
+  }
+  sb_streams.erase(it);
+}
+
+static void sb_stream_attach(u32 id, uWS::HttpResponse<false>* res) {
+  auto it = sb_streams.find(id);
+  if (it == sb_streams.end()) { res->end(); return; }
+  SbStream& s = it->second;
+  s.res = res;
+  s.attached = true;
+  res->onAborted([id]() {
+    auto found = sb_streams.find(id);
+    if (found == sb_streams.end()) return;
+    found->second.aborted = true;
+    found->second.res = nullptr;
+  });
+  if (!s.pending.empty()) { res->write(std::string_view(s.pending)); s.pending.clear(); }
+  if (s.ended) { res->end(); sb_streams.erase(it); }
+}
+
+`;
+
+export const STREAM_FORBIDDEN_ANCHOR =
+  '         key == "x-sb-raw-body"; // sproutboat #176: internal signal, never sent\n';
+export const STREAM_FORBIDDEN_INJECT =
+  '         key == "x-sb-raw-body" || // sproutboat #176: internal signal, never sent\n' +
+  '         key == "x-sb-stream"; // sproutboat B19: internal signal, never sent\n';
+
+export const STREAM_SCAN_ANCHOR =
+  '      if (std::string_view(scan_buf, scan_bytes) == "x-sb-raw-body") raw_body = true;\n';
+export const STREAM_SCAN_INJECT =
+  STREAM_SCAN_ANCHOR +
+  '      if (std::string_view(scan_buf, scan_bytes) == "x-sb-stream") {\n' +
+  "        const struct jsval stream_value = unpack_jsval(*((u64*)(porf_mem + scan_entries + i * 16 + 8)));\n" +
+  "        const char* id_buf = nullptr;\n" +
+  "        size_t id_len = 0;\n" +
+  "        char* id_owned = nullptr;\n" +
+  "        porf_native_fetch_read_value(stream_value, &id_buf, &id_len, &id_owned);\n" +
+  "        stream_id = (u32)strtoul(std::string(id_buf, id_len).c_str(), nullptr, 10);\n" +
+  "        if (id_owned) free(id_owned);\n" +
+  "      }\n";
+
+/** The scan loop above stops at the raw-body header; the stream id needs its own flag. */
+export const STREAM_FLAG_ANCHOR = "  bool raw_body = false;\n";
+export const STREAM_FLAG_INJECT = "  bool raw_body = false;\n  u32 stream_id = 0; // sproutboat B19\n";
+
+export const STREAM_CORK_ANCHOR = "    res->cork([res, status, headers_entries_ptr, body_buf, body_len]() {\n";
+export const STREAM_CORK_INJECT = "    res->cork([res, status, headers_entries_ptr, body_buf, body_len, stream_id]() {\n";
+
+export const STREAM_END_ANCHOR = "      res->end(std::string_view(body_buf, body_len));\n";
+export const STREAM_END_INJECT =
+  "      if (stream_id) sb_stream_attach(stream_id, res); // sproutboat B19: the prelude pumps the body\n" +
+  "      else res->end(std::string_view(body_buf, body_len));\n";
+
+export const STREAM_REGISTRY_ANCHOR =
+  "static void write_response_value(uWS::HttpResponse<false>* res, struct jsval response, bool* aborted) {\n";
+
+/**
+ * Weak fallbacks for the runtime C that render.js emits (compiler/render.js), inserted before
+ * porf_native_fetch_read_raw_bytes. The shim's strong definitions above replace them in a
+ * standalone server; everywhere else (sproutd's workers) sb_stream_supported() returns 0 and
+ * the prelude buffers. Weak definitions, not weak undefined references: Mach-O will not link
+ * an undefined weak reference without -U, while a weak definition links on ELF and Mach-O.
+ */
+export const STREAM_STUBS =
+  "// sproutboat B19: streaming fallbacks, overridden by the native server's shim\n" +
+  "__attribute__((weak)) int sb_stream_supported(void) { return 0; }\n" +
+  "__attribute__((weak)) unsigned int sb_stream_open(void) { return 0; }\n" +
+  "__attribute__((weak)) int sb_stream_write(unsigned int id, const char* data, size_t len) { (void)id; (void)data; (void)len; return -1; }\n" +
+  "__attribute__((weak)) void sb_stream_end(unsigned int id) { (void)id; }\n\n";
+
+export const STREAM_STUBS_ANCHOR = "// sproutboat #176: zero-copy passthrough";

package/src/text-decoder.ts

@@ -0,0 +1,92 @@
+/**
+ * The WHATWG UTF-8 TextDecoder that replaces Porffor's (see patchTextDecoder). Porffor's
+ * decoded three bytes at most (astral characters came out as garbage), never checked
+ * continuation bytes, and ignored fatal, ignoreBOM and { stream }. Found by sproutd's W2
+ * conformance suite against workerd.
+ */
+export const TEXT_DECODER_SOURCE = String.raw`class TextDecoder {
+  // sproutboat: WHATWG UTF-8 decoder
+  constructor(label = 'utf-8', options = undefined) {
+    const name = String(label).trim().toLowerCase();
+    if (name != 'utf-8' && name != 'utf8' && name != 'unicode-1-1-utf-8') throw new RangeError('TextDecoder: unsupported encoding ' + label);
+    this.encoding = 'utf-8';
+    this.fatal = !!(options && options.fatal);
+    this.ignoreBOM = !!(options && options.ignoreBOM);
+    this._pending = [];
+    this._started = false;
+  }
+
+  decode(input = undefined, options = undefined) {
+    const stream = !!(options && options.stream);
+    let view;
+    if (input == null) view = new Uint8Array(0);
+    else if (input instanceof ArrayBuffer) view = new Uint8Array(input);
+    else if (ArrayBuffer.isView(input)) view = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+    else throw new TypeError('TextDecoder.decode: input must be an ArrayBuffer or a view of one');
+    let bytes = view;
+    if (this._pending.length > 0) {
+      bytes = new Uint8Array(this._pending.length + view.length);
+      for (let i = 0; i < this._pending.length; i++) bytes[i] = this._pending[i];
+      bytes.set(view, this._pending.length);
+      this._pending = [];
+    }
+    const n = bytes.length;
+    let out = '';
+    let i = 0;
+    while (i < n) {
+      const a = bytes[i];
+      let cp = -1;
+      let next = i + 1;
+      if (a < 0x80) cp = a;
+      else {
+        let need = 0, lower = 0x80, upper = 0xbf;
+        if (a >= 0xc2 && a <= 0xdf) { need = 1; cp = a & 0x1f; }
+        else if (a >= 0xe0 && a <= 0xef) { need = 2; cp = a & 0x0f; if (a == 0xe0) lower = 0xa0; if (a == 0xed) upper = 0x9f; }
+        else if (a >= 0xf0 && a <= 0xf4) { need = 3; cp = a & 0x07; if (a == 0xf0) lower = 0x90; if (a == 0xf4) upper = 0x8f; }
+        if (need == 0) cp = -1;
+        else {
+          let k = 0;
+          while (k < need) {
+            if (next >= n) break;
+            const c = bytes[next];
+            if (c < lower || c > upper) break;
+            lower = 0x80; upper = 0xbf;
+            cp = (cp << 6) | (c & 0x3f);
+            next++; k++;
+          }
+          if (k < need) {
+            if (next >= n && stream) {
+              // An incomplete sequence at the end of a chunk waits for the next one.
+              for (let j = i; j < n; j++) this._pending.push(bytes[j]);
+              break;
+            }
+            cp = -1;
+          }
+        }
+      }
+      if (cp < 0) {
+        if (this.fatal) {
+          this._pending = [];
+          this._started = false;
+          throw new TypeError('The encoded data was not valid utf-8');
+        }
+        cp = 0xfffd;
+      }
+      if (!this._started) {
+        this._started = true;
+        if (cp == 0xfeff && !this.ignoreBOM) { i = next; continue; }
+      }
+      if (cp > 0xffff) {
+        cp -= 0x10000;
+        out += String.fromCharCode(0xd800 + (cp >> 10), 0xdc00 + (cp & 0x3ff));
+      } else out += String.fromCharCode(cp);
+      i = next;
+    }
+    if (!stream) {
+      this._pending = [];
+      this._started = false;
+    }
+    return out;
+  }
+}
+`;

package/src/url-class.ts

@@ -0,0 +1,342 @@
+/**
+ * The URL class patchURLClass puts into Porffor's runtime/fetch-globals.js. Porffor's own
+ * exposes href, origin, pathname and search only, with no setters but pathname, no base
+ * argument and no hash, so Workers code that rewrites a URL (`url.hostname = ...`,
+ * `url.searchParams.set(...)`, `new URL(path, request.url)`) failed or went stale.
+ * Plain JavaScript compiled by Porffor; checked against WHATWG URL behaviour (Bun's) by
+ * packages/runtime/test/native-url.ts. searchParams is the prelude's URLSearchParams,
+ * which writes back through `_url` and is re-read through `_reset`.
+ */
+export const URL_CLASS_SOURCE = String.raw`class URL {
+  // sproutboat: WHATWG-style URL. Porffor's had href/origin/pathname/search only, no
+  // setters but pathname, no base argument, no hash.
+  constructor(input, base = undefined) {
+    const raw = input != null && typeof input == 'object' && input.href != null ? String(input.href) : String(input);
+    if (this._parse(raw)) return;
+    if (base == null) throw new TypeError('Invalid URL: ' + raw);
+    this._resolve(raw.trim(), base instanceof URL ? base : new URL(base));
+  }
+
+  static _defaultPort(protocol) {
+    if (protocol == 'http:' || protocol == 'ws:') return '80';
+    if (protocol == 'https:' || protocol == 'wss:') return '443';
+    if (protocol == 'ftp:') return '21';
+    return '';
+  }
+
+  static canParse(input, base = undefined) {
+    try {
+      new URL(input, base);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  _clear() {
+    this._username = '';
+    this._password = '';
+    this._hostname = '';
+    this._port = '';
+    this._pathname = '';
+    this._query = null;
+    this._fragment = null;
+    this._params = null;
+  }
+
+  // Splits off the fragment and the query (null when absent, '' when empty); returns the rest.
+  _splitTail(rest) {
+    const hashAt = rest.indexOf('#');
+    this._fragment = hashAt == -1 ? null : URL._escape(rest.slice(hashAt + 1));
+    if (hashAt != -1) rest = rest.slice(0, hashAt);
+    const queryAt = rest.indexOf('?');
+    this._query = queryAt == -1 ? null : URL._escape(rest.slice(queryAt + 1), this._isSpecial());
+    if (queryAt != -1) rest = rest.slice(0, queryAt);
+    return rest;
+  }
+
+  // false when raw has no scheme (a relative reference).
+  _parse(raw) {
+    raw = raw.trim();
+    const first = raw.charCodeAt(0);
+    if (!((first >= 65 && first <= 90) || (first >= 97 && first <= 122))) return false;
+    let i = 1;
+    while (i < raw.length) {
+      const c = raw.charCodeAt(i);
+      if ((c >= 65 && c <= 90) || (c >= 97 && c <= 122) || (c >= 48 && c <= 57) || c == 43 || c == 45 || c == 46) i++;
+      else break;
+    }
+    if (raw.charCodeAt(i) != 58) return false;
+    this._clear();
+    this._protocol = raw.slice(0, i + 1).toLowerCase();
+    let rest = this._splitTail(raw.slice(i + 1));
+    if (rest.startsWith('//')) {
+      rest = rest.slice(2);
+      let end = rest.indexOf('/');
+      if (end == -1) end = rest.length;
+      this._setAuthority(rest.slice(0, end));
+      if (this._hostname == '' && this._protocol != 'file:') throw new TypeError('Invalid URL: ' + raw);
+      this._pathname = URL._path(rest.slice(end) || '/');
+    } else if (this._isSpecial()) {
+      throw new TypeError('Invalid URL: ' + raw);
+    } else {
+      this._pathname = rest;
+    }
+    return true;
+  }
+
+  _isSpecial() {
+    const p = this._protocol;
+    return p == 'http:' || p == 'https:' || p == 'ws:' || p == 'wss:' || p == 'ftp:' || p == 'file:';
+  }
+
+  _resolve(raw, base) {
+    if (raw.startsWith('//')) {
+      if (!this._parse(base._protocol + raw)) throw new TypeError('Invalid URL: ' + raw);
+      return;
+    }
+    this._clear();
+    this._protocol = base._protocol;
+    this._username = base._username;
+    this._password = base._password;
+    this._hostname = base._hostname;
+    this._port = base._port;
+    const path = this._splitTail(raw);
+    if (path == '') {
+      this._pathname = base._pathname;
+      if (raw.indexOf('?') == -1) this._query = base._query;
+    } else if (path.startsWith('/')) {
+      this._pathname = URL._path(path);
+    } else {
+      const dir = base._pathname.slice(0, base._pathname.lastIndexOf('/') + 1);
+      this._pathname = URL._path(dir + path);
+    }
+  }
+
+  _setAuthority(auth) {
+    const at = auth.lastIndexOf('@');
+    if (at != -1) {
+      const info = auth.slice(0, at);
+      const colon = info.indexOf(':');
+      this._username = colon == -1 ? info : info.slice(0, colon);
+      this._password = colon == -1 ? '' : info.slice(colon + 1);
+      auth = auth.slice(at + 1);
+    }
+    this._setHost(auth);
+  }
+
+  _setHost(host) {
+    const close = host.charCodeAt(0) == 91 ? host.indexOf(']') : -1;
+    const colon = host.indexOf(':', close == -1 ? 0 : close);
+    this._hostname = URL._toASCII((colon == -1 ? host : host.slice(0, colon)).toLowerCase());
+    if (colon != -1) this.port = host.slice(colon + 1);
+  }
+
+  // An internationalized host in its ASCII form: each non-ASCII label as xn-- plus its
+  // Punycode (RFC 3492), as fetch and DNS need it. Lowercased first; no full UTS 46 mapping.
+  static _toASCII(host) {
+    if (host.charCodeAt(0) == 91) return host;
+    let ascii = true;
+    for (let i = 0; i < host.length; i++) if (host.charCodeAt(i) > 127) { ascii = false; break; }
+    if (ascii) return host;
+    const labels = host.split('.');
+    for (let i = 0; i < labels.length; i++) {
+      const label = labels[i];
+      for (let j = 0; j < label.length; j++) if (label.charCodeAt(j) > 127) { labels[i] = 'xn--' + URL._punycode(label); break; }
+    }
+    return labels.join('.');
+  }
+
+  static _punycode(input) {
+    const base = 36, tMin = 1, tMax = 26, skew = 38, damp = 700;
+    const points = [];
+    for (let i = 0; i < input.length; i++) {
+      const c = input.codePointAt(i);
+      points.push(c);
+      if (c > 0xffff) i++;
+    }
+    let out = '';
+    for (let i = 0; i < points.length; i++) if (points[i] < 0x80) out += String.fromCharCode(points[i]);
+    const basic = out.length;
+    let handled = basic;
+    if (basic > 0) out += '-';
+    const digit = (d) => String.fromCharCode(d < 26 ? d + 97 : d + 22);
+    const adapt = (delta, count, first) => {
+      delta = first ? Math.floor(delta / damp) : delta >> 1;
+      delta += Math.floor(delta / count);
+      let k = 0;
+      while (delta > ((base - tMin) * tMax) >> 1) { delta = Math.floor(delta / (base - tMin)); k += base; }
+      return k + Math.floor(((base - tMin + 1) * delta) / (delta + skew));
+    };
+    let n = 128, delta = 0, bias = 72;
+    while (handled < points.length) {
+      let m = 0x110000;
+      for (let i = 0; i < points.length; i++) if (points[i] >= n && points[i] < m) m = points[i];
+      delta += (m - n) * (handled + 1);
+      n = m;
+      for (let i = 0; i < points.length; i++) {
+        const c = points[i];
+        if (c < n) delta++;
+        if (c == n) {
+          let q = delta;
+          for (let k = base; ; k += base) {
+            const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
+            if (q < t) break;
+            out += digit(t + ((q - t) % (base - t)));
+            q = Math.floor((q - t) / (base - t));
+          }
+          out += digit(q);
+          bias = adapt(delta, handled + 1, handled == basic);
+          delta = 0;
+          handled++;
+        }
+      }
+      delta++;
+      n++;
+    }
+    return out;
+  }
+
+  // Dot segments resolved, spaces escaped.
+  static _path(p) {
+    p = URL._escape(p, false, true);
+    if (p.indexOf('.') == -1 && p.indexOf('%2') == -1) return p;
+    const parts = p.split('/');
+    const out = [];
+    for (let i = 1; i < parts.length; i++) {
+      const s = parts[i];
+      const last = i == parts.length - 1;
+      const l = s.toLowerCase();
+      if (l == '.' || l == '%2e') {
+        if (last) out.push('');
+      } else if (l == '..' || l == '.%2e' || l == '%2e.' || l == '%2e%2e') {
+        if (out.length > 0) out.pop();
+        if (last) out.push('');
+      } else {
+        out.push(s);
+      }
+    }
+    return '/' + out.join('/');
+  }
+
+  // The WHATWG percent-encode sets that matter here: C0 controls, space, " < > and backtick, non-ASCII;
+  // plus ' in a query, { } in a path. Existing %XX sequences stay as they are.
+  static _escape(s, query = false, path = false) {
+    let out = '';
+    for (let i = 0; i < s.length; i++) {
+      const c = s.charCodeAt(i);
+      if (c <= 32 || c == 34 || c == 60 || c == 62 || c == 96 || c == 127 || (query && c == 39) || (path && (c == 123 || c == 125))) {
+        out += '%' + (c < 16 ? '0' : '') + c.toString(16).toUpperCase();
+      } else if (c > 127) {
+        const pair = c >= 0xd800 && c <= 0xdbff && i + 1 < s.length;
+        out += encodeURIComponent(pair ? s.slice(i, i + 2) : s[i]);
+        if (pair) i++;
+      } else {
+        out += s[i];
+      }
+    }
+    return out;
+  }
+
+  get protocol() { return this._protocol; }
+  set protocol(value) {
+    let v = String(value);
+    const colon = v.indexOf(':');
+    if (colon != -1) v = v.slice(0, colon);
+    if (v == '') return;
+    this._protocol = v.toLowerCase() + ':';
+    if (this._port == URL._defaultPort(this._protocol)) this._port = '';
+  }
+
+  get username() { return this._username; }
+  set username(value) { if (this._hostname != '') this._username = URL._escape(String(value)); }
+  get password() { return this._password; }
+  set password(value) { if (this._hostname != '') this._password = URL._escape(String(value)); }
+
+  get hostname() { return this._hostname; }
+  set hostname(value) {
+    const v = String(value);
+    if (v != '' && this._hostname != '') this._hostname = URL._toASCII(v.toLowerCase());
+  }
+
+  get port() { return this._port; }
+  set port(value) {
+    const v = String(value);
+    let digits = '';
+    for (let i = 0; i < v.length; i++) {
+      const c = v.charCodeAt(i);
+      if (c < 48 || c > 57) break;
+      digits += v[i];
+    }
+    if (digits == '' && v != '') return;
+    if (digits != '') digits = String(Number(digits));
+    if (Number(digits) > 65535) return;
+    this._port = digits == URL._defaultPort(this._protocol) ? '' : digits;
+  }
+
+  get host() { return this._port == '' ? this._hostname : this._hostname + ':' + this._port; }
+  set host(value) {
+    const v = String(value);
+    if (v != '' && this._hostname != '') this._setHost(v);
+  }
+
+  get origin() {
+    return this._isSpecial() && this._protocol != 'file:' ? this._protocol + '//' + this.host : 'null';
+  }
+
+  get pathname() { return this._pathname; }
+  set pathname(value) {
+    if (this._hostname == '' && !this._isSpecial()) return;
+    const v = String(value);
+    this._pathname = URL._path(v.startsWith('/') ? v : '/' + v);
+  }
+
+  get search() { return this._query == null || this._query == '' ? '' : '?' + this._query; }
+  set search(value) {
+    let v = String(value);
+    if (v.startsWith('?')) v = v.slice(1);
+    this._query = v == '' ? null : URL._escape(v, this._isSpecial());
+    if (this._params != null) this._params._reset(this.search);
+  }
+
+  get hash() { return this._fragment == null || this._fragment == '' ? '' : '#' + this._fragment; }
+  set hash(value) {
+    let v = String(value);
+    if (v.startsWith('#')) v = v.slice(1);
+    this._fragment = v == '' ? null : URL._escape(v);
+  }
+
+  get searchParams() {
+    if (this._params == null) {
+      this._params = new globalThis.URLSearchParams(this.search);
+      this._params._url = this;
+    }
+    return this._params;
+  }
+
+  get href() {
+    let out = this._protocol;
+    if (this._hostname != '' || this._protocol == 'file:') {
+      out += '//';
+      if (this._username != '' || this._password != '') {
+        out += this._username;
+        if (this._password != '') out += ':' + this._password;
+        out += '@';
+      }
+      out += this.host;
+    }
+    out += this._pathname;
+    if (this._query != null) out += '?' + this._query;
+    if (this._fragment != null) out += '#' + this._fragment;
+    return out;
+  }
+  set href(value) {
+    const v = String(value);
+    if (!this._parse(v)) throw new TypeError('Invalid URL: ' + v);
+  }
+
+  toString() { return this.href; }
+  toJSON() { return this.href; }
+}
+
+`;