quickwin 1.1.4 → 1.2.1

package/examples/exec_server.js

@@ -1,38 +1,3539 @@
-import { createServer } from '../lib/http-server.js';
-import * as std from 'std';
-function readAll(file) {
-    const chunks = [];
-    const buf = new Uint8Array(4096);
-    while (true) {
-        const n = file.read(buf.buffer, 0, 4096);
-        if (n <= 0)
-            break;
-        chunks.push(buf.slice(0, n));
-    }
-    let total = 0;
-    for (const c of chunks)
-        total += c.length;
-    const out = new Uint8Array(total);
+// _build/lib/polyfill.js
+import * as os from "os";
+
+// _build/lib/url.js
+function _encode(s2) {
+  return encodeURIComponent(s2);
+}
+function _decode(s2) {
+  try {
+    return decodeURIComponent(s2.replace(/\+/g, " "));
+  } catch {
+    return s2;
+  }
+}
+function _normalizePath(path) {
+  if (!path)
+    return "/";
+  const parts = path.split("/");
+  const out = [];
+  let hasRoot = path[0] === "/";
+  if (hasRoot)
+    out.push("");
+  for (const p2 of parts) {
+    if (p2 === "" || p2 === ".")
+      continue;
+    if (p2 === "..") {
+      const last = out[out.length - 1];
+      if (last !== void 0 && last !== "")
+        out.pop();
+    } else {
+      out.push(p2);
+    }
+  }
+  if (path.endsWith("/") && out[out.length - 1] !== "")
+    out.push("");
+  const result = out.join("/");
+  if (hasRoot && !result.startsWith("/"))
+    return "/" + result;
+  return result || "/";
+}
+function _parseURL(url) {
+  const r2 = { scheme: "", user: "", pass: "", host: "", port: "", path: "/", query: "", fragment: "" };
+  const fi = url.indexOf("#");
+  if (fi >= 0) {
+    r2.fragment = url.slice(fi + 1);
+    url = url.slice(0, fi);
+  }
+  const qi = url.indexOf("?");
+  if (qi >= 0) {
+    r2.query = url.slice(qi + 1);
+    url = url.slice(0, qi);
+  }
+  const sm = url.match(/^([a-zA-Z][a-zA-Z0-9+\-.]*):(.*)$/);
+  if (sm) {
+    r2.scheme = sm[1].toLowerCase();
+    url = sm[2];
+  }
+  if (url.startsWith("//")) {
+    url = url.slice(2);
+    const si = url.indexOf("/");
+    let auth;
+    if (si < 0) {
+      auth = url;
+      url = "";
+    } else {
+      auth = url.slice(0, si);
+      url = url.slice(si);
+    }
+    const ai = auth.lastIndexOf("@");
+    if (ai >= 0) {
+      const ui = auth.slice(0, ai);
+      auth = auth.slice(ai + 1);
+      const ci = ui.indexOf(":");
+      if (ci >= 0) {
+        r2.user = _decode(ui.slice(0, ci));
+        r2.pass = _decode(ui.slice(ci + 1));
+      } else
+        r2.user = _decode(ui);
+    }
+    if (auth.startsWith("[")) {
+      const cb = auth.indexOf("]");
+      r2.host = auth.slice(1, cb).toLowerCase();
+      const pp = auth.slice(cb + 1);
+      if (pp.startsWith(":"))
+        r2.port = pp.slice(1);
+    } else {
+      const ci = auth.lastIndexOf(":");
+      if (ci >= 0 && ci === auth.lastIndexOf(":")) {
+        r2.host = auth.slice(0, ci).toLowerCase();
+        r2.port = auth.slice(ci + 1);
+      } else
+        r2.host = auth.toLowerCase();
+    }
+  }
+  r2.path = url;
+  if (r2.host && !r2.path.startsWith("/"))
+    r2.path = "/" + r2.path;
+  return r2;
+}
+var URLSearchParamsImpl = class {
+  _list = [];
+  constructor(init) {
+    if (typeof init === "string") {
+      const s2 = init.startsWith("?") ? init.slice(1) : init;
+      if (!s2)
+        return;
+      for (const p2 of s2.split("&")) {
+        const eq = p2.indexOf("=");
+        if (eq < 0) {
+          this._list.push([_decode(p2), ""]);
+          continue;
+        }
+        this._list.push([_decode(p2.slice(0, eq)), _decode(p2.slice(eq + 1))]);
+      }
+    } else if (init) {
+      if (Array.isArray(init))
+        for (const [k2, v2] of init)
+          this._list.push([String(k2), String(v2)]);
+      else
+        for (const k2 of Object.keys(init))
+          this._list.push([k2, String(init[k2])]);
+    }
+  }
+  append(key, value) {
+    this._list.push([key, value]);
+  }
+  delete(key) {
+    this._list = this._list.filter(([k2]) => k2 !== key);
+  }
+  get(key) {
+    for (const [k2, v2] of this._list)
+      if (k2 === key)
+        return v2;
+    return null;
+  }
+  getAll(key) {
+    return this._list.filter(([k2]) => k2 === key).map(([, v2]) => v2);
+  }
+  has(key) {
+    return this._list.some(([k2]) => k2 === key);
+  }
+  set(key, value) {
+    let f2 = false;
+    for (let i2 = 0; i2 < this._list.length; i2++) {
+      if (this._list[i2][0] === key) {
+        if (!f2) {
+          this._list[i2][1] = value;
+          f2 = true;
+        } else {
+          this._list.splice(i2, 1);
+          i2--;
+        }
+      }
+    }
+    if (!f2)
+      this._list.push([key, value]);
+  }
+  sort() {
+    this._list.sort(([a2], [b2]) => a2 < b2 ? -1 : a2 > b2 ? 1 : 0);
+  }
+  forEach(fn) {
+    for (const [k2, v2] of this._list)
+      fn(v2, k2);
+  }
+  *keys() {
+    for (const [k2] of this._list)
+      yield k2;
+  }
+  *values() {
+    for (const [, v2] of this._list)
+      yield v2;
+  }
+  *entries() {
+    for (const item of this._list)
+      yield [item[0], item[1]];
+  }
+  *[Symbol.iterator]() {
+    for (const item of this._list)
+      yield item;
+  }
+  toString() {
+    return this._list.map(([k2, v2]) => _encode(k2) + "=" + _encode(v2)).join("&");
+  }
+  get size() {
+    return this._list.length;
+  }
+};
+if (typeof globalThis.URLSearchParams === "undefined") {
+  globalThis.URLSearchParams = URLSearchParamsImpl;
+}
+var URLImpl = class _URLImpl {
+  _scheme = "";
+  _username = "";
+  _password = "";
+  _hostname = "";
+  _port = "";
+  _pathname = "/";
+  _query = "";
+  _fragment = "";
+  _searchParams = new URLSearchParamsImpl();
+  constructor(url, base) {
+    let p2 = _parseURL(url);
+    if (p2.scheme) {
+      this._apply(p2);
+      return;
+    }
+    if (base === void 0)
+      throw new TypeError("Invalid URL");
+    const b2 = new _URLImpl(base);
+    if (p2.host) {
+      p2.scheme = b2._scheme;
+      this._apply(p2);
+      return;
+    }
+    if (!p2.path && !p2.query) {
+      this._apply({
+        scheme: b2._scheme,
+        user: b2._username,
+        pass: b2._password,
+        host: b2._hostname,
+        port: b2._port,
+        path: b2._pathname,
+        query: b2._query,
+        fragment: p2.fragment || ""
+      });
+      return;
+    }
+    p2.scheme = b2._scheme;
+    if (!p2.user)
+      p2.user = b2._username;
+    if (!p2.pass)
+      p2.pass = b2._password;
+    if (!p2.host)
+      p2.host = b2._hostname;
+    if (!p2.port)
+      p2.port = b2._port;
+    if (!p2.fragment)
+      p2.fragment = "";
+    if (p2.path && !p2.path.startsWith("/")) {
+      const bd = b2._pathname.substring(0, b2._pathname.lastIndexOf("/") + 1);
+      p2.path = _normalizePath(bd + p2.path);
+    } else if (!p2.path) {
+      p2.path = b2._pathname;
+      if (!p2.query)
+        p2.query = b2._query;
+    }
+    this._apply(p2);
+  }
+  _apply(p2) {
+    this._scheme = p2.scheme;
+    this._username = p2.user;
+    this._password = p2.pass;
+    this._hostname = p2.host;
+    this._port = p2.port;
+    this._pathname = _normalizePath(p2.path || "/");
+    this._query = p2.query;
+    this._fragment = p2.fragment;
+    this._searchParams = new URLSearchParamsImpl(this._query);
+  }
+  get href() {
+    return this.toString();
+  }
+  get protocol() {
+    return this._scheme + ":";
+  }
+  get hostname() {
+    return this._hostname;
+  }
+  get port() {
+    return this._port;
+  }
+  get pathname() {
+    return this._pathname;
+  }
+  get search() {
+    return this._query ? "?" + this._query : "";
+  }
+  get hash() {
+    return this._fragment ? "#" + this._fragment : "";
+  }
+  get host() {
+    const h2 = this._hostname;
+    const ipv6 = h2.includes(":");
+    return (ipv6 ? "[" + h2 + "]" : h2) + (this._port ? ":" + this._port : "");
+  }
+  get origin() {
+    const h2 = this._hostname;
+    const ipv6 = h2.includes(":");
+    return this._scheme + "://" + (ipv6 ? "[" + h2 + "]" : h2) + (this._port ? ":" + this._port : "");
+  }
+  get username() {
+    return this._username;
+  }
+  get password() {
+    return this._password;
+  }
+  get searchParams() {
+    return this._searchParams;
+  }
+  toString() {
+    let s2 = this._scheme + ":";
+    const special = ["http", "https", "ws", "wss", "ftp", "file"];
+    if (this._hostname || special.includes(this._scheme) && this._pathname.startsWith("/")) {
+      s2 += "//";
+      if (this._username) {
+        s2 += _encode(this._username);
+        if (this._password)
+          s2 += ":" + _encode(this._password);
+        s2 += "@";
+      }
+      s2 += this._hostname.includes(":") ? "[" + this._hostname + "]" : this._hostname;
+      if (this._port)
+        s2 += ":" + this._port;
+    }
+    s2 += this._pathname;
+    if (this._query)
+      s2 += "?" + this._query;
+    if (this._fragment)
+      s2 += "#" + this._fragment;
+    return s2;
+  }
+  toJSON() {
+    return this.toString();
+  }
+};
+if (typeof globalThis.URL === "undefined") {
+  globalThis.URL = URLImpl;
+}
+
+// _build/lib/text-codec.js
+var _labelMap = {
+  "utf-8": "utf-8",
+  "utf8": "utf-8",
+  "unicode-1-1-utf-8": "utf-8",
+  "utf-16": "utf-16le",
+  "utf-16le": "utf-16le",
+  "utf-16be": "utf-16be"
+};
+function _normalizeLabel(label) {
+  if (!label)
+    return "utf-8";
+  const result = _labelMap[label.trim().toLowerCase()];
+  if (result)
+    return result;
+  throw new RangeError(`The encoding label "${label}" is not supported`);
+}
+function _decodeUTF8(buf, fatal) {
+  let out = "";
+  for (let i2 = 0; i2 < buf.length; ) {
+    const b2 = buf[i2++];
+    if (b2 < 128) {
+      out += String.fromCharCode(b2);
+      continue;
+    }
+    if (b2 < 192) {
+      out += fatal ? (() => {
+        throw new TypeError("unexpected continuation byte");
+      })() : "\uFFFD";
+      continue;
+    }
+    let c2, min;
+    if (b2 < 224) {
+      if (i2 >= buf.length) {
+        out += fatal ? (() => {
+          throw new TypeError("incomplete utf-8");
+        })() : "\uFFFD";
+        break;
+      }
+      const b22 = buf[i2++];
+      if ((b22 & 192) !== 128) {
+        out += "\uFFFD";
+        continue;
+      }
+      c2 = (b2 & 31) << 6 | b22 & 63;
+      min = 128;
+    } else if (b2 < 240) {
+      if (i2 + 1 >= buf.length) {
+        out += fatal ? (() => {
+          throw new TypeError("incomplete utf-8");
+        })() : "\uFFFD";
+        break;
+      }
+      const b22 = buf[i2++];
+      const b3 = buf[i2++];
+      if ((b22 & 192) !== 128 || (b3 & 192) !== 128) {
+        out += "\uFFFD";
+        continue;
+      }
+      c2 = (b2 & 15) << 12 | (b22 & 63) << 6 | b3 & 63;
+      min = 2048;
+    } else if (b2 < 248) {
+      if (i2 + 2 >= buf.length) {
+        out += fatal ? (() => {
+          throw new TypeError("incomplete utf-8");
+        })() : "\uFFFD";
+        break;
+      }
+      const b22 = buf[i2++];
+      const b3 = buf[i2++];
+      const b4 = buf[i2++];
+      if ((b22 & 192) !== 128 || (b3 & 192) !== 128 || (b4 & 192) !== 128) {
+        out += "\uFFFD";
+        continue;
+      }
+      c2 = (b2 & 7) << 18 | (b22 & 63) << 12 | (b3 & 63) << 6 | b4 & 63;
+      min = 65536;
+    } else {
+      out += fatal ? (() => {
+        throw new TypeError("invalid utf-8 start");
+      })() : "\uFFFD";
+      continue;
+    }
+    if (c2 < min || c2 >= 55296 && c2 <= 57343 || c2 > 1114111) {
+      out += fatal ? (() => {
+        throw new TypeError("invalid utf-8 codepoint");
+      })() : "\uFFFD";
+      continue;
+    }
+    if (c2 <= 65535)
+      out += String.fromCharCode(c2);
+    else {
+      c2 -= 65536;
+      out += String.fromCharCode(55296 | c2 >> 10, 56320 | c2 & 1023);
+    }
+  }
+  return out;
+}
+function _decodeUTF16(buf, le2, fatal) {
+  const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  let out = "";
+  for (let i2 = 0; i2 + 1 < buf.length; i2 += 2) {
+    let c2 = dv.getUint16(i2, le2);
+    if (c2 >= 55296 && c2 <= 56319) {
+      i2 += 2;
+      if (i2 + 1 >= buf.length) {
+        out += fatal ? (() => {
+          throw new TypeError("truncated surrogate pair");
+        })() : "\uFFFD";
+        break;
+      }
+      const c22 = dv.getUint16(i2, le2);
+      if (c22 >= 56320 && c22 <= 57343) {
+        out += String.fromCharCode(c2, c22);
+      } else {
+        out += fatal ? (() => {
+          throw new TypeError("invalid surrogate pair");
+        })() : "\uFFFD";
+        i2 -= 2;
+      }
+    } else if (c2 >= 56320 && c2 <= 57343) {
+      out += fatal ? (() => {
+        throw new TypeError("unexpected trailing surrogate");
+      })() : "\uFFFD";
+    } else {
+      out += String.fromCharCode(c2);
+    }
+  }
+  return out;
+}
+var TextDecoderImpl = class {
+  _encoding;
+  _fatal;
+  _ignoreBOM;
+  constructor(label, options) {
+    this._encoding = _normalizeLabel(label);
+    this._fatal = options?.fatal ?? false;
+    this._ignoreBOM = options?.ignoreBOM ?? false;
+  }
+  get encoding() {
+    return this._encoding;
+  }
+  get fatal() {
+    return this._fatal;
+  }
+  get ignoreBOM() {
+    return this._ignoreBOM;
+  }
+  decode(buffer) {
+    if (!buffer)
+      return "";
+    const arr = buffer instanceof Uint8Array ? buffer : buffer instanceof ArrayBuffer ? new Uint8Array(buffer) : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    if (this._encoding === "utf-8") {
+      return _decodeUTF8(arr, this._fatal);
+    }
+    const le2 = this._encoding === "utf-16le";
     let offset = 0;
-    for (const c of chunks) {
-        out.set(c, offset);
-        offset += c.length;
-    }
-    return new TextDecoder().decode(out);
-}
-const server = createServer(async (req) => {
-    if (req.method === 'POST' && new URL(req.url).pathname === '/exec') {
-        const body = await req.json();
-        const file = std.popen(body.cmd, 'r');
-        if (!file)
-            return new Response('popen failed', { status: 500 });
-        const output = readAll(file);
-        file.close();
-        return new Response(output, {
-            headers: { 'Content-Type': 'application/octet-stream' }
+    if (arr.length >= 2 && !this._ignoreBOM) {
+      const bomLo = le2 ? arr[0] : arr[1];
+      const bomHi = le2 ? arr[1] : arr[0];
+      const bom = bomHi << 8 | bomLo;
+      if (bom === 65279 || bom === 65534) {
+        offset = 2;
+      }
+    }
+    return _decodeUTF16(arr.slice(offset), le2, this._fatal);
+  }
+};
+var TextEncoderImpl = class {
+  _encoding;
+  constructor(label) {
+    this._encoding = _normalizeLabel(label);
+  }
+  get encoding() {
+    return this._encoding;
+  }
+  encode(input) {
+    if (!input)
+      return new Uint8Array(0);
+    if (this._encoding === "utf-8") {
+      const bytes = [];
+      for (let i2 = 0; i2 < input.length; i2++) {
+        let c2 = input.charCodeAt(i2);
+        if (c2 < 128) {
+          bytes.push(c2);
+        } else if (c2 < 2048) {
+          bytes.push(192 | c2 >> 6, 128 | c2 & 63);
+        } else if (c2 < 55296 || c2 >= 57344) {
+          bytes.push(224 | c2 >> 12, 128 | c2 >> 6 & 63, 128 | c2 & 63);
+        } else {
+          i2++;
+          const c22 = input.charCodeAt(i2);
+          c2 = 65536 + ((c2 & 1023) << 10) | c22 & 1023;
+          bytes.push(240 | c2 >> 18, 128 | c2 >> 12 & 63, 128 | c2 >> 6 & 63, 128 | c2 & 63);
+        }
+      }
+      return new Uint8Array(bytes);
+    }
+    const le2 = this._encoding === "utf-16le";
+    const buf = new ArrayBuffer(input.length * 2);
+    const dv = new DataView(buf);
+    for (let i2 = 0; i2 < input.length; i2++)
+      dv.setUint16(i2 * 2, input.charCodeAt(i2), le2);
+    return new Uint8Array(buf);
+  }
+};
+if (typeof globalThis.TextDecoder === "undefined") {
+  globalThis.TextDecoder = TextDecoderImpl;
+}
+if (typeof globalThis.TextEncoder === "undefined") {
+  globalThis.TextEncoder = TextEncoderImpl;
+}
+
+// _build/lib/polyfill.js
+if (typeof globalThis.window === "undefined")
+  globalThis.window = globalThis;
+if (typeof globalThis.setTimeout === "undefined") {
+  globalThis.setTimeout = ((fn, ms, ...args) => {
+    return os.setTimeout(() => fn(...args), ms ?? 0);
+  });
+}
+if (typeof globalThis.clearTimeout === "undefined") {
+  globalThis.clearTimeout = os.clearTimeout;
+}
+if (typeof console.error === "undefined") {
+  console.error = (...args) => {
+    console.log(...args);
+  };
+}
+function sha1Bytes(bytes) {
+  const len = bytes.length;
+  const ml = len * 8;
+  bytes.push(128);
+  while (bytes.length % 64 !== 56) {
+    bytes.push(0);
+  }
+  bytes.push(0);
+  bytes.push(0);
+  bytes.push(0);
+  bytes.push(0);
+  bytes.push(ml >>> 24 & 255);
+  bytes.push(ml >>> 16 & 255);
+  bytes.push(ml >>> 8 & 255);
+  bytes.push(ml & 255);
+  let h0 = 1732584193, h1 = 4023233417;
+  let h2 = 2562383102, h3 = 271733878, h4 = 3285377520;
+  const rotl = (x2, n2) => (x2 << n2 | x2 >>> 32 - n2) >>> 0;
+  for (let i2 = 0; i2 < bytes.length; i2 += 64) {
+    const w2 = [];
+    for (let t2 = 0; t2 < 16; t2++) {
+      w2[t2] = bytes[i2 + 4 * t2] << 24 | bytes[i2 + 4 * t2 + 1] << 16 | bytes[i2 + 4 * t2 + 2] << 8 | bytes[i2 + 4 * t2 + 3];
+    }
+    for (let t2 = 16; t2 < 80; t2++) {
+      w2[t2] = rotl(w2[t2 - 3] ^ w2[t2 - 8] ^ w2[t2 - 14] ^ w2[t2 - 16], 1);
+    }
+    let a2 = h0, b2 = h1, c2 = h2, d2 = h3, e2 = h4;
+    for (let t2 = 0; t2 < 80; t2++) {
+      let f2, k2;
+      if (t2 < 20) {
+        f2 = b2 & c2 | ~b2 & d2;
+        k2 = 1518500249;
+      } else if (t2 < 40) {
+        f2 = b2 ^ c2 ^ d2;
+        k2 = 1859775393;
+      } else if (t2 < 60) {
+        f2 = b2 & c2 | b2 & d2 | c2 & d2;
+        k2 = 2400959708;
+      } else {
+        f2 = b2 ^ c2 ^ d2;
+        k2 = 3395469782;
+      }
+      const temp = rotl(a2, 5) + f2 + e2 + k2 + w2[t2] >>> 0;
+      e2 = d2;
+      d2 = c2;
+      c2 = rotl(b2, 30);
+      b2 = a2;
+      a2 = temp;
+    }
+    h0 = h0 + a2 >>> 0;
+    h1 = h1 + b2 >>> 0;
+    h2 = h2 + c2 >>> 0;
+    h3 = h3 + d2 >>> 0;
+    h4 = h4 + e2 >>> 0;
+  }
+  const result = new Uint8Array(20);
+  const w32 = (off, v2) => {
+    result[off] = v2 >>> 24 & 255;
+    result[off + 1] = v2 >>> 16 & 255;
+    result[off + 2] = v2 >>> 8 & 255;
+    result[off + 3] = v2 & 255;
+  };
+  w32(0, h0);
+  w32(4, h1);
+  w32(8, h2);
+  w32(12, h3);
+  w32(16, h4);
+  return result.buffer;
+}
+var B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function b64Encode(data) {
+  let r2 = "";
+  for (let i2 = 0; i2 < data.length; i2 += 3) {
+    const b0 = data[i2], b1 = i2 + 1 < data.length ? data[i2 + 1] : 0, b2 = i2 + 2 < data.length ? data[i2 + 2] : 0;
+    r2 += B64[b0 >> 2] + B64[(b0 & 3) << 4 | b1 >> 4];
+    r2 += i2 + 1 < data.length ? B64[(b1 & 15) << 2 | b2 >> 6] : "=";
+    r2 += i2 + 2 < data.length ? B64[b2 & 63] : "=";
+  }
+  return r2;
+}
+function b64Decode(str) {
+  str = str.replace(/[^A-Za-z0-9+/=]/g, "");
+  const bytes = [];
+  for (let i2 = 0; i2 < str.length; i2 += 4) {
+    const c0 = B64.indexOf(str[i2]), c1 = B64.indexOf(str[i2 + 1]);
+    const c2 = B64.indexOf(str[i2 + 2]), c3 = B64.indexOf(str[i2 + 3]);
+    bytes.push(c0 << 2 | c1 >> 4);
+    if (c2 >= 0)
+      bytes.push((c1 & 15) << 4 | c2 >> 2);
+    if (c3 >= 0)
+      bytes.push((c2 & 3) << 6 | c3);
+  }
+  return new Uint8Array(bytes);
+}
+if (typeof globalThis.btoa === "undefined") {
+  globalThis.btoa = (data) => {
+    const bytes = new Uint8Array(data.length);
+    for (let i2 = 0; i2 < data.length; i2++)
+      bytes[i2] = data.charCodeAt(i2) & 255;
+    return b64Encode(bytes);
+  };
+}
+if (typeof globalThis.atob === "undefined") {
+  globalThis.atob = (data) => {
+    const bytes = b64Decode(data);
+    let r2 = "";
+    for (let i2 = 0; i2 < bytes.length; i2++)
+      r2 += String.fromCharCode(bytes[i2]);
+    return r2;
+  };
+}
+if (typeof globalThis.crypto === "undefined") {
+  globalThis.crypto = {
+    getRandomValues: (array) => {
+      const view = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+      for (let i2 = 0; i2 < view.length; i2++)
+        view[i2] = Math.random() * 256 | 0;
+      return array;
+    },
+    subtle: {
+      digest: (algorithm, data) => {
+        if (algorithm.toUpperCase() !== "SHA-1")
+          return Promise.reject(new Error("Digest: " + algorithm + " not supported"));
+        const bytes = data instanceof Uint8Array ? Array.from(data) : Array.from(new Uint8Array(data));
+        return Promise.resolve(sha1Bytes(bytes));
+      }
+    }
+  };
+}
+
+// _build/lib/http-server.js
+import * as sock from "sock";
+
+// _build/lib/vendor/web-streams/ponyfill.mjs
+function e() {
+}
+function t(e2) {
+  return "object" == typeof e2 && null !== e2 || "function" == typeof e2;
+}
+var r = e;
+function o(e2, t2) {
+  try {
+    Object.defineProperty(e2, "name", { value: t2, configurable: true });
+  } catch (e3) {
+  }
+}
+var n = Promise;
+var i = Promise.resolve.bind(n);
+var a = Promise.prototype.then;
+var s = Promise.reject.bind(n);
+var l = i;
+function u(e2) {
+  return new n(e2);
+}
+function c(e2) {
+  return u((t2) => t2(e2));
+}
+function d(e2) {
+  return s(e2);
+}
+function f(e2, t2, r2) {
+  return a.call(e2, t2, r2);
+}
+function h(e2, t2, o2) {
+  f(f(e2, t2, o2), void 0, r);
+}
+function b(e2, t2) {
+  h(e2, t2);
+}
+function _(e2, t2) {
+  h(e2, void 0, t2);
+}
+function m(e2, t2, r2) {
+  return f(e2, t2, r2);
+}
+function p(e2) {
+  f(e2, void 0, r);
+}
+var y = (e2) => {
+  if ("function" == typeof queueMicrotask) y = queueMicrotask;
+  else {
+    const e3 = c(void 0);
+    y = (t2) => f(e3, t2);
+  }
+  return y(e2);
+};
+function S(e2, t2, r2) {
+  if ("function" != typeof e2) throw new TypeError("Argument is not a function");
+  return Function.prototype.apply.call(e2, t2, r2);
+}
+function g(e2, t2, r2) {
+  try {
+    return c(S(e2, t2, r2));
+  } catch (e3) {
+    return d(e3);
+  }
+}
+var v = class {
+  constructor() {
+    this._cursor = 0, this._size = 0, this._front = { _elements: [], _next: void 0 }, this._back = this._front, this._cursor = 0, this._size = 0;
+  }
+  get length() {
+    return this._size;
+  }
+  push(e2) {
+    const t2 = this._back;
+    let r2 = t2;
+    16383 === t2._elements.length && (r2 = { _elements: [], _next: void 0 }), t2._elements.push(e2), r2 !== t2 && (this._back = r2, t2._next = r2), ++this._size;
+  }
+  shift() {
+    const e2 = this._front;
+    let t2 = e2;
+    const r2 = this._cursor;
+    let o2 = r2 + 1;
+    const n2 = e2._elements, i2 = n2[r2];
+    return 16384 === o2 && (t2 = e2._next, o2 = 0), --this._size, this._cursor = o2, e2 !== t2 && (this._front = t2), n2[r2] = void 0, i2;
+  }
+  forEach(e2) {
+    let t2 = this._cursor, r2 = this._front, o2 = r2._elements;
+    for (; !(t2 === o2.length && void 0 === r2._next || t2 === o2.length && (r2 = r2._next, o2 = r2._elements, t2 = 0, 0 === o2.length)); ) e2(o2[t2]), ++t2;
+  }
+  peek() {
+    const e2 = this._front, t2 = this._cursor;
+    return e2._elements[t2];
+  }
+};
+var w = /* @__PURE__ */ Symbol("[[AbortSteps]]");
+var R = /* @__PURE__ */ Symbol("[[ErrorSteps]]");
+var T = /* @__PURE__ */ Symbol("[[CancelSteps]]");
+var P = /* @__PURE__ */ Symbol("[[PullSteps]]");
+var C = /* @__PURE__ */ Symbol("[[CanPullSyncSteps]]");
+var q = /* @__PURE__ */ Symbol("[[ReleaseSteps]]");
+function E(e2, t2) {
+  e2._ownerReadableStream = t2, t2._reader = e2, "readable" === t2._state ? j(e2) : "closed" === t2._state ? (function(e3) {
+    j(e3), z(e3);
+  })(e2) : k(e2, t2._storedError);
+}
+function W(e2, t2) {
+  return Mr(e2._ownerReadableStream, t2);
+}
+function O(e2) {
+  const t2 = e2._ownerReadableStream;
+  "readable" === t2._state ? A(e2, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")) : (function(e3, t3) {
+    k(e3, t3);
+  })(e2, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")), t2._readableStreamController[q](), t2._reader = void 0, e2._ownerReadableStream = void 0;
+}
+function B(e2) {
+  return new TypeError("Cannot " + e2 + " a stream using a released reader");
+}
+function j(e2) {
+  e2._closedPromise = u((t2, r2) => {
+    e2._closedPromise_resolve = t2, e2._closedPromise_reject = r2;
+  });
+}
+function k(e2, t2) {
+  j(e2), A(e2, t2);
+}
+function A(e2, t2) {
+  void 0 !== e2._closedPromise_reject && (p(e2._closedPromise), e2._closedPromise_reject(t2), e2._closedPromise_resolve = void 0, e2._closedPromise_reject = void 0);
+}
+function z(e2) {
+  void 0 !== e2._closedPromise_resolve && (e2._closedPromise_resolve(void 0), e2._closedPromise_resolve = void 0, e2._closedPromise_reject = void 0);
+}
+var D = Number.isFinite || function(e2) {
+  return "number" == typeof e2 && isFinite(e2);
+};
+var F = Math.trunc || function(e2) {
+  return e2 < 0 ? Math.ceil(e2) : Math.floor(e2);
+};
+function L(e2, t2) {
+  if (void 0 !== e2 && ("object" != typeof (r2 = e2) && "function" != typeof r2)) throw new TypeError(`${t2} is not an object.`);
+  var r2;
+}
+function I(e2, t2) {
+  if ("function" != typeof e2) throw new TypeError(`${t2} is not a function.`);
+}
+function $(e2, t2) {
+  if (!/* @__PURE__ */ (function(e3) {
+    return "object" == typeof e3 && null !== e3 || "function" == typeof e3;
+  })(e2)) throw new TypeError(`${t2} is not an object.`);
+}
+function M(e2, t2, r2) {
+  if (void 0 === e2) throw new TypeError(`Parameter ${t2} is required in '${r2}'.`);
+}
+function Y(e2, t2, r2) {
+  if (void 0 === e2) throw new TypeError(`${t2} is required in '${r2}'.`);
+}
+function x(e2) {
+  return Number(e2);
+}
+function Q(e2) {
+  return 0 === e2 ? 0 : e2;
+}
+function N(e2, t2) {
+  const r2 = Number.MAX_SAFE_INTEGER;
+  let o2 = Number(e2);
+  if (o2 = Q(o2), !D(o2)) throw new TypeError(`${t2} is not a finite number`);
+  if (o2 = (function(e3) {
+    return Q(F(e3));
+  })(o2), o2 < 0 || o2 > r2) throw new TypeError(`${t2} is outside the accepted range of 0 to ${r2}, inclusive`);
+  return D(o2) && 0 !== o2 ? o2 : 0;
+}
+function H(e2, t2) {
+  if (!Ir(e2)) throw new TypeError(`${t2} is not a ReadableStream.`);
+}
+function V(e2) {
+  return new ReadableStreamDefaultReader(e2);
+}
+function U(e2, t2) {
+  e2._reader._readRequests.push(t2);
+}
+function G(e2, t2, r2) {
+  const o2 = e2._reader._readRequests.shift();
+  r2 ? o2._closeSteps() : o2._chunkSteps(t2);
+}
+function X(e2) {
+  return e2._reader._readRequests.length;
+}
+function J(e2) {
+  const t2 = e2._reader;
+  return void 0 !== t2 && !!ee(t2);
+}
+var ReadableStreamDefaultReader = class {
+  constructor(e2) {
+    if (M(e2, 1, "ReadableStreamDefaultReader"), H(e2, "First parameter"), $r(e2)) throw new TypeError("This stream has already been locked for exclusive reading by another reader");
+    E(this, e2), this._readRequests = new v();
+  }
+  get closed() {
+    return ee(this) ? this._closedPromise : d(ne("closed"));
+  }
+  cancel(e2 = void 0) {
+    return ee(this) ? void 0 === this._ownerReadableStream ? d(B("cancel")) : W(this, e2) : d(ne("cancel"));
+  }
+  read() {
+    if (!ee(this)) return d(ne("read"));
+    if (void 0 === this._ownerReadableStream) return d(B("read from"));
+    const e2 = re(this) ? new Z() : new K();
+    return te(this, e2), e2._promise;
+  }
+  releaseLock() {
+    if (!ee(this)) throw ne("releaseLock");
+    void 0 !== this._ownerReadableStream && (function(e2) {
+      O(e2);
+      const t2 = new TypeError("Reader was released");
+      oe(e2, t2);
+    })(this);
+  }
+};
+Object.defineProperties(ReadableStreamDefaultReader.prototype, { cancel: { enumerable: true }, read: { enumerable: true }, releaseLock: { enumerable: true }, closed: { enumerable: true } }), o(ReadableStreamDefaultReader.prototype.cancel, "cancel"), o(ReadableStreamDefaultReader.prototype.read, "read"), o(ReadableStreamDefaultReader.prototype.releaseLock, "releaseLock"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(ReadableStreamDefaultReader.prototype, Symbol.toStringTag, { value: "ReadableStreamDefaultReader", configurable: true });
+var K = class {
+  constructor() {
+    this._promise = u((e2, t2) => {
+      this._resolvePromise = e2, this._rejectPromise = t2;
+    });
+  }
+  _chunkSteps(e2) {
+    this._resolvePromise({ value: e2, done: false });
+  }
+  _closeSteps() {
+    this._resolvePromise({ value: void 0, done: true });
+  }
+  _errorSteps(e2) {
+    this._rejectPromise(e2);
+  }
+};
+var Z = class {
+  constructor() {
+    this._promise = void 0;
+  }
+  _chunkSteps(e2) {
+    this._promise = l({ value: e2, done: false });
+  }
+  _closeSteps() {
+    this._promise = l({ value: void 0, done: true });
+  }
+  _errorSteps(e2) {
+    this._promise = d(e2);
+  }
+};
+function ee(e2) {
+  return !!t(e2) && (!!Object.prototype.hasOwnProperty.call(e2, "_readRequests") && e2 instanceof ReadableStreamDefaultReader);
+}
+function te(e2, t2) {
+  const r2 = e2._ownerReadableStream;
+  r2._disturbed = true, "closed" === r2._state ? t2._closeSteps() : "errored" === r2._state ? t2._errorSteps(r2._storedError) : r2._readableStreamController[P](t2);
+}
+function re(e2) {
+  const t2 = e2._ownerReadableStream;
+  return "closed" === t2._state || ("errored" === t2._state || t2._readableStreamController[C]());
+}
+function oe(e2, t2) {
+  const r2 = e2._readRequests;
+  e2._readRequests = new v(), r2.forEach((e3) => {
+    e3._errorSteps(t2);
+  });
+}
+function ne(e2) {
+  return new TypeError(`ReadableStreamDefaultReader.prototype.${e2} can only be used on a ReadableStreamDefaultReader`);
+}
+var ie;
+var ae;
+var se;
+function le(e2) {
+  return e2.slice();
+}
+function ue(e2, t2, r2, o2, n2) {
+  new Uint8Array(e2).set(new Uint8Array(r2, o2, n2), t2);
+}
+var ce = (e2) => (ce = "function" == typeof e2.transfer ? (e3) => e3.transfer() : "function" == typeof structuredClone ? (e3) => structuredClone(e3, { transfer: [e3] }) : (e3) => e3, ce(e2));
+var de = (e2) => (de = "boolean" == typeof e2.detached ? (e3) => e3.detached : (e3) => 0 === e3.byteLength, de(e2));
+function fe(e2, t2, r2) {
+  if (e2.slice) return e2.slice(t2, r2);
+  const o2 = r2 - t2, n2 = new ArrayBuffer(o2);
+  return ue(n2, 0, e2, t2, o2), n2;
+}
+function he(e2, t2) {
+  const r2 = e2[t2];
+  if (null != r2) {
+    if ("function" != typeof r2) throw new TypeError(`${String(t2)} is not a function`);
+    return r2;
+  }
+}
+function be(e2) {
+  try {
+    const t2 = e2.done, r2 = e2.value;
+    return f(l(r2), (e3) => ({ done: t2, value: e3 }));
+  } catch (e3) {
+    return d(e3);
+  }
+}
+var _e = null !== (se = null !== (ie = Symbol.asyncIterator) && void 0 !== ie ? ie : null === (ae = Symbol.for) || void 0 === ae ? void 0 : ae.call(Symbol, "Symbol.asyncIterator")) && void 0 !== se ? se : "@@asyncIterator";
+function me(e2, r2 = "sync", o2) {
+  if (void 0 === o2) if ("async" === r2) {
+    if (void 0 === (o2 = he(e2, _e))) {
+      return (function(e3) {
+        const r3 = { next() {
+          let t2;
+          try {
+            t2 = pe(e3);
+          } catch (e4) {
+            return d(e4);
+          }
+          return be(t2);
+        }, return(r4) {
+          let o3;
+          try {
+            const t2 = he(e3.iterator, "return");
+            if (void 0 === t2) return c({ done: true, value: r4 });
+            o3 = S(t2, e3.iterator, [r4]);
+          } catch (e4) {
+            return d(e4);
+          }
+          return t(o3) ? be(o3) : d(new TypeError("The iterator.return() method must return an object"));
+        } };
+        return { iterator: r3, nextMethod: r3.next, done: false };
+      })(me(e2, "sync", he(e2, Symbol.iterator)));
+    }
+  } else o2 = he(e2, Symbol.iterator);
+  if (void 0 === o2) throw new TypeError("The object is not iterable");
+  const n2 = S(o2, e2, []);
+  if (!t(n2)) throw new TypeError("The iterator method must return an object");
+  return { iterator: n2, nextMethod: n2.next, done: false };
+}
+function pe(e2) {
+  const r2 = S(e2.nextMethod, e2.iterator, []);
+  if (!t(r2)) throw new TypeError("The iterator.next() method must return an object");
+  return r2;
+}
+var ye = class {
+  constructor(e2, t2) {
+    this._ongoingPromise = void 0, this._isFinished = false, this._reader = e2, this._preventCancel = t2;
+  }
+  next() {
+    const e2 = () => this._nextSteps();
+    return this._ongoingPromise = this._ongoingPromise ? m(this._ongoingPromise, e2, e2) : e2(), this._ongoingPromise;
+  }
+  return(e2) {
+    const t2 = () => this._returnSteps(e2);
+    return this._ongoingPromise = this._ongoingPromise ? m(this._ongoingPromise, t2, t2) : t2(), this._ongoingPromise;
+  }
+  _nextSteps() {
+    if (this._isFinished) return Promise.resolve({ value: void 0, done: true });
+    const e2 = this._reader, t2 = new Se(this);
+    return te(e2, t2), t2._promise;
+  }
+  _returnSteps(e2) {
+    if (this._isFinished) return Promise.resolve({ value: e2, done: true });
+    this._isFinished = true;
+    const t2 = this._reader;
+    if (!this._preventCancel) {
+      const r2 = W(t2, e2);
+      return O(t2), m(r2, () => ({ value: e2, done: true }));
+    }
+    return O(t2), c({ value: e2, done: true });
+  }
+};
+var Se = class {
+  constructor(e2) {
+    this._iterator = e2, this._promise = u((e3, t2) => {
+      this._resolvePromise = e3, this._rejectPromise = t2;
+    });
+  }
+  _chunkSteps(e2) {
+    this._iterator._ongoingPromise = void 0, y(() => this._resolvePromise({ value: e2, done: false }));
+  }
+  _closeSteps() {
+    const e2 = this._iterator;
+    e2._ongoingPromise = void 0, e2._isFinished = true, O(e2._reader), this._resolvePromise({ value: void 0, done: true });
+  }
+  _errorSteps(e2) {
+    const t2 = this._iterator;
+    t2._ongoingPromise = void 0, t2._isFinished = true, O(t2._reader), this._rejectPromise(e2);
+  }
+};
+var ge = { next() {
+  return ve(this) ? this._asyncIteratorImpl.next() : d(we("next"));
+}, return(e2) {
+  return ve(this) ? this._asyncIteratorImpl.return(e2) : d(we("return"));
+}, [_e]() {
+  return this;
+} };
+function ve(e2) {
+  if (!t(e2)) return false;
+  if (!Object.prototype.hasOwnProperty.call(e2, "_asyncIteratorImpl")) return false;
+  try {
+    return e2._asyncIteratorImpl instanceof ye;
+  } catch (e3) {
+    return false;
+  }
+}
+function we(e2) {
+  return new TypeError(`ReadableStreamAsyncIterator.${e2} can only be used on a ReadableSteamAsyncIterator`);
+}
+Object.defineProperty(ge, _e, { enumerable: false });
+var Re = Number.isNaN || function(e2) {
+  return e2 != e2;
+};
+function Te(e2) {
+  const t2 = fe(e2.buffer, e2.byteOffset, e2.byteOffset + e2.byteLength);
+  return new Uint8Array(t2);
+}
+function Pe(e2) {
+  const t2 = e2._queue.shift();
+  return e2._queueTotalSize -= t2.size, e2._queueTotalSize < 0 && (e2._queueTotalSize = 0), t2.value;
+}
+function Ce(e2, t2, r2) {
+  if ("number" != typeof (o2 = r2) || Re(o2) || o2 < 0 || r2 === 1 / 0) throw new RangeError("Size must be a finite, non-NaN, non-negative number.");
+  var o2;
+  e2._queue.push({ value: t2, size: r2 }), e2._queueTotalSize += r2;
+}
+function qe(e2) {
+  e2._queue = new v(), e2._queueTotalSize = 0;
+}
+function Ee(e2) {
+  return e2 === DataView;
+}
+function We(e2) {
+  return Ee(e2) ? 1 : e2.BYTES_PER_ELEMENT;
+}
+var ReadableStreamBYOBRequest = class {
+  constructor() {
+    throw new TypeError("Illegal constructor");
+  }
+  get view() {
+    if (!Be(this)) throw ot("view");
+    return this._view;
+  }
+  respond(e2) {
+    if (!Be(this)) throw ot("respond");
+    if (M(e2, 1, "respond"), e2 = N(e2, "First parameter"), void 0 === this._associatedReadableByteStreamController) throw new TypeError("This BYOB request has been invalidated");
+    if (de(this._view.buffer)) throw new TypeError("The BYOB request's buffer has been detached and so cannot be used as a response");
+    et(this._associatedReadableByteStreamController, e2);
+  }
+  respondWithNewView(e2) {
+    if (!Be(this)) throw ot("respondWithNewView");
+    if (M(e2, 1, "respondWithNewView"), !ArrayBuffer.isView(e2)) throw new TypeError("You can only respond with array buffer views");
+    if (void 0 === this._associatedReadableByteStreamController) throw new TypeError("This BYOB request has been invalidated");
+    if (de(e2.buffer)) throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");
+    tt(this._associatedReadableByteStreamController, e2);
+  }
+};
+Object.defineProperties(ReadableStreamBYOBRequest.prototype, { respond: { enumerable: true }, respondWithNewView: { enumerable: true }, view: { enumerable: true } }), o(ReadableStreamBYOBRequest.prototype.respond, "respond"), o(ReadableStreamBYOBRequest.prototype.respondWithNewView, "respondWithNewView"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(ReadableStreamBYOBRequest.prototype, Symbol.toStringTag, { value: "ReadableStreamBYOBRequest", configurable: true });
+var ReadableByteStreamController = class {
+  constructor() {
+    throw new TypeError("Illegal constructor");
+  }
+  get byobRequest() {
+    if (!Oe(this)) throw nt("byobRequest");
+    return Ke(this);
+  }
+  get desiredSize() {
+    if (!Oe(this)) throw nt("desiredSize");
+    return Ze(this);
+  }
+  close() {
+    if (!Oe(this)) throw nt("close");
+    if (this._closeRequested) throw new TypeError("The stream has already been closed; do not close it again!");
+    const e2 = this._controlledReadableByteStream._state;
+    if ("readable" !== e2) throw new TypeError(`The stream (in ${e2} state) is not in the readable state and cannot be closed`);
+    Ue(this);
+  }
+  enqueue(e2) {
+    if (!Oe(this)) throw nt("enqueue");
+    if (M(e2, 1, "enqueue"), !ArrayBuffer.isView(e2)) throw new TypeError("chunk must be an array buffer view");
+    if (0 === e2.byteLength) throw new TypeError("chunk must have non-zero byteLength");
+    if (0 === e2.buffer.byteLength) throw new TypeError("chunk's buffer must have non-zero byteLength");
+    if (this._closeRequested) throw new TypeError("stream is closed or draining");
+    const t2 = this._controlledReadableByteStream._state;
+    if ("readable" !== t2) throw new TypeError(`The stream (in ${t2} state) is not in the readable state and cannot be enqueued to`);
+    Ge(this, e2);
+  }
+  error(e2 = void 0) {
+    if (!Oe(this)) throw nt("error");
+    Xe(this, e2);
+  }
+  [T](e2) {
+    ke(this), qe(this);
+    const t2 = this._cancelAlgorithm(e2);
+    return Ve(this), t2;
+  }
+  [P](e2) {
+    const t2 = this._controlledReadableByteStream;
+    if (this._queueTotalSize > 0) return void Je(this, e2);
+    const r2 = this._autoAllocateChunkSize;
+    if (void 0 !== r2) {
+      let t3;
+      try {
+        t3 = new ArrayBuffer(r2);
+      } catch (t4) {
+        return void e2._errorSteps(t4);
+      }
+      const o2 = { buffer: t3, bufferByteLength: r2, byteOffset: 0, byteLength: r2, bytesFilled: 0, minimumFill: 1, elementSize: 1, viewConstructor: Uint8Array, readerType: "default" };
+      this._pendingPullIntos.push(o2);
+    }
+    U(t2, e2), je(this);
+  }
+  [C]() {
+    return this._queueTotalSize > 0;
+  }
+  [q]() {
+    if (this._pendingPullIntos.length > 0) {
+      const e2 = this._pendingPullIntos.peek();
+      e2.readerType = "none", this._pendingPullIntos = new v(), this._pendingPullIntos.push(e2);
+    }
+  }
+};
+function Oe(e2) {
+  return !!t(e2) && (!!Object.prototype.hasOwnProperty.call(e2, "_controlledReadableByteStream") && e2 instanceof ReadableByteStreamController);
+}
+function Be(e2) {
+  return !!t(e2) && (!!Object.prototype.hasOwnProperty.call(e2, "_associatedReadableByteStreamController") && e2 instanceof ReadableStreamBYOBRequest);
+}
+function je(e2) {
+  const t2 = (function(e3) {
+    const t3 = e3._controlledReadableByteStream;
+    if ("readable" !== t3._state) return false;
+    if (e3._closeRequested) return false;
+    if (!e3._started) return false;
+    if (J(t3) && X(t3) > 0) return true;
+    if (ut(t3) && lt(t3) > 0) return true;
+    const r2 = Ze(e3);
+    if (r2 > 0) return true;
+    return false;
+  })(e2);
+  if (!t2) return;
+  if (e2._pulling) return void (e2._pullAgain = true);
+  e2._pulling = true;
+  h(e2._pullAlgorithm(), () => (e2._pulling = false, e2._pullAgain && (e2._pullAgain = false, je(e2)), null), (t3) => (Xe(e2, t3), null));
+}
+function ke(e2) {
+  xe(e2), e2._pendingPullIntos = new v();
+}
+function Ae(e2, t2) {
+  let r2 = false;
+  "closed" === e2._state && (r2 = true);
+  const o2 = De(t2);
+  "default" === t2.readerType ? G(e2, o2, r2) : (function(e3, t3, r3) {
+    const o3 = e3._reader, n2 = o3._readIntoRequests.shift();
+    r3 ? n2._closeSteps(t3) : n2._chunkSteps(t3);
+  })(e2, o2, r2);
+}
+function ze(e2, t2) {
+  for (let r2 = 0; r2 < t2.length; ++r2) Ae(e2, t2[r2]);
+}
+function De(e2) {
+  const t2 = e2.bytesFilled, r2 = e2.elementSize;
+  return new e2.viewConstructor(e2.buffer, e2.byteOffset, t2 / r2);
+}
+function Fe(e2, t2, r2, o2) {
+  e2._queue.push({ buffer: t2, byteOffset: r2, byteLength: o2 }), e2._queueTotalSize += o2;
+}
+function Le(e2, t2, r2, o2) {
+  let n2;
+  try {
+    n2 = fe(t2, r2, r2 + o2);
+  } catch (t3) {
+    throw Xe(e2, t3), t3;
+  }
+  Fe(e2, n2, 0, o2);
+}
+function Ie(e2, t2) {
+  t2.bytesFilled > 0 && Le(e2, t2.buffer, t2.byteOffset, t2.bytesFilled), He(e2);
+}
+function $e(e2, t2) {
+  const r2 = Math.min(e2._queueTotalSize, t2.byteLength - t2.bytesFilled), o2 = t2.bytesFilled + r2;
+  let n2 = r2, i2 = false;
+  const a2 = o2 - o2 % t2.elementSize;
+  a2 >= t2.minimumFill && (n2 = a2 - t2.bytesFilled, i2 = true);
+  const s2 = e2._queue;
+  for (; n2 > 0; ) {
+    const r3 = s2.peek(), o3 = Math.min(n2, r3.byteLength), i3 = t2.byteOffset + t2.bytesFilled;
+    ue(t2.buffer, i3, r3.buffer, r3.byteOffset, o3), r3.byteLength === o3 ? s2.shift() : (r3.byteOffset += o3, r3.byteLength -= o3), e2._queueTotalSize -= o3, Me(e2, o3, t2), n2 -= o3;
+  }
+  return i2;
+}
+function Me(e2, t2, r2) {
+  r2.bytesFilled += t2;
+}
+function Ye(e2) {
+  0 === e2._queueTotalSize && e2._closeRequested ? (Ve(e2), Yr(e2._controlledReadableByteStream)) : je(e2);
+}
+function xe(e2) {
+  null !== e2._byobRequest && (e2._byobRequest._associatedReadableByteStreamController = void 0, e2._byobRequest._view = null, e2._byobRequest = null);
+}
+function Qe(e2) {
+  const t2 = [];
+  for (; e2._pendingPullIntos.length > 0 && 0 !== e2._queueTotalSize; ) {
+    const r2 = e2._pendingPullIntos.peek();
+    $e(e2, r2) && (He(e2), t2.push(r2));
+  }
+  return t2;
+}
+function Ne(e2, t2) {
+  const r2 = e2._pendingPullIntos.peek();
+  xe(e2);
+  "closed" === e2._controlledReadableByteStream._state ? (function(e3, t3) {
+    "none" === t3.readerType && He(e3);
+    const r3 = e3._controlledReadableByteStream;
+    if (ut(r3)) {
+      const t4 = [];
+      for (; t4.length < lt(r3); ) t4.push(He(e3));
+      ze(r3, t4);
+    }
+  })(e2, r2) : (function(e3, t3, r3) {
+    if (Me(0, t3, r3), "none" === r3.readerType) {
+      Ie(e3, r3);
+      const t4 = Qe(e3);
+      return void ze(e3._controlledReadableByteStream, t4);
+    }
+    if (r3.bytesFilled < r3.minimumFill) return;
+    He(e3);
+    const o2 = r3.bytesFilled % r3.elementSize;
+    if (o2 > 0) {
+      const t4 = r3.byteOffset + r3.bytesFilled;
+      Le(e3, r3.buffer, t4 - o2, o2);
+    }
+    r3.bytesFilled -= o2;
+    const n2 = Qe(e3);
+    Ae(e3._controlledReadableByteStream, r3), ze(e3._controlledReadableByteStream, n2);
+  })(e2, t2, r2), je(e2);
+}
+function He(e2) {
+  return e2._pendingPullIntos.shift();
+}
+function Ve(e2) {
+  e2._pullAlgorithm = void 0, e2._cancelAlgorithm = void 0;
+}
+function Ue(e2) {
+  const t2 = e2._controlledReadableByteStream;
+  if (!e2._closeRequested && "readable" === t2._state) if (e2._queueTotalSize > 0) e2._closeRequested = true;
+  else {
+    if (e2._pendingPullIntos.length > 0) {
+      const t3 = e2._pendingPullIntos.peek();
+      if (t3.bytesFilled % t3.elementSize !== 0) {
+        const t4 = new TypeError("Insufficient bytes to fill elements in the given buffer");
+        throw Xe(e2, t4), t4;
+      }
+    }
+    Ve(e2), Yr(t2);
+  }
+}
+function Ge(e2, t2) {
+  const r2 = e2._controlledReadableByteStream;
+  if (e2._closeRequested || "readable" !== r2._state) return;
+  const { buffer: o2, byteOffset: n2, byteLength: i2 } = t2;
+  if (de(o2)) throw new TypeError("chunk's buffer is detached and so cannot be enqueued");
+  const a2 = ce(o2);
+  if (e2._pendingPullIntos.length > 0) {
+    const t3 = e2._pendingPullIntos.peek();
+    if (de(t3.buffer)) throw new TypeError("The BYOB request's buffer has been detached and so cannot be filled with an enqueued chunk");
+    xe(e2), t3.buffer = ce(t3.buffer), "none" === t3.readerType && Ie(e2, t3);
+  }
+  if (J(r2)) if ((function(e3) {
+    const t3 = e3._controlledReadableByteStream._reader;
+    for (; t3._readRequests.length > 0; ) {
+      if (0 === e3._queueTotalSize) return;
+      Je(e3, t3._readRequests.shift());
+    }
+  })(e2), 0 === X(r2)) Fe(e2, a2, n2, i2);
+  else {
+    e2._pendingPullIntos.length > 0 && He(e2);
+    G(r2, new Uint8Array(a2, n2, i2), false);
+  }
+  else if (ut(r2)) {
+    Fe(e2, a2, n2, i2);
+    ze(r2, Qe(e2));
+  } else Fe(e2, a2, n2, i2);
+  je(e2);
+}
+function Xe(e2, t2) {
+  const r2 = e2._controlledReadableByteStream;
+  "readable" === r2._state && (ke(e2), qe(e2), Ve(e2), xr(r2, t2));
+}
+function Je(e2, t2) {
+  const r2 = e2._queue.shift();
+  e2._queueTotalSize -= r2.byteLength, Ye(e2);
+  const o2 = new Uint8Array(r2.buffer, r2.byteOffset, r2.byteLength);
+  t2._chunkSteps(o2);
+}
+function Ke(e2) {
+  if (null === e2._byobRequest && e2._pendingPullIntos.length > 0) {
+    const t2 = e2._pendingPullIntos.peek(), r2 = new Uint8Array(t2.buffer, t2.byteOffset + t2.bytesFilled, t2.byteLength - t2.bytesFilled), o2 = Object.create(ReadableStreamBYOBRequest.prototype);
+    !(function(e3, t3, r3) {
+      e3._associatedReadableByteStreamController = t3, e3._view = r3;
+    })(o2, e2, r2), e2._byobRequest = o2;
+  }
+  return e2._byobRequest;
+}
+function Ze(e2) {
+  const t2 = e2._controlledReadableByteStream._state;
+  return "errored" === t2 ? null : "closed" === t2 ? 0 : e2._strategyHWM - e2._queueTotalSize;
+}
+function et(e2, t2) {
+  const r2 = e2._pendingPullIntos.peek();
+  if ("closed" === e2._controlledReadableByteStream._state) {
+    if (0 !== t2) throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream");
+  } else {
+    if (0 === t2) throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");
+    if (r2.bytesFilled + t2 > r2.byteLength) throw new RangeError("bytesWritten out of range");
+  }
+  r2.buffer = ce(r2.buffer), Ne(e2, t2);
+}
+function tt(e2, t2) {
+  const r2 = e2._pendingPullIntos.peek();
+  if ("closed" === e2._controlledReadableByteStream._state) {
+    if (0 !== t2.byteLength) throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream");
+  } else if (0 === t2.byteLength) throw new TypeError("The view's length must be greater than 0 when calling respondWithNewView() on a readable stream");
+  if (r2.byteOffset + r2.bytesFilled !== t2.byteOffset) throw new RangeError("The region specified by view does not match byobRequest");
+  if (r2.bufferByteLength !== t2.buffer.byteLength) throw new RangeError("The buffer of view has different capacity than byobRequest");
+  if (r2.bytesFilled + t2.byteLength > r2.byteLength) throw new RangeError("The region specified by view is larger than byobRequest");
+  const o2 = t2.byteLength;
+  r2.buffer = ce(t2.buffer), Ne(e2, o2);
+}
+function rt(e2, t2, r2, o2, n2, i2, a2) {
+  t2._controlledReadableByteStream = e2, t2._pullAgain = false, t2._pulling = false, t2._byobRequest = null, t2._queue = t2._queueTotalSize = void 0, qe(t2), t2._closeRequested = false, t2._started = false, t2._strategyHWM = i2, t2._pullAlgorithm = o2, t2._cancelAlgorithm = n2, t2._autoAllocateChunkSize = a2, t2._pendingPullIntos = new v(), e2._readableStreamController = t2;
+  h(c(r2()), () => (t2._started = true, je(t2), null), (e3) => (Xe(t2, e3), null));
+}
+function ot(e2) {
+  return new TypeError(`ReadableStreamBYOBRequest.prototype.${e2} can only be used on a ReadableStreamBYOBRequest`);
+}
+function nt(e2) {
+  return new TypeError(`ReadableByteStreamController.prototype.${e2} can only be used on a ReadableByteStreamController`);
+}
+function it(e2, t2) {
+  if ("byob" !== (e2 = `${e2}`)) throw new TypeError(`${t2} '${e2}' is not a valid enumeration value for ReadableStreamReaderMode`);
+  return e2;
+}
+function at(e2) {
+  return new ReadableStreamBYOBReader(e2);
+}
+function st(e2, t2) {
+  e2._reader._readIntoRequests.push(t2);
+}
+function lt(e2) {
+  return e2._reader._readIntoRequests.length;
+}
+function ut(e2) {
+  const t2 = e2._reader;
+  return void 0 !== t2 && !!ft(t2);
+}
+Object.defineProperties(ReadableByteStreamController.prototype, { close: { enumerable: true }, enqueue: { enumerable: true }, error: { enumerable: true }, byobRequest: { enumerable: true }, desiredSize: { enumerable: true } }), o(ReadableByteStreamController.prototype.close, "close"), o(ReadableByteStreamController.prototype.enqueue, "enqueue"), o(ReadableByteStreamController.prototype.error, "error"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(ReadableByteStreamController.prototype, Symbol.toStringTag, { value: "ReadableByteStreamController", configurable: true });
+var ReadableStreamBYOBReader = class {
+  constructor(e2) {
+    if (M(e2, 1, "ReadableStreamBYOBReader"), H(e2, "First parameter"), $r(e2)) throw new TypeError("This stream has already been locked for exclusive reading by another reader");
+    if (!Oe(e2._readableStreamController)) throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");
+    E(this, e2), this._readIntoRequests = new v();
+  }
+  get closed() {
+    return ft(this) ? this._closedPromise : d(_t("closed"));
+  }
+  cancel(e2 = void 0) {
+    return ft(this) ? void 0 === this._ownerReadableStream ? d(B("cancel")) : W(this, e2) : d(_t("cancel"));
+  }
+  read(e2, t2 = {}) {
+    if (!ft(this)) return d(_t("read"));
+    if (!ArrayBuffer.isView(e2)) return d(new TypeError("view must be an array buffer view"));
+    if (0 === e2.byteLength) return d(new TypeError("view must have non-zero byteLength"));
+    if (0 === e2.buffer.byteLength) return d(new TypeError("view's buffer must have non-zero byteLength"));
+    if (de(e2.buffer)) return d(new TypeError("view's buffer has been detached"));
+    let r2;
+    try {
+      r2 = (function(e3, t3) {
+        var r3;
+        return L(e3, t3), { min: N(null !== (r3 = null == e3 ? void 0 : e3.min) && void 0 !== r3 ? r3 : 1, `${t3} has member 'min' that`) };
+      })(t2, "options");
+    } catch (e3) {
+      return d(e3);
+    }
+    const o2 = r2.min;
+    if (0 === o2) return d(new TypeError("options.min must be greater than 0"));
+    if ((function(e3) {
+      return Ee(e3.constructor);
+    })(e2)) {
+      if (o2 > e2.byteLength) return d(new RangeError("options.min must be less than or equal to view's byteLength"));
+    } else if (o2 > e2.length) return d(new RangeError("options.min must be less than or equal to view's length"));
+    if (void 0 === this._ownerReadableStream) return d(B("read from"));
+    const n2 = (function(e3, t3, r3) {
+      const o3 = e3._ownerReadableStream;
+      return "errored" === o3._state || (function(e4, t4, r4) {
+        const o4 = e4._controlledReadableByteStream, n3 = We(t4.constructor), { byteLength: i2 } = t4, a2 = r4 * n3;
+        return !(e4._pendingPullIntos.length > 0) && ("closed" === o4._state || e4._queueTotalSize >= a2);
+      })(o3._readableStreamController, t3, r3);
+    })(this, e2, o2) ? new dt() : new ct();
+    return ht(this, e2, o2, n2), n2._promise;
+  }
+  releaseLock() {
+    if (!ft(this)) throw _t("releaseLock");
+    void 0 !== this._ownerReadableStream && (function(e2) {
+      O(e2);
+      const t2 = new TypeError("Reader was released");
+      bt(e2, t2);
+    })(this);
+  }
+};
+Object.defineProperties(ReadableStreamBYOBReader.prototype, { cancel: { enumerable: true }, read: { enumerable: true }, releaseLock: { enumerable: true }, closed: { enumerable: true } }), o(ReadableStreamBYOBReader.prototype.cancel, "cancel"), o(ReadableStreamBYOBReader.prototype.read, "read"), o(ReadableStreamBYOBReader.prototype.releaseLock, "releaseLock"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(ReadableStreamBYOBReader.prototype, Symbol.toStringTag, { value: "ReadableStreamBYOBReader", configurable: true });
+var ct = class {
+  constructor() {
+    this._promise = u((e2, t2) => {
+      this._resolvePromise = e2, this._rejectPromise = t2;
+    });
+  }
+  _chunkSteps(e2) {
+    this._resolvePromise({ value: e2, done: false });
+  }
+  _closeSteps(e2) {
+    this._resolvePromise({ value: e2, done: true });
+  }
+  _errorSteps(e2) {
+    this._rejectPromise(e2);
+  }
+};
+var dt = class {
+  constructor() {
+    this._promise = void 0;
+  }
+  _chunkSteps(e2) {
+    this._promise = l({ value: e2, done: false });
+  }
+  _closeSteps(e2) {
+    this._promise = l({ value: e2, done: true });
+  }
+  _errorSteps(e2) {
+    this._promise = d(e2);
+  }
+};
+function ft(e2) {
+  return !!t(e2) && (!!Object.prototype.hasOwnProperty.call(e2, "_readIntoRequests") && e2 instanceof ReadableStreamBYOBReader);
+}
+function ht(e2, t2, r2, o2) {
+  const n2 = e2._ownerReadableStream;
+  n2._disturbed = true, "errored" === n2._state ? o2._errorSteps(n2._storedError) : (function(e3, t3, r3, o3) {
+    const n3 = e3._controlledReadableByteStream, i2 = t3.constructor, a2 = We(i2), { byteOffset: s2, byteLength: l2 } = t3, u2 = r3 * a2;
+    let c2;
+    try {
+      c2 = ce(t3.buffer);
+    } catch (e4) {
+      return void o3._errorSteps(e4);
+    }
+    const d2 = { buffer: c2, bufferByteLength: c2.byteLength, byteOffset: s2, byteLength: l2, bytesFilled: 0, minimumFill: u2, elementSize: a2, viewConstructor: i2, readerType: "byob" };
+    if (e3._pendingPullIntos.length > 0) return e3._pendingPullIntos.push(d2), void st(n3, o3);
+    if ("closed" === n3._state) {
+      const e4 = new i2(d2.buffer, d2.byteOffset, 0);
+      return void o3._closeSteps(e4);
+    }
+    if (e3._queueTotalSize > 0) {
+      if ($e(e3, d2)) {
+        const t4 = De(d2);
+        return Ye(e3), void o3._chunkSteps(t4);
+      }
+      if (e3._closeRequested) {
+        const t4 = new TypeError("Insufficient bytes to fill elements in the given buffer");
+        return Xe(e3, t4), void o3._errorSteps(t4);
+      }
+    }
+    e3._pendingPullIntos.push(d2), st(n3, o3), je(e3);
+  })(n2._readableStreamController, t2, r2, o2);
+}
+function bt(e2, t2) {
+  const r2 = e2._readIntoRequests;
+  e2._readIntoRequests = new v(), r2.forEach((e3) => {
+    e3._errorSteps(t2);
+  });
+}
+function _t(e2) {
+  return new TypeError(`ReadableStreamBYOBReader.prototype.${e2} can only be used on a ReadableStreamBYOBReader`);
+}
+function mt(e2, t2) {
+  const { highWaterMark: r2 } = e2;
+  if (void 0 === r2) return t2;
+  if (Re(r2) || r2 < 0) throw new RangeError("Invalid highWaterMark");
+  return r2;
+}
+function pt(e2) {
+  const { size: t2 } = e2;
+  return t2 || (() => 1);
+}
+function yt(e2, t2) {
+  L(e2, t2);
+  const r2 = null == e2 ? void 0 : e2.highWaterMark, o2 = null == e2 ? void 0 : e2.size;
+  return { highWaterMark: void 0 === r2 ? void 0 : x(r2), size: void 0 === o2 ? void 0 : St(o2, `${t2} has member 'size' that`) };
+}
+function St(e2, t2) {
+  return I(e2, t2), (t3) => x(e2(t3));
+}
+function gt(e2, t2, r2) {
+  return I(e2, r2), (r3) => g(e2, t2, [r3]);
+}
+function vt(e2, t2, r2) {
+  return I(e2, r2), () => g(e2, t2, []);
+}
+function wt(e2, t2, r2) {
+  return I(e2, r2), (r3) => S(e2, t2, [r3]);
+}
+function Rt(e2, t2, r2) {
+  return I(e2, r2), (r3, o2) => g(e2, t2, [r3, o2]);
+}
+function Tt(e2, t2) {
+  if (!qt(e2)) throw new TypeError(`${t2} is not a WritableStream.`);
+}
+var WritableStream = class {
+  constructor(e2 = {}, t2 = {}) {
+    void 0 === e2 ? e2 = null : $(e2, "First parameter");
+    const r2 = yt(t2, "Second parameter"), o2 = (function(e3, t3) {
+      L(e3, t3);
+      const r3 = null == e3 ? void 0 : e3.abort, o3 = null == e3 ? void 0 : e3.close, n3 = null == e3 ? void 0 : e3.start, i2 = null == e3 ? void 0 : e3.type, a2 = null == e3 ? void 0 : e3.write;
+      return { abort: void 0 === r3 ? void 0 : gt(r3, e3, `${t3} has member 'abort' that`), close: void 0 === o3 ? void 0 : vt(o3, e3, `${t3} has member 'close' that`), start: void 0 === n3 ? void 0 : wt(n3, e3, `${t3} has member 'start' that`), write: void 0 === a2 ? void 0 : Rt(a2, e3, `${t3} has member 'write' that`), type: i2 };
+    })(e2, "First parameter");
+    Ct(this);
+    if (void 0 !== o2.type) throw new RangeError("Invalid type is specified");
+    const n2 = pt(r2);
+    !(function(e3, t3, r3, o3) {
+      const n3 = Object.create(WritableStreamDefaultController.prototype);
+      let i2, a2, s2, l2;
+      i2 = void 0 !== t3.start ? () => t3.start(n3) : () => {
+      };
+      a2 = void 0 !== t3.write ? (e4) => t3.write(e4, n3) : () => c(void 0);
+      s2 = void 0 !== t3.close ? () => t3.close() : () => c(void 0);
+      l2 = void 0 !== t3.abort ? (e4) => t3.abort(e4) : () => c(void 0);
+      Nt(e3, n3, i2, a2, s2, l2, r3, o3);
+    })(this, o2, mt(r2, 1), n2);
+  }
+  get locked() {
+    if (!qt(this)) throw Kt("locked");
+    return Et(this);
+  }
+  abort(e2 = void 0) {
+    return qt(this) ? Et(this) ? d(new TypeError("Cannot abort a stream that already has a writer")) : Wt(this, e2) : d(Kt("abort"));
+  }
+  close() {
+    return qt(this) ? Et(this) ? d(new TypeError("Cannot close a stream that already has a writer")) : At(this) ? d(new TypeError("Cannot close an already-closing stream")) : Ot(this) : d(Kt("close"));
+  }
+  getWriter() {
+    if (!qt(this)) throw Kt("getWriter");
+    return Pt(this);
+  }
+};
+function Pt(e2) {
+  return new WritableStreamDefaultWriter(e2);
+}
+function Ct(e2) {
+  e2._state = "writable", e2._storedError = void 0, e2._writer = void 0, e2._writableStreamController = void 0, e2._writeRequests = new v(), e2._inFlightWriteRequest = void 0, e2._closeRequest = void 0, e2._inFlightCloseRequest = void 0, e2._pendingAbortRequest = void 0, e2._backpressure = false;
+}
+function qt(e2) {
+  return !!t(e2) && (!!Object.prototype.hasOwnProperty.call(e2, "_writableStreamController") && e2 instanceof WritableStream);
+}
+function Et(e2) {
+  return void 0 !== e2._writer;
+}
+function Wt(e2, t2) {
+  var r2;
+  if ("closed" === e2._state || "errored" === e2._state) return c(void 0);
+  e2._writableStreamController._abortReason = t2, null === (r2 = e2._writableStreamController._abortController) || void 0 === r2 || r2.abort(t2);
+  const o2 = e2._state;
+  if ("closed" === o2 || "errored" === o2) return c(void 0);
+  if (void 0 !== e2._pendingAbortRequest) return e2._pendingAbortRequest._promise;
+  let n2 = false;
+  "erroring" === o2 && (n2 = true, t2 = void 0);
+  const i2 = u((r3, o3) => {
+    e2._pendingAbortRequest = { _promise: void 0, _resolve: r3, _reject: o3, _reason: t2, _wasAlreadyErroring: n2 };
+  });
+  return e2._pendingAbortRequest._promise = i2, n2 || jt(e2, t2), i2;
+}
+function Ot(e2) {
+  const t2 = e2._state;
+  if ("closed" === t2 || "errored" === t2) return d(new TypeError(`The stream (in ${t2} state) is not in the writable state and cannot be closed`));
+  const r2 = u((t3, r3) => {
+    const o3 = { _resolve: t3, _reject: r3 };
+    e2._closeRequest = o3;
+  }), o2 = e2._writer;
+  var n2;
+  return void 0 !== o2 && e2._backpressure && "writable" === t2 && cr(o2), Ce(n2 = e2._writableStreamController, xt, 0), Ut(n2), r2;
+}
+function Bt(e2, t2) {
+  "writable" !== e2._state ? kt(e2) : jt(e2, t2);
+}
+function jt(e2, t2) {
+  const r2 = e2._writableStreamController;
+  e2._state = "erroring", e2._storedError = t2;
+  const o2 = e2._writer;
+  void 0 !== o2 && $t(o2, t2), !(function(e3) {
+    if (void 0 === e3._inFlightWriteRequest && void 0 === e3._inFlightCloseRequest) return false;
+    return true;
+  })(e2) && r2._started && kt(e2);
+}
+function kt(e2) {
+  e2._state = "errored", e2._writableStreamController[R]();
+  const t2 = e2._storedError;
+  if (e2._writeRequests.forEach((e3) => {
+    e3._reject(t2);
+  }), e2._writeRequests = new v(), void 0 === e2._pendingAbortRequest) return void zt(e2);
+  const r2 = e2._pendingAbortRequest;
+  if (e2._pendingAbortRequest = void 0, r2._wasAlreadyErroring) return r2._reject(t2), void zt(e2);
+  h(e2._writableStreamController[w](r2._reason), () => (r2._resolve(), zt(e2), null), (t3) => (r2._reject(t3), zt(e2), null));
+}
+function At(e2) {
+  return void 0 !== e2._closeRequest || void 0 !== e2._inFlightCloseRequest;
+}
+function zt(e2) {
+  void 0 !== e2._closeRequest && (e2._closeRequest._reject(e2._storedError), e2._closeRequest = void 0);
+  const t2 = e2._writer;
+  void 0 !== t2 && nr(t2, e2._storedError);
+}
+function Dt(e2, t2) {
+  const r2 = e2._writer;
+  void 0 !== r2 && t2 !== e2._backpressure && (t2 ? (function(e3) {
+    ar(e3);
+  })(r2) : cr(r2)), e2._backpressure = t2;
+}
+Object.defineProperties(WritableStream.prototype, { abort: { enumerable: true }, close: { enumerable: true }, getWriter: { enumerable: true }, locked: { enumerable: true } }), o(WritableStream.prototype.abort, "abort"), o(WritableStream.prototype.close, "close"), o(WritableStream.prototype.getWriter, "getWriter"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(WritableStream.prototype, Symbol.toStringTag, { value: "WritableStream", configurable: true });
+var WritableStreamDefaultWriter = class {
+  constructor(e2) {
+    if (M(e2, 1, "WritableStreamDefaultWriter"), Tt(e2, "First parameter"), Et(e2)) throw new TypeError("This stream has already been locked for exclusive writing by another writer");
+    this._ownerWritableStream = e2, e2._writer = this;
+    const t2 = e2._state;
+    if ("writable" === t2) !At(e2) && e2._backpressure ? ar(this) : lr(this), rr(this);
+    else if ("erroring" === t2) sr(this, e2._storedError), rr(this);
+    else if ("closed" === t2) lr(this), rr(r2 = this), ir(r2);
+    else {
+      const t3 = e2._storedError;
+      sr(this, t3), or(this, t3);
+    }
+    var r2;
+  }
+  get closed() {
+    return Ft(this) ? this._closedPromise : d(er("closed"));
+  }
+  get desiredSize() {
+    if (!Ft(this)) throw er("desiredSize");
+    if (void 0 === this._ownerWritableStream) throw tr("desiredSize");
+    return (function(e2) {
+      const t2 = e2._ownerWritableStream, r2 = t2._state;
+      if ("errored" === r2 || "erroring" === r2) return null;
+      if ("closed" === r2) return 0;
+      return Vt(t2._writableStreamController);
+    })(this);
+  }
+  get ready() {
+    return Ft(this) ? this._readyPromise : d(er("ready"));
+  }
+  abort(e2 = void 0) {
+    return Ft(this) ? void 0 === this._ownerWritableStream ? d(tr("abort")) : (function(e3, t2) {
+      return Wt(e3._ownerWritableStream, t2);
+    })(this, e2) : d(er("abort"));
+  }
+  close() {
+    if (!Ft(this)) return d(er("close"));
+    const e2 = this._ownerWritableStream;
+    return void 0 === e2 ? d(tr("close")) : At(e2) ? d(new TypeError("Cannot close an already-closing stream")) : Lt(this);
+  }
+  releaseLock() {
+    if (!Ft(this)) throw er("releaseLock");
+    void 0 !== this._ownerWritableStream && Mt(this);
+  }
+  write(e2 = void 0) {
+    return Ft(this) ? void 0 === this._ownerWritableStream ? d(tr("write to")) : Yt(this, e2) : d(er("write"));
+  }
+};
+function Ft(e2) {
+  return !!t(e2) && (!!Object.prototype.hasOwnProperty.call(e2, "_ownerWritableStream") && e2 instanceof WritableStreamDefaultWriter);
+}
+function Lt(e2) {
+  return Ot(e2._ownerWritableStream);
+}
+function It(e2, t2) {
+  "pending" === e2._closedPromiseState ? nr(e2, t2) : (function(e3, t3) {
+    or(e3, t3);
+  })(e2, t2);
+}
+function $t(e2, t2) {
+  "pending" === e2._readyPromiseState ? ur(e2, t2) : (function(e3, t3) {
+    sr(e3, t3);
+  })(e2, t2);
+}
+function Mt(e2) {
+  const t2 = e2._ownerWritableStream, r2 = new TypeError("Writer was released and can no longer be used to monitor the stream's closedness");
+  $t(e2, r2), It(e2, r2), t2._writer = void 0, e2._ownerWritableStream = void 0;
+}
+function Yt(e2, t2) {
+  const r2 = e2._ownerWritableStream, o2 = r2._writableStreamController, n2 = (function(e3, t3) {
+    if (void 0 === e3._strategySizeAlgorithm) return 1;
+    try {
+      return e3._strategySizeAlgorithm(t3);
+    } catch (t4) {
+      return Gt(e3, t4), 1;
+    }
+  })(o2, t2);
+  if (r2 !== e2._ownerWritableStream) return d(tr("write to"));
+  const i2 = r2._state;
+  if ("errored" === i2) return d(r2._storedError);
+  if (At(r2) || "closed" === i2) return d(new TypeError("The stream is closing or closed and cannot be written to"));
+  if ("erroring" === i2) return d(r2._storedError);
+  const a2 = (function(e3) {
+    return u((t3, r3) => {
+      const o3 = { _resolve: t3, _reject: r3 };
+      e3._writeRequests.push(o3);
+    });
+  })(r2);
+  return (function(e3, t3, r3) {
+    try {
+      Ce(e3, t3, r3);
+    } catch (t4) {
+      return void Gt(e3, t4);
+    }
+    const o3 = e3._controlledWritableStream;
+    if (!At(o3) && "writable" === o3._state) {
+      Dt(o3, Xt(e3));
+    }
+    Ut(e3);
+  })(o2, t2, n2), a2;
+}
+Object.defineProperties(WritableStreamDefaultWriter.prototype, { abort: { enumerable: true }, close: { enumerable: true }, releaseLock: { enumerable: true }, write: { enumerable: true }, closed: { enumerable: true }, desiredSize: { enumerable: true }, ready: { enumerable: true } }), o(WritableStreamDefaultWriter.prototype.abort, "abort"), o(WritableStreamDefaultWriter.prototype.close, "close"), o(WritableStreamDefaultWriter.prototype.releaseLock, "releaseLock"), o(WritableStreamDefaultWriter.prototype.write, "write"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(WritableStreamDefaultWriter.prototype, Symbol.toStringTag, { value: "WritableStreamDefaultWriter", configurable: true });
+var xt = {};
+var WritableStreamDefaultController = class {
+  constructor() {
+    throw new TypeError("Illegal constructor");
+  }
+  get abortReason() {
+    if (!Qt(this)) throw Zt("abortReason");
+    return this._abortReason;
+  }
+  get signal() {
+    if (!Qt(this)) throw Zt("signal");
+    if (void 0 === this._abortController) throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported");
+    return this._abortController.signal;
+  }
+  error(e2 = void 0) {
+    if (!Qt(this)) throw Zt("error");
+    "writable" === this._controlledWritableStream._state && Jt(this, e2);
+  }
+  [w](e2) {
+    const t2 = this._abortAlgorithm(e2);
+    return Ht(this), t2;
+  }
+  [R]() {
+    qe(this);
+  }
+};
+function Qt(e2) {
+  return !!t(e2) && (!!Object.prototype.hasOwnProperty.call(e2, "_controlledWritableStream") && e2 instanceof WritableStreamDefaultController);
+}
+function Nt(e2, t2, r2, o2, n2, i2, a2, s2) {
+  t2._controlledWritableStream = e2, e2._writableStreamController = t2, t2._queue = void 0, t2._queueTotalSize = void 0, qe(t2), t2._abortReason = void 0, t2._abortController = (function() {
+    if ("function" == typeof AbortController) return new AbortController();
+  })(), t2._started = false, t2._strategySizeAlgorithm = s2, t2._strategyHWM = a2, t2._writeAlgorithm = o2, t2._closeAlgorithm = n2, t2._abortAlgorithm = i2;
+  const l2 = Xt(t2);
+  Dt(e2, l2);
+  h(c(r2()), () => (t2._started = true, Ut(t2), null), (r3) => (t2._started = true, Bt(e2, r3), null));
+}
+function Ht(e2) {
+  e2._writeAlgorithm = void 0, e2._closeAlgorithm = void 0, e2._abortAlgorithm = void 0, e2._strategySizeAlgorithm = void 0;
+}
+function Vt(e2) {
+  return e2._strategyHWM - e2._queueTotalSize;
+}
+function Ut(e2) {
+  const t2 = e2._controlledWritableStream;
+  if (!e2._started) return;
+  if (void 0 !== t2._inFlightWriteRequest) return;
+  if ("erroring" === t2._state) return void kt(t2);
+  if (0 === e2._queue.length) return;
+  const r2 = e2._queue.peek().value;
+  r2 === xt ? (function(e3) {
+    const t3 = e3._controlledWritableStream;
+    (function(e4) {
+      e4._inFlightCloseRequest = e4._closeRequest, e4._closeRequest = void 0;
+    })(t3), Pe(e3);
+    const r3 = e3._closeAlgorithm();
+    Ht(e3), h(r3, () => ((function(e4) {
+      e4._inFlightCloseRequest._resolve(void 0), e4._inFlightCloseRequest = void 0, "erroring" === e4._state && (e4._storedError = void 0, void 0 !== e4._pendingAbortRequest && (e4._pendingAbortRequest._resolve(), e4._pendingAbortRequest = void 0)), e4._state = "closed";
+      const t4 = e4._writer;
+      void 0 !== t4 && ir(t4);
+    })(t3), null), (e4) => ((function(e5, t4) {
+      e5._inFlightCloseRequest._reject(t4), e5._inFlightCloseRequest = void 0, void 0 !== e5._pendingAbortRequest && (e5._pendingAbortRequest._reject(t4), e5._pendingAbortRequest = void 0), Bt(e5, t4);
+    })(t3, e4), null));
+  })(e2) : (function(e3, t3) {
+    const r3 = e3._controlledWritableStream;
+    !(function(e4) {
+      e4._inFlightWriteRequest = e4._writeRequests.shift();
+    })(r3);
+    const o2 = e3._writeAlgorithm(t3);
+    h(o2, () => {
+      !(function(e4) {
+        e4._inFlightWriteRequest._resolve(void 0), e4._inFlightWriteRequest = void 0;
+      })(r3);
+      const t4 = r3._state;
+      if (Pe(e3), !At(r3) && "writable" === t4) {
+        const t5 = Xt(e3);
+        Dt(r3, t5);
+      }
+      return Ut(e3), null;
+    }, (t4) => ("writable" === r3._state && Ht(e3), (function(e4, t5) {
+      e4._inFlightWriteRequest._reject(t5), e4._inFlightWriteRequest = void 0, Bt(e4, t5);
+    })(r3, t4), null));
+  })(e2, r2);
+}
+function Gt(e2, t2) {
+  "writable" === e2._controlledWritableStream._state && Jt(e2, t2);
+}
+function Xt(e2) {
+  return Vt(e2) <= 0;
+}
+function Jt(e2, t2) {
+  const r2 = e2._controlledWritableStream;
+  Ht(e2), jt(r2, t2);
+}
+function Kt(e2) {
+  return new TypeError(`WritableStream.prototype.${e2} can only be used on a WritableStream`);
+}
+function Zt(e2) {
+  return new TypeError(`WritableStreamDefaultController.prototype.${e2} can only be used on a WritableStreamDefaultController`);
+}
+function er(e2) {
+  return new TypeError(`WritableStreamDefaultWriter.prototype.${e2} can only be used on a WritableStreamDefaultWriter`);
+}
+function tr(e2) {
+  return new TypeError("Cannot " + e2 + " a stream using a released writer");
+}
+function rr(e2) {
+  e2._closedPromise = u((t2, r2) => {
+    e2._closedPromise_resolve = t2, e2._closedPromise_reject = r2, e2._closedPromiseState = "pending";
+  });
+}
+function or(e2, t2) {
+  rr(e2), nr(e2, t2);
+}
+function nr(e2, t2) {
+  void 0 !== e2._closedPromise_reject && (p(e2._closedPromise), e2._closedPromise_reject(t2), e2._closedPromise_resolve = void 0, e2._closedPromise_reject = void 0, e2._closedPromiseState = "rejected");
+}
+function ir(e2) {
+  void 0 !== e2._closedPromise_resolve && (e2._closedPromise_resolve(void 0), e2._closedPromise_resolve = void 0, e2._closedPromise_reject = void 0, e2._closedPromiseState = "resolved");
+}
+function ar(e2) {
+  e2._readyPromise = u((t2, r2) => {
+    e2._readyPromise_resolve = t2, e2._readyPromise_reject = r2;
+  }), e2._readyPromiseState = "pending";
+}
+function sr(e2, t2) {
+  ar(e2), ur(e2, t2);
+}
+function lr(e2) {
+  ar(e2), cr(e2);
+}
+function ur(e2, t2) {
+  void 0 !== e2._readyPromise_reject && (p(e2._readyPromise), e2._readyPromise_reject(t2), e2._readyPromise_resolve = void 0, e2._readyPromise_reject = void 0, e2._readyPromiseState = "rejected");
+}
+function cr(e2) {
+  void 0 !== e2._readyPromise_resolve && (e2._readyPromise_resolve(void 0), e2._readyPromise_resolve = void 0, e2._readyPromise_reject = void 0, e2._readyPromiseState = "fulfilled");
+}
+Object.defineProperties(WritableStreamDefaultController.prototype, { abortReason: { enumerable: true }, signal: { enumerable: true }, error: { enumerable: true } }), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(WritableStreamDefaultController.prototype, Symbol.toStringTag, { value: "WritableStreamDefaultController", configurable: true });
+var dr = "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : "undefined" != typeof global ? global : void 0;
+var fr = (function() {
+  const e2 = null == dr ? void 0 : dr.DOMException;
+  return (function(e3) {
+    if ("function" != typeof e3 && "object" != typeof e3) return false;
+    if ("DOMException" !== e3.name) return false;
+    try {
+      return new e3(), true;
+    } catch (e4) {
+      return false;
+    }
+  })(e2) ? e2 : void 0;
+})() || (function() {
+  const e2 = function(e3, t2) {
+    this.message = e3 || "", this.name = t2 || "Error", Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
+  };
+  return o(e2, "DOMException"), e2.prototype = Object.create(Error.prototype), Object.defineProperty(e2.prototype, "constructor", { value: e2, writable: true, configurable: true }), e2;
+})();
+function hr(e2, t2, r2, o2, n2, i2) {
+  const a2 = V(e2), s2 = Pt(t2);
+  e2._disturbed = true;
+  const l2 = new br(s2), _2 = new mr(l2);
+  return u((m2, y2) => {
+    let S2;
+    if (void 0 !== i2) {
+      if (S2 = () => {
+        const r3 = void 0 !== i2.reason ? i2.reason : new fr("Aborted", "AbortError"), a3 = [];
+        o2 || a3.push(() => "writable" === t2._state ? Wt(t2, r3) : c(void 0)), n2 || a3.push(() => "readable" === e2._state ? Mr(e2, r3) : c(void 0)), T2(() => Promise.all(a3.map((e3) => e3())), true, r3);
+      }, i2.aborted) return void S2();
+      i2.addEventListener("abort", S2);
+    }
+    function g2() {
+      for (; !l2._shuttingDown && !t2._backpressure && "writable" === t2._state && !At(t2) && "readable" === e2._state && re(a2); ) te(a2, _2);
+      if (l2._shuttingDown) return c(true);
+      if (t2._backpressure) return f(s2._readyPromise, g2);
+      const r3 = new _r(l2);
+      return te(a2, r3), r3._promise;
+    }
+    var v2, w2, R2;
+    if (pr(e2, a2._closedPromise, (e3) => (o2 ? P2(true, e3) : T2(() => Wt(t2, e3), true, e3), null)), pr(t2, s2._closedPromise, (t3) => (n2 ? P2(true, t3) : T2(() => Mr(e2, t3), true, t3), null)), v2 = e2, w2 = a2._closedPromise, R2 = () => (r2 ? P2() : T2(() => (function(e3) {
+      const t3 = e3._ownerWritableStream, r3 = t3._state;
+      return At(t3) || "closed" === r3 ? c(void 0) : "errored" === r3 ? d(t3._storedError) : Lt(e3);
+    })(s2)), null), "closed" === v2._state ? R2() : b(w2, R2), At(t2) || "closed" === t2._state) {
+      const t3 = new TypeError("the destination writable stream closed before all data could be piped to it");
+      n2 ? P2(true, t3) : T2(() => Mr(e2, t3), true, t3);
+    }
+    function T2(e3, r3, o3) {
+      function n3() {
+        return h(e3(), () => C2(r3, o3), (e4) => C2(true, e4)), null;
+      }
+      l2._shuttingDown || (l2._shuttingDown = true, "writable" !== t2._state || At(t2) ? n3() : b(l2._waitForWritesToFinish(), n3));
+    }
+    function P2(e3, r3) {
+      l2._shuttingDown || (l2._shuttingDown = true, "writable" !== t2._state || At(t2) ? C2(e3, r3) : b(l2._waitForWritesToFinish(), () => C2(e3, r3)));
+    }
+    function C2(e3, t3) {
+      return Mt(s2), O(a2), void 0 !== i2 && i2.removeEventListener("abort", S2), e3 ? y2(t3) : m2(void 0), null;
+    }
+    p(u((e3, t3) => {
+      !(function r3(o3) {
+        o3 ? e3() : f(g2(), r3, t3);
+      })(false);
+    }));
+  });
+}
+var br = class {
+  constructor(e2) {
+    this._writer = e2, this._shuttingDown = false, this._currentWrite = c(void 0);
+  }
+  _waitForWritesToFinish() {
+    const e2 = this._currentWrite;
+    return f(this._currentWrite, () => e2 !== this._currentWrite ? this._waitForWritesToFinish() : void 0);
+  }
+};
+var _r = class {
+  constructor(e2) {
+    this._state = e2, this._promise = u((e3, t2) => {
+      this._resolvePromise = e3, this._rejectPromise = t2;
+    });
+  }
+  _chunkSteps(t2) {
+    this._state._currentWrite = f(Yt(this._state._writer, t2), void 0, e), this._resolvePromise(false);
+  }
+  _closeSteps() {
+    this._resolvePromise(true);
+  }
+  _errorSteps(e2) {
+    this._rejectPromise(e2);
+  }
+};
+var mr = class {
+  constructor(e2) {
+    this._state = e2;
+  }
+  _chunkSteps(t2) {
+    this._state._currentWrite = f(Yt(this._state._writer, t2), void 0, e);
+  }
+  _closeSteps() {
+  }
+  _errorSteps(e2) {
+  }
+};
+function pr(e2, t2, r2) {
+  "errored" === e2._state ? r2(e2._storedError) : _(t2, r2);
+}
+var ReadableStreamDefaultController = class {
+  constructor() {
+    throw new TypeError("Illegal constructor");
+  }
+  get desiredSize() {
+    if (!yr(this)) throw Er("desiredSize");
+    return Pr(this);
+  }
+  close() {
+    if (!yr(this)) throw Er("close");
+    if (!Cr(this)) throw new TypeError("The stream is not in a state that permits close");
+    wr(this);
+  }
+  enqueue(e2 = void 0) {
+    if (!yr(this)) throw Er("enqueue");
+    if (!Cr(this)) throw new TypeError("The stream is not in a state that permits enqueue");
+    return Rr(this, e2);
+  }
+  error(e2 = void 0) {
+    if (!yr(this)) throw Er("error");
+    Tr(this, e2);
+  }
+  [T](e2) {
+    qe(this);
+    const t2 = this._cancelAlgorithm(e2);
+    return vr(this), t2;
+  }
+  [P](e2) {
+    const t2 = this._controlledReadableStream;
+    if (this._queue.length > 0) {
+      const r2 = Pe(this);
+      this._closeRequested && 0 === this._queue.length ? (vr(this), Yr(t2)) : Sr(this), e2._chunkSteps(r2);
+    } else U(t2, e2), Sr(this);
+  }
+  [C]() {
+    return this._queue.length > 0;
+  }
+  [q]() {
+  }
+};
+function yr(e2) {
+  return !!t(e2) && (!!Object.prototype.hasOwnProperty.call(e2, "_controlledReadableStream") && e2 instanceof ReadableStreamDefaultController);
+}
+function Sr(e2) {
+  if (!gr(e2)) return;
+  if (e2._pulling) return void (e2._pullAgain = true);
+  e2._pulling = true;
+  h(e2._pullAlgorithm(), () => (e2._pulling = false, e2._pullAgain && (e2._pullAgain = false, Sr(e2)), null), (t2) => (Tr(e2, t2), null));
+}
+function gr(e2) {
+  const t2 = e2._controlledReadableStream;
+  if (!Cr(e2)) return false;
+  if (!e2._started) return false;
+  if ($r(t2) && X(t2) > 0) return true;
+  return Pr(e2) > 0;
+}
+function vr(e2) {
+  e2._pullAlgorithm = void 0, e2._cancelAlgorithm = void 0, e2._strategySizeAlgorithm = void 0;
+}
+function wr(e2) {
+  if (!Cr(e2)) return;
+  const t2 = e2._controlledReadableStream;
+  e2._closeRequested = true, 0 === e2._queue.length && (vr(e2), Yr(t2));
+}
+function Rr(e2, t2) {
+  if (!Cr(e2)) return;
+  const r2 = e2._controlledReadableStream;
+  if ($r(r2) && X(r2) > 0) G(r2, t2, false);
+  else {
+    let r3;
+    try {
+      r3 = e2._strategySizeAlgorithm(t2);
+    } catch (t3) {
+      throw Tr(e2, t3), t3;
+    }
+    try {
+      Ce(e2, t2, r3);
+    } catch (t3) {
+      throw Tr(e2, t3), t3;
+    }
+  }
+  Sr(e2);
+}
+function Tr(e2, t2) {
+  const r2 = e2._controlledReadableStream;
+  "readable" === r2._state && (qe(e2), vr(e2), xr(r2, t2));
+}
+function Pr(e2) {
+  const t2 = e2._controlledReadableStream._state;
+  return "errored" === t2 ? null : "closed" === t2 ? 0 : e2._strategyHWM - e2._queueTotalSize;
+}
+function Cr(e2) {
+  const t2 = e2._controlledReadableStream._state;
+  return !e2._closeRequested && "readable" === t2;
+}
+function qr(e2, t2, r2, o2, n2, i2, a2) {
+  t2._controlledReadableStream = e2, t2._queue = void 0, t2._queueTotalSize = void 0, qe(t2), t2._started = false, t2._closeRequested = false, t2._pullAgain = false, t2._pulling = false, t2._strategySizeAlgorithm = a2, t2._strategyHWM = i2, t2._pullAlgorithm = o2, t2._cancelAlgorithm = n2, e2._readableStreamController = t2;
+  h(c(r2()), () => (t2._started = true, Sr(t2), null), (e3) => (Tr(t2, e3), null));
+}
+function Er(e2) {
+  return new TypeError(`ReadableStreamDefaultController.prototype.${e2} can only be used on a ReadableStreamDefaultController`);
+}
+function Wr(e2, t2) {
+  return Oe(e2._readableStreamController) ? (function(e3) {
+    let t3, r2, o2, n2, i2, a2 = V(e3), s2 = false, l2 = false, d2 = false, f2 = false, h2 = false;
+    const b2 = u((e4) => {
+      i2 = e4;
+    });
+    function m2(e4) {
+      _(e4._closedPromise, (t4) => (e4 !== a2 || (Xe(o2._readableStreamController, t4), Xe(n2._readableStreamController, t4), f2 && h2 || i2(void 0)), null));
+    }
+    function p2() {
+      ft(a2) && (O(a2), a2 = V(e3), m2(a2));
+      te(a2, { _chunkSteps: (t4) => {
+        y(() => {
+          l2 = false, d2 = false;
+          const r3 = t4;
+          let a3 = t4;
+          if (!f2 && !h2) try {
+            a3 = Te(t4);
+          } catch (t5) {
+            return Xe(o2._readableStreamController, t5), Xe(n2._readableStreamController, t5), void i2(Mr(e3, t5));
+          }
+          f2 || Ge(o2._readableStreamController, r3), h2 || Ge(n2._readableStreamController, a3), s2 = false, l2 ? g2() : d2 && v2();
+        });
+      }, _closeSteps: () => {
+        s2 = false, f2 || Ue(o2._readableStreamController), h2 || Ue(n2._readableStreamController), o2._readableStreamController._pendingPullIntos.length > 0 && et(o2._readableStreamController, 0), n2._readableStreamController._pendingPullIntos.length > 0 && et(n2._readableStreamController, 0), f2 && h2 || i2(void 0);
+      }, _errorSteps: () => {
+        s2 = false;
+      } });
+    }
+    function S2(t4, r3) {
+      ee(a2) && (O(a2), a2 = at(e3), m2(a2));
+      const u2 = r3 ? n2 : o2, c2 = r3 ? o2 : n2;
+      ht(a2, t4, 1, { _chunkSteps: (t5) => {
+        y(() => {
+          l2 = false, d2 = false;
+          const o3 = r3 ? h2 : f2;
+          if (r3 ? f2 : h2) o3 || tt(u2._readableStreamController, t5);
+          else {
+            let r4;
+            try {
+              r4 = Te(t5);
+            } catch (t6) {
+              return Xe(u2._readableStreamController, t6), Xe(c2._readableStreamController, t6), void i2(Mr(e3, t6));
+            }
+            o3 || tt(u2._readableStreamController, t5), Ge(c2._readableStreamController, r4);
+          }
+          s2 = false, l2 ? g2() : d2 && v2();
+        });
+      }, _closeSteps: (e4) => {
+        s2 = false;
+        const t5 = r3 ? h2 : f2, o3 = r3 ? f2 : h2;
+        t5 || Ue(u2._readableStreamController), o3 || Ue(c2._readableStreamController), void 0 !== e4 && (t5 || tt(u2._readableStreamController, e4), !o3 && c2._readableStreamController._pendingPullIntos.length > 0 && et(c2._readableStreamController, 0)), t5 && o3 || i2(void 0);
+      }, _errorSteps: () => {
+        s2 = false;
+      } });
+    }
+    function g2() {
+      if (s2) return l2 = true, c(void 0);
+      s2 = true;
+      const e4 = Ke(o2._readableStreamController);
+      return null === e4 ? p2() : S2(e4._view, false), c(void 0);
+    }
+    function v2() {
+      if (s2) return d2 = true, c(void 0);
+      s2 = true;
+      const e4 = Ke(n2._readableStreamController);
+      return null === e4 ? p2() : S2(e4._view, true), c(void 0);
+    }
+    function w2(o3) {
+      if (f2 = true, t3 = o3, h2) {
+        const o4 = le([t3, r2]), n3 = Mr(e3, o4);
+        i2(n3);
+      }
+      return b2;
+    }
+    function R2(o3) {
+      if (h2 = true, r2 = o3, f2) {
+        const o4 = le([t3, r2]), n3 = Mr(e3, o4);
+        i2(n3);
+      }
+      return b2;
+    }
+    function T2() {
+    }
+    return o2 = Fr(T2, g2, w2), n2 = Fr(T2, v2, R2), m2(a2), [o2, n2];
+  })(e2) : (function(e3) {
+    const t3 = V(e3);
+    let r2, o2, n2, i2, a2, s2 = false, l2 = false, d2 = false, f2 = false;
+    const h2 = u((e4) => {
+      a2 = e4;
+    });
+    function b2() {
+      if (s2) return l2 = true, c(void 0);
+      s2 = true;
+      return te(t3, { _chunkSteps: (e4) => {
+        y(() => {
+          l2 = false;
+          const t4 = e4, r3 = e4;
+          d2 || Rr(n2._readableStreamController, t4), f2 || Rr(i2._readableStreamController, r3), s2 = false, l2 && b2();
+        });
+      }, _closeSteps: () => {
+        s2 = false, d2 || wr(n2._readableStreamController), f2 || wr(i2._readableStreamController), d2 && f2 || a2(void 0);
+      }, _errorSteps: () => {
+        s2 = false;
+      } }), c(void 0);
+    }
+    function m2(t4) {
+      if (d2 = true, r2 = t4, f2) {
+        const t5 = le([r2, o2]), n3 = Mr(e3, t5);
+        a2(n3);
+      }
+      return h2;
+    }
+    function p2(t4) {
+      if (f2 = true, o2 = t4, d2) {
+        const t5 = le([r2, o2]), n3 = Mr(e3, t5);
+        a2(n3);
+      }
+      return h2;
+    }
+    function S2() {
+    }
+    return n2 = Dr(S2, b2, m2), i2 = Dr(S2, b2, p2), _(t3._closedPromise, (e4) => (Tr(n2._readableStreamController, e4), Tr(i2._readableStreamController, e4), d2 && f2 || a2(void 0), null)), [n2, i2];
+  })(e2);
+}
+function Or(r2) {
+  return t(o2 = r2) && void 0 !== o2.getReader ? (function(r3) {
+    let o3;
+    function n2() {
+      let e2;
+      try {
+        e2 = r3.read();
+      } catch (e3) {
+        return d(e3);
+      }
+      return m(e2, (e3) => {
+        if (!t(e3)) throw new TypeError("The promise returned by the reader.read() method must fulfill with an object");
+        if (e3.done) wr(o3._readableStreamController);
+        else {
+          const t2 = e3.value;
+          Rr(o3._readableStreamController, t2);
+        }
+      });
+    }
+    function i2(e2) {
+      try {
+        return c(r3.cancel(e2));
+      } catch (e3) {
+        return d(e3);
+      }
+    }
+    return o3 = Dr(e, n2, i2, 0), o3;
+  })(r2.getReader()) : (function(r3) {
+    let o3;
+    const n2 = me(r3, "async");
+    function i2() {
+      let e2;
+      try {
+        e2 = pe(n2);
+      } catch (e3) {
+        return d(e3);
+      }
+      return m(c(e2), (e3) => {
+        if (!t(e3)) throw new TypeError("The promise returned by the iterator.next() method must fulfill with an object");
+        if (e3.done) wr(o3._readableStreamController);
+        else {
+          const t2 = e3.value;
+          Rr(o3._readableStreamController, t2);
+        }
+      });
+    }
+    function a2(e2) {
+      const r4 = n2.iterator;
+      let o4;
+      try {
+        o4 = he(r4, "return");
+      } catch (e3) {
+        return d(e3);
+      }
+      if (void 0 === o4) return c(void 0);
+      return m(g(o4, r4, [e2]), (e3) => {
+        if (!t(e3)) throw new TypeError("The promise returned by the iterator.return() method must fulfill with an object");
+      });
+    }
+    return o3 = Dr(e, i2, a2, 0), o3;
+  })(r2);
+  var o2;
+}
+function Br(e2, t2, r2) {
+  return I(e2, r2), (r3) => g(e2, t2, [r3]);
+}
+function jr(e2, t2, r2) {
+  return I(e2, r2), (r3) => g(e2, t2, [r3]);
+}
+function kr(e2, t2, r2) {
+  return I(e2, r2), (r3) => S(e2, t2, [r3]);
+}
+function Ar(e2, t2) {
+  if ("bytes" !== (e2 = `${e2}`)) throw new TypeError(`${t2} '${e2}' is not a valid enumeration value for ReadableStreamType`);
+  return e2;
+}
+function zr(e2, t2) {
+  L(e2, t2);
+  const r2 = null == e2 ? void 0 : e2.preventAbort, o2 = null == e2 ? void 0 : e2.preventCancel, n2 = null == e2 ? void 0 : e2.preventClose, i2 = null == e2 ? void 0 : e2.signal;
+  return void 0 !== i2 && (function(e3, t3) {
+    if (!(function(e4) {
+      if ("object" != typeof e4 || null === e4) return false;
+      try {
+        return "boolean" == typeof e4.aborted;
+      } catch (e5) {
+        return false;
+      }
+    })(e3)) throw new TypeError(`${t3} is not an AbortSignal.`);
+  })(i2, `${t2} has member 'signal' that`), { preventAbort: Boolean(r2), preventCancel: Boolean(o2), preventClose: Boolean(n2), signal: i2 };
+}
+Object.defineProperties(ReadableStreamDefaultController.prototype, { close: { enumerable: true }, enqueue: { enumerable: true }, error: { enumerable: true }, desiredSize: { enumerable: true } }), o(ReadableStreamDefaultController.prototype.close, "close"), o(ReadableStreamDefaultController.prototype.enqueue, "enqueue"), o(ReadableStreamDefaultController.prototype.error, "error"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(ReadableStreamDefaultController.prototype, Symbol.toStringTag, { value: "ReadableStreamDefaultController", configurable: true });
+var ReadableStream2 = class {
+  constructor(e2 = {}, t2 = {}) {
+    void 0 === e2 ? e2 = null : $(e2, "First parameter");
+    const r2 = yt(t2, "Second parameter"), o2 = (function(e3, t3) {
+      L(e3, t3);
+      const r3 = e3, o3 = null == r3 ? void 0 : r3.autoAllocateChunkSize, n2 = null == r3 ? void 0 : r3.cancel, i2 = null == r3 ? void 0 : r3.pull, a2 = null == r3 ? void 0 : r3.start, s2 = null == r3 ? void 0 : r3.type;
+      return { autoAllocateChunkSize: void 0 === o3 ? void 0 : N(o3, `${t3} has member 'autoAllocateChunkSize' that`), cancel: void 0 === n2 ? void 0 : Br(n2, r3, `${t3} has member 'cancel' that`), pull: void 0 === i2 ? void 0 : jr(i2, r3, `${t3} has member 'pull' that`), start: void 0 === a2 ? void 0 : kr(a2, r3, `${t3} has member 'start' that`), type: void 0 === s2 ? void 0 : Ar(s2, `${t3} has member 'type' that`) };
+    })(e2, "First parameter");
+    if (Lr(this), "bytes" === o2.type) {
+      if (void 0 !== r2.size) throw new RangeError("The strategy for a byte stream cannot have a size function");
+      !(function(e3, t3, r3) {
+        const o3 = Object.create(ReadableByteStreamController.prototype);
+        let n2, i2, a2;
+        n2 = void 0 !== t3.start ? () => t3.start(o3) : () => {
+        }, i2 = void 0 !== t3.pull ? () => t3.pull(o3) : () => c(void 0), a2 = void 0 !== t3.cancel ? (e4) => t3.cancel(e4) : () => c(void 0);
+        const s2 = t3.autoAllocateChunkSize;
+        if (0 === s2) throw new TypeError("autoAllocateChunkSize must be greater than 0");
+        rt(e3, o3, n2, i2, a2, r3, s2);
+      })(this, o2, mt(r2, 0));
+    } else {
+      const e3 = pt(r2);
+      !(function(e4, t3, r3, o3) {
+        const n2 = Object.create(ReadableStreamDefaultController.prototype);
+        let i2, a2, s2;
+        i2 = void 0 !== t3.start ? () => t3.start(n2) : () => {
+        }, a2 = void 0 !== t3.pull ? () => t3.pull(n2) : () => c(void 0), s2 = void 0 !== t3.cancel ? (e5) => t3.cancel(e5) : () => c(void 0), qr(e4, n2, i2, a2, s2, r3, o3);
+      })(this, o2, mt(r2, 1), e3);
+    }
+  }
+  get locked() {
+    if (!Ir(this)) throw Qr("locked");
+    return $r(this);
+  }
+  cancel(e2 = void 0) {
+    return Ir(this) ? $r(this) ? d(new TypeError("Cannot cancel a stream that already has a reader")) : Mr(this, e2) : d(Qr("cancel"));
+  }
+  getReader(e2 = void 0) {
+    if (!Ir(this)) throw Qr("getReader");
+    return void 0 === (function(e3, t2) {
+      L(e3, t2);
+      const r2 = null == e3 ? void 0 : e3.mode;
+      return { mode: void 0 === r2 ? void 0 : it(r2, `${t2} has member 'mode' that`) };
+    })(e2, "First parameter").mode ? V(this) : at(this);
+  }
+  pipeThrough(e2, t2 = {}) {
+    if (!Ir(this)) throw Qr("pipeThrough");
+    M(e2, 1, "pipeThrough");
+    const r2 = (function(e3, t3) {
+      L(e3, t3);
+      const r3 = null == e3 ? void 0 : e3.readable;
+      Y(r3, "readable", "ReadableWritablePair"), H(r3, `${t3} has member 'readable' that`);
+      const o3 = null == e3 ? void 0 : e3.writable;
+      return Y(o3, "writable", "ReadableWritablePair"), Tt(o3, `${t3} has member 'writable' that`), { readable: r3, writable: o3 };
+    })(e2, "First parameter"), o2 = zr(t2, "Second parameter");
+    if ($r(this)) throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");
+    if (Et(r2.writable)) throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");
+    return p(hr(this, r2.writable, o2.preventClose, o2.preventAbort, o2.preventCancel, o2.signal)), r2.readable;
+  }
+  pipeTo(e2, t2 = {}) {
+    if (!Ir(this)) return d(Qr("pipeTo"));
+    if (void 0 === e2) return d("Parameter 1 is required in 'pipeTo'.");
+    if (!qt(e2)) return d(new TypeError("ReadableStream.prototype.pipeTo's first argument must be a WritableStream"));
+    let r2;
+    try {
+      r2 = zr(t2, "Second parameter");
+    } catch (e3) {
+      return d(e3);
+    }
+    return $r(this) ? d(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream")) : Et(e2) ? d(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream")) : hr(this, e2, r2.preventClose, r2.preventAbort, r2.preventCancel, r2.signal);
+  }
+  tee() {
+    if (!Ir(this)) throw Qr("tee");
+    return le(Wr(this));
+  }
+  values(e2 = void 0) {
+    if (!Ir(this)) throw Qr("values");
+    return (function(e3, t2) {
+      const r2 = V(e3), o2 = new ye(r2, t2), n2 = Object.create(ge);
+      return n2._asyncIteratorImpl = o2, n2;
+    })(this, (function(e3, t2) {
+      L(e3, t2);
+      const r2 = null == e3 ? void 0 : e3.preventCancel;
+      return { preventCancel: Boolean(r2) };
+    })(e2, "First parameter").preventCancel);
+  }
+  [_e](e2) {
+    return this.values(e2);
+  }
+  static from(e2) {
+    return Or(e2);
+  }
+};
+function Dr(e2, t2, r2, o2 = 1, n2 = () => 1) {
+  const i2 = Object.create(ReadableStream2.prototype);
+  Lr(i2);
+  return qr(i2, Object.create(ReadableStreamDefaultController.prototype), e2, t2, r2, o2, n2), i2;
+}
+function Fr(e2, t2, r2) {
+  const o2 = Object.create(ReadableStream2.prototype);
+  Lr(o2);
+  return rt(o2, Object.create(ReadableByteStreamController.prototype), e2, t2, r2, 0, void 0), o2;
+}
+function Lr(e2) {
+  e2._state = "readable", e2._reader = void 0, e2._storedError = void 0, e2._disturbed = false;
+}
+function Ir(e2) {
+  return !!t(e2) && (!!Object.prototype.hasOwnProperty.call(e2, "_readableStreamController") && e2 instanceof ReadableStream2);
+}
+function $r(e2) {
+  return void 0 !== e2._reader;
+}
+function Mr(t2, r2) {
+  if (t2._disturbed = true, "closed" === t2._state) return c(void 0);
+  if ("errored" === t2._state) return d(t2._storedError);
+  Yr(t2);
+  const o2 = t2._reader;
+  if (void 0 !== o2 && ft(o2)) {
+    const e2 = o2._readIntoRequests;
+    o2._readIntoRequests = new v(), e2.forEach((e3) => {
+      e3._closeSteps(void 0);
+    });
+  }
+  return m(t2._readableStreamController[T](r2), e);
+}
+function Yr(e2) {
+  e2._state = "closed";
+  const t2 = e2._reader;
+  if (void 0 !== t2 && (z(t2), ee(t2))) {
+    const e3 = t2._readRequests;
+    t2._readRequests = new v(), e3.forEach((e4) => {
+      e4._closeSteps();
+    });
+  }
+}
+function xr(e2, t2) {
+  e2._state = "errored", e2._storedError = t2;
+  const r2 = e2._reader;
+  void 0 !== r2 && (A(r2, t2), ee(r2) ? oe(r2, t2) : bt(r2, t2));
+}
+function Qr(e2) {
+  return new TypeError(`ReadableStream.prototype.${e2} can only be used on a ReadableStream`);
+}
+function Nr(e2, t2) {
+  L(e2, t2);
+  const r2 = null == e2 ? void 0 : e2.highWaterMark;
+  return Y(r2, "highWaterMark", "QueuingStrategyInit"), { highWaterMark: x(r2) };
+}
+Object.defineProperties(ReadableStream2, { from: { enumerable: true } }), Object.defineProperties(ReadableStream2.prototype, { cancel: { enumerable: true }, getReader: { enumerable: true }, pipeThrough: { enumerable: true }, pipeTo: { enumerable: true }, tee: { enumerable: true }, values: { enumerable: true }, locked: { enumerable: true } }), o(ReadableStream2.from, "from"), o(ReadableStream2.prototype.cancel, "cancel"), o(ReadableStream2.prototype.getReader, "getReader"), o(ReadableStream2.prototype.pipeThrough, "pipeThrough"), o(ReadableStream2.prototype.pipeTo, "pipeTo"), o(ReadableStream2.prototype.tee, "tee"), o(ReadableStream2.prototype.values, "values"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(ReadableStream2.prototype, Symbol.toStringTag, { value: "ReadableStream", configurable: true }), Object.defineProperty(ReadableStream2.prototype, _e, { value: ReadableStream2.prototype.values, writable: true, configurable: true });
+var Hr = (e2) => e2.byteLength;
+o(Hr, "size");
+var ByteLengthQueuingStrategy = class {
+  constructor(e2) {
+    M(e2, 1, "ByteLengthQueuingStrategy"), e2 = Nr(e2, "First parameter"), this._byteLengthQueuingStrategyHighWaterMark = e2.highWaterMark;
+  }
+  get highWaterMark() {
+    if (!Ur(this)) throw Vr("highWaterMark");
+    return this._byteLengthQueuingStrategyHighWaterMark;
+  }
+  get size() {
+    if (!Ur(this)) throw Vr("size");
+    return Hr;
+  }
+};
+function Vr(e2) {
+  return new TypeError(`ByteLengthQueuingStrategy.prototype.${e2} can only be used on a ByteLengthQueuingStrategy`);
+}
+function Ur(e2) {
+  return !!t(e2) && (!!Object.prototype.hasOwnProperty.call(e2, "_byteLengthQueuingStrategyHighWaterMark") && e2 instanceof ByteLengthQueuingStrategy);
+}
+Object.defineProperties(ByteLengthQueuingStrategy.prototype, { highWaterMark: { enumerable: true }, size: { enumerable: true } }), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(ByteLengthQueuingStrategy.prototype, Symbol.toStringTag, { value: "ByteLengthQueuingStrategy", configurable: true });
+var Gr = () => 1;
+o(Gr, "size");
+var CountQueuingStrategy = class {
+  constructor(e2) {
+    M(e2, 1, "CountQueuingStrategy"), e2 = Nr(e2, "First parameter"), this._countQueuingStrategyHighWaterMark = e2.highWaterMark;
+  }
+  get highWaterMark() {
+    if (!Jr(this)) throw Xr("highWaterMark");
+    return this._countQueuingStrategyHighWaterMark;
+  }
+  get size() {
+    if (!Jr(this)) throw Xr("size");
+    return Gr;
+  }
+};
+function Xr(e2) {
+  return new TypeError(`CountQueuingStrategy.prototype.${e2} can only be used on a CountQueuingStrategy`);
+}
+function Jr(e2) {
+  return !!t(e2) && (!!Object.prototype.hasOwnProperty.call(e2, "_countQueuingStrategyHighWaterMark") && e2 instanceof CountQueuingStrategy);
+}
+function Kr(e2, t2, r2) {
+  return I(e2, r2), (r3) => g(e2, t2, [r3]);
+}
+function Zr(e2, t2, r2) {
+  return I(e2, r2), (r3) => S(e2, t2, [r3]);
+}
+function eo(e2, t2, r2) {
+  return I(e2, r2), (r3, o2) => g(e2, t2, [r3, o2]);
+}
+function to(e2, t2, r2) {
+  return I(e2, r2), (r3) => g(e2, t2, [r3]);
+}
+Object.defineProperties(CountQueuingStrategy.prototype, { highWaterMark: { enumerable: true }, size: { enumerable: true } }), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(CountQueuingStrategy.prototype, Symbol.toStringTag, { value: "CountQueuingStrategy", configurable: true });
+var TransformStream = class {
+  constructor(e2 = {}, t2 = {}, r2 = {}) {
+    void 0 === e2 && (e2 = null);
+    const o2 = yt(t2, "Second parameter"), n2 = yt(r2, "Third parameter"), i2 = (function(e3, t3) {
+      L(e3, t3);
+      const r3 = null == e3 ? void 0 : e3.cancel, o3 = null == e3 ? void 0 : e3.flush, n3 = null == e3 ? void 0 : e3.readableType, i3 = null == e3 ? void 0 : e3.start, a3 = null == e3 ? void 0 : e3.transform, s3 = null == e3 ? void 0 : e3.writableType;
+      return { cancel: void 0 === r3 ? void 0 : to(r3, e3, `${t3} has member 'cancel' that`), flush: void 0 === o3 ? void 0 : Kr(o3, e3, `${t3} has member 'flush' that`), readableType: n3, start: void 0 === i3 ? void 0 : Zr(i3, e3, `${t3} has member 'start' that`), transform: void 0 === a3 ? void 0 : eo(a3, e3, `${t3} has member 'transform' that`), writableType: s3 };
+    })(e2, "First parameter");
+    if (void 0 !== i2.readableType) throw new RangeError("Invalid readableType specified");
+    if (void 0 !== i2.writableType) throw new RangeError("Invalid writableType specified");
+    const a2 = mt(n2, 0), s2 = pt(n2), l2 = mt(o2, 1), f2 = pt(o2);
+    let b2;
+    !(function(e3, t3, r3, o3, n3, i3) {
+      function a3() {
+        return t3;
+      }
+      function s3(t4) {
+        return (function(e4, t5) {
+          const r4 = e4._transformStreamController;
+          if (e4._backpressure) {
+            return m(e4._backpressureChangePromise, () => {
+              const o4 = e4._writable;
+              if ("erroring" === o4._state) throw o4._storedError;
+              return co(r4, t5);
+            });
+          }
+          return co(r4, t5);
+        })(e3, t4);
+      }
+      function l3(t4) {
+        return (function(e4, t5) {
+          const r4 = e4._transformStreamController;
+          if (void 0 !== r4._finishPromise) return r4._finishPromise;
+          const o4 = e4._readable;
+          r4._finishPromise = u((e5, t6) => {
+            r4._finishPromise_resolve = e5, r4._finishPromise_reject = t6;
+          });
+          const n4 = r4._cancelAlgorithm(t5);
+          return lo(r4), h(n4, () => ("errored" === o4._state ? bo(r4, o4._storedError) : (Tr(o4._readableStreamController, t5), ho(r4)), null), (e5) => (Tr(o4._readableStreamController, e5), bo(r4, e5), null)), r4._finishPromise;
+        })(e3, t4);
+      }
+      function c2() {
+        return (function(e4) {
+          const t4 = e4._transformStreamController;
+          if (void 0 !== t4._finishPromise) return t4._finishPromise;
+          const r4 = e4._readable;
+          t4._finishPromise = u((e5, r5) => {
+            t4._finishPromise_resolve = e5, t4._finishPromise_reject = r5;
+          });
+          const o4 = t4._flushAlgorithm();
+          return lo(t4), h(o4, () => ("errored" === r4._state ? bo(t4, r4._storedError) : (wr(r4._readableStreamController), ho(t4)), null), (e5) => (Tr(r4._readableStreamController, e5), bo(t4, e5), null)), t4._finishPromise;
+        })(e3);
+      }
+      function d2() {
+        return (function(e4) {
+          return ao(e4, false), e4._backpressureChangePromise;
+        })(e3);
+      }
+      function f3(t4) {
+        return (function(e4, t5) {
+          const r4 = e4._transformStreamController;
+          if (void 0 !== r4._finishPromise) return r4._finishPromise;
+          const o4 = e4._writable;
+          r4._finishPromise = u((e5, t6) => {
+            r4._finishPromise_resolve = e5, r4._finishPromise_reject = t6;
+          });
+          const n4 = r4._cancelAlgorithm(t5);
+          return lo(r4), h(n4, () => ("errored" === o4._state ? bo(r4, o4._storedError) : (Gt(o4._writableStreamController, t5), io(e4), ho(r4)), null), (t6) => (Gt(o4._writableStreamController, t6), io(e4), bo(r4, t6), null)), r4._finishPromise;
+        })(e3, t4);
+      }
+      e3._writable = (function(e4, t4, r4, o4, n4 = 1, i4 = () => 1) {
+        const a4 = Object.create(WritableStream.prototype);
+        return Ct(a4), Nt(a4, Object.create(WritableStreamDefaultController.prototype), e4, t4, r4, o4, n4, i4), a4;
+      })(a3, s3, c2, l3, r3, o3), e3._readable = Dr(a3, d2, f3, n3, i3), e3._backpressure = void 0, e3._backpressureChangePromise = void 0, e3._backpressureChangePromise_resolve = void 0, ao(e3, true), e3._transformStreamController = void 0;
+    })(this, u((e3) => {
+      b2 = e3;
+    }), l2, f2, a2, s2), (function(e3, t3) {
+      const r3 = Object.create(TransformStreamDefaultController.prototype);
+      let o3, n3, i3;
+      o3 = void 0 !== t3.transform ? (e4) => t3.transform(e4, r3) : (e4) => {
+        try {
+          return uo(r3, e4), c(void 0);
+        } catch (e5) {
+          return d(e5);
+        }
+      };
+      n3 = void 0 !== t3.flush ? () => t3.flush(r3) : () => c(void 0);
+      i3 = void 0 !== t3.cancel ? (e4) => t3.cancel(e4) : () => c(void 0);
+      !(function(e4, t4, r4, o4, n4) {
+        t4._controlledTransformStream = e4, e4._transformStreamController = t4, t4._transformAlgorithm = r4, t4._flushAlgorithm = o4, t4._cancelAlgorithm = n4, t4._finishPromise = void 0, t4._finishPromise_resolve = void 0, t4._finishPromise_reject = void 0;
+      })(e3, r3, o3, n3, i3);
+    })(this, i2), void 0 !== i2.start ? b2(i2.start(this._transformStreamController)) : b2(void 0);
+  }
+  get readable() {
+    if (!ro(this)) throw _o("readable");
+    return this._readable;
+  }
+  get writable() {
+    if (!ro(this)) throw _o("writable");
+    return this._writable;
+  }
+};
+function ro(e2) {
+  return !!t(e2) && (!!Object.prototype.hasOwnProperty.call(e2, "_transformStreamController") && e2 instanceof TransformStream);
+}
+function oo(e2, t2) {
+  Tr(e2._readable._readableStreamController, t2), no(e2, t2);
+}
+function no(e2, t2) {
+  lo(e2._transformStreamController), Gt(e2._writable._writableStreamController, t2), io(e2);
+}
+function io(e2) {
+  e2._backpressure && ao(e2, false);
+}
+function ao(e2, t2) {
+  void 0 !== e2._backpressureChangePromise && e2._backpressureChangePromise_resolve(), e2._backpressureChangePromise = u((t3) => {
+    e2._backpressureChangePromise_resolve = t3;
+  }), e2._backpressure = t2;
+}
+Object.defineProperties(TransformStream.prototype, { readable: { enumerable: true }, writable: { enumerable: true } }), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(TransformStream.prototype, Symbol.toStringTag, { value: "TransformStream", configurable: true });
+var TransformStreamDefaultController = class {
+  constructor() {
+    throw new TypeError("Illegal constructor");
+  }
+  get desiredSize() {
+    if (!so(this)) throw fo("desiredSize");
+    return Pr(this._controlledTransformStream._readable._readableStreamController);
+  }
+  enqueue(e2 = void 0) {
+    if (!so(this)) throw fo("enqueue");
+    uo(this, e2);
+  }
+  error(e2 = void 0) {
+    if (!so(this)) throw fo("error");
+    var t2;
+    t2 = e2, oo(this._controlledTransformStream, t2);
+  }
+  terminate() {
+    if (!so(this)) throw fo("terminate");
+    !(function(e2) {
+      const t2 = e2._controlledTransformStream;
+      wr(t2._readable._readableStreamController);
+      const r2 = new TypeError("TransformStream terminated");
+      no(t2, r2);
+    })(this);
+  }
+};
+function so(e2) {
+  return !!t(e2) && (!!Object.prototype.hasOwnProperty.call(e2, "_controlledTransformStream") && e2 instanceof TransformStreamDefaultController);
+}
+function lo(e2) {
+  e2._transformAlgorithm = void 0, e2._flushAlgorithm = void 0, e2._cancelAlgorithm = void 0;
+}
+function uo(e2, t2) {
+  const r2 = e2._controlledTransformStream, o2 = r2._readable._readableStreamController;
+  if (!Cr(o2)) throw new TypeError("Readable side is not in a state that permits enqueue");
+  try {
+    Rr(o2, t2);
+  } catch (e3) {
+    throw no(r2, e3), r2._readable._storedError;
+  }
+  const n2 = (function(e3) {
+    return !gr(e3);
+  })(o2);
+  n2 !== r2._backpressure && ao(r2, true);
+}
+function co(e2, t2) {
+  return m(e2._transformAlgorithm(t2), void 0, (t3) => {
+    throw oo(e2._controlledTransformStream, t3), t3;
+  });
+}
+function fo(e2) {
+  return new TypeError(`TransformStreamDefaultController.prototype.${e2} can only be used on a TransformStreamDefaultController`);
+}
+function ho(e2) {
+  void 0 !== e2._finishPromise_resolve && (e2._finishPromise_resolve(), e2._finishPromise_resolve = void 0, e2._finishPromise_reject = void 0);
+}
+function bo(e2, t2) {
+  void 0 !== e2._finishPromise_reject && (p(e2._finishPromise), e2._finishPromise_reject(t2), e2._finishPromise_resolve = void 0, e2._finishPromise_reject = void 0);
+}
+function _o(e2) {
+  return new TypeError(`TransformStream.prototype.${e2} can only be used on a TransformStream`);
+}
+Object.defineProperties(TransformStreamDefaultController.prototype, { enqueue: { enumerable: true }, error: { enumerable: true }, terminate: { enumerable: true }, desiredSize: { enumerable: true } }), o(TransformStreamDefaultController.prototype.enqueue, "enqueue"), o(TransformStreamDefaultController.prototype.error, "error"), o(TransformStreamDefaultController.prototype.terminate, "terminate"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(TransformStreamDefaultController.prototype, Symbol.toStringTag, { value: "TransformStreamDefaultController", configurable: true });
+
+// _build/lib/stream.js
+globalThis.ReadableStream = ReadableStream2;
+
+// _build/lib/http-common.js
+function _concat(parts) {
+  if (parts.length === 0)
+    return new Uint8Array(0);
+  let totalLen = 0;
+  for (const p2 of parts)
+    totalLen += p2.length;
+  const result = new Uint8Array(totalLen);
+  let offset = 0;
+  for (const p2 of parts) {
+    result.set(p2, offset);
+    offset += p2.length;
+  }
+  return result;
+}
+function _toReadableStream(body) {
+  if (body instanceof ReadableStream)
+    return body;
+  const bytes = typeof body === "string" ? new TextEncoder().encode(body) : body instanceof ArrayBuffer ? new Uint8Array(body) : new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
+  return new ReadableStream({
+    start(ctrl) {
+      ctrl.enqueue(bytes);
+      ctrl.close();
+    }
+  });
+}
+async function _readStream(stream) {
+  const reader = stream.getReader();
+  const chunks = [];
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    chunks.push(value);
+  }
+  return _concat(chunks);
+}
+var HeadersImpl = class _HeadersImpl {
+  _headers = [];
+  constructor(init) {
+    if (init) {
+      if (init instanceof _HeadersImpl) {
+        this._headers = [...init._headers];
+      } else if (Array.isArray(init)) {
+        this._headers = init.flatMap(([k2, v2]) => [k2.toLowerCase(), v2]);
+      } else if (typeof init === "object") {
+        this._headers = Object.entries(init).flatMap(([k2, v2]) => [k2.toLowerCase(), v2]);
+      }
+    }
+  }
+  append(name, value) {
+    this._headers.push(name.toLowerCase(), value);
+  }
+  delete(name) {
+    const key = name.toLowerCase();
+    const h2 = this._headers;
+    let i2 = h2.length - 2;
+    while (i2 >= 0) {
+      if (h2[i2] === key) {
+        h2.splice(i2, 2);
+        i2 -= 2;
+      } else
+        i2 -= 2;
+    }
+  }
+  get(name) {
+    const key = name.toLowerCase();
+    const matches = [...this.entries()].filter(([k2]) => k2 === key).map(([, v2]) => v2);
+    return matches.length ? matches.join(", ") : null;
+  }
+  has(name) {
+    return [...this.keys()].includes(name.toLowerCase());
+  }
+  set(name, value) {
+    const key = name.toLowerCase();
+    const h2 = this._headers;
+    let found = false;
+    let i2 = h2.length - 2;
+    while (i2 >= 0) {
+      if (h2[i2] === key) {
+        if (!found) {
+          h2[i2 + 1] = value;
+          found = true;
+        } else {
+          h2.splice(i2, 2);
+        }
+      }
+      i2 -= 2;
+    }
+    if (!found)
+      h2.push(key, value);
+  }
+  forEach(callback) {
+    for (const [name, value] of this) {
+      callback(value, name, this);
+    }
+  }
+  *entries() {
+    const h2 = this._headers;
+    for (let i2 = 0; i2 < h2.length; i2 += 2) {
+      yield [h2[i2], h2[i2 + 1]];
+    }
+  }
+  *keys() {
+    for (const [k2] of this)
+      yield k2;
+  }
+  *values() {
+    for (const [, v2] of this)
+      yield v2;
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+};
+var RequestImpl = class _RequestImpl {
+  url;
+  method;
+  headers;
+  _body;
+  redirect;
+  timeout;
+  maxRedirects;
+  _bodyConsumed = false;
+  integrity = "";
+  keepalive = false;
+  mode = "cors";
+  cache = "default";
+  credentials = "same-origin";
+  referrer = "about:client";
+  referrerPolicy = "";
+  signal = null;
+  destination = "";
+  get body() {
+    return this._body;
+  }
+  get bodyUsed() {
+    return this._bodyConsumed || (this._body?.locked ?? false);
+  }
+  constructor(input, init = {}) {
+    const initBody = init.body;
+    if (input instanceof _RequestImpl) {
+      this.url = input.url;
+      this.method = init.method || input.method;
+      this.headers = new HeadersImpl(init.headers || input.headers);
+      if (initBody !== void 0 && initBody !== null) {
+        this._body = _toReadableStream(initBody);
+      } else {
+        this._body = input._body;
+      }
+      this.redirect = init.redirect || input.redirect;
+      this.timeout = init.timeout || input.timeout;
+      this.maxRedirects = init.maxRedirects || input.maxRedirects;
+    } else {
+      this.url = input;
+      this.method = init.method || "GET";
+      this.headers = new HeadersImpl(init.headers);
+      this._body = initBody !== null && initBody !== void 0 ? _toReadableStream(initBody) : null;
+      this.redirect = init.redirect || "follow";
+      this.timeout = init.timeout || 3e4;
+      this.maxRedirects = init.maxRedirects || 5;
+    }
+  }
+  async arrayBuffer() {
+    if (!this.body)
+      return new ArrayBuffer(0);
+    if (this._bodyConsumed)
+      throw new TypeError("Body already used");
+    this._bodyConsumed = true;
+    const bytes = await _readStream(this.body);
+    return bytes.buffer;
+  }
+  async json() {
+    return JSON.parse(await this.text());
+  }
+  async text() {
+    if (!this.body)
+      return "";
+    if (this._bodyConsumed)
+      throw new TypeError("Body already used");
+    this._bodyConsumed = true;
+    const bytes = await _readStream(this.body);
+    return new TextDecoder("utf-8").decode(bytes);
+  }
+  clone() {
+    if (this.bodyUsed)
+      throw new TypeError("Body already used");
+    if (this._body) {
+      const [branch1, branch2] = this._body.tee();
+      this._body = branch1;
+      const req = new _RequestImpl(this.url, {
+        method: this.method,
+        headers: this.headers,
+        body: branch2,
+        redirect: this.redirect,
+        timeout: this.timeout,
+        maxRedirects: this.maxRedirects
+      });
+      return req;
+    }
+    return new _RequestImpl(this.url, {
+      method: this.method,
+      headers: this.headers,
+      redirect: this.redirect,
+      timeout: this.timeout,
+      maxRedirects: this.maxRedirects
+    });
+  }
+};
+var ResponseImpl = class _ResponseImpl {
+  status;
+  statusText;
+  ok;
+  _headers;
+  _redirected = false;
+  _type = "basic";
+  _url = "";
+  _body;
+  _bodyConsumed = false;
+  get body() {
+    return this._body;
+  }
+  get bodyUsed() {
+    return this._bodyConsumed || this._body.locked;
+  }
+  get headers() {
+    return this._headers;
+  }
+  get redirected() {
+    return this._redirected;
+  }
+  get type() {
+    return this._type;
+  }
+  get url() {
+    return this._url;
+  }
+  constructor(body, init) {
+    const status = init?.status ?? 200;
+    const statusText = init?.statusText ?? "";
+    const headers = new HeadersImpl(init?.headers);
+    this.status = status;
+    this.statusText = statusText;
+    this._headers = headers;
+    this.ok = status >= 200 && status < 300;
+    this._body = body != null ? _toReadableStream(body) : new ReadableStream({
+      start(ctrl) {
+        ctrl.close();
+      }
+    });
+  }
+  async text() {
+    if (this.bodyUsed)
+      throw new TypeError("Body already used");
+    this._bodyConsumed = true;
+    const bytes = await _readStream(this._body);
+    return new TextDecoder("utf-8").decode(bytes);
+  }
+  async json() {
+    return JSON.parse(await this.text());
+  }
+  async arrayBuffer() {
+    if (this.bodyUsed)
+      throw new TypeError("Body already used");
+    this._bodyConsumed = true;
+    const bytes = await _readStream(this._body);
+    return bytes.buffer;
+  }
+  async bytes() {
+    if (this.bodyUsed)
+      throw new TypeError("Body already used");
+    this._bodyConsumed = true;
+    return await _readStream(this._body);
+  }
+  clone() {
+    if (this.bodyUsed)
+      throw new TypeError("Body already used");
+    const [branch1, branch2] = this._body.tee();
+    this._body = branch1;
+    return new _ResponseImpl(branch2, { status: this.status, statusText: this.statusText, headers: this._headers });
+  }
+  _applyDecompressedBody(stream, _body, newHeaders) {
+    this._bodyConsumed = false;
+    this._body = stream;
+    this._headers = newHeaders;
+  }
+};
+globalThis.Headers = HeadersImpl;
+globalThis.Request = RequestImpl;
+globalThis.Response = ResponseImpl;
+
+// _build/lib/http-server.js
+var STATUS_TEXT = {
+  100: "Continue",
+  101: "Switching Protocols",
+  200: "OK",
+  201: "Created",
+  202: "Accepted",
+  204: "No Content",
+  301: "Moved Permanently",
+  302: "Found",
+  304: "Not Modified",
+  400: "Bad Request",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  408: "Request Timeout",
+  413: "Payload Too Large",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable"
+};
+function concatU8(parts) {
+  let total = 0;
+  for (const p2 of parts)
+    total += p2.length;
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const p2 of parts) {
+    out.set(p2, off);
+    off += p2.length;
+  }
+  return out;
+}
+function toArrayBuffer(u8) {
+  return u8.buffer.slice(u8.byteOffset, u8.byteOffset + u8.byteLength);
+}
+function findCrLfCrLf(buf) {
+  const n2 = buf.length - 3;
+  for (let i2 = 0; i2 < n2; i2++) {
+    if (buf[i2] === 13 && buf[i2 + 1] === 10 && buf[i2 + 2] === 13 && buf[i2 + 3] === 10)
+      return i2;
+  }
+  return -1;
+}
+function decodeChunked(buf, start) {
+  let pos = start;
+  const parts = [];
+  const decoder = new TextDecoder("utf-8");
+  while (pos < buf.length) {
+    let eol = pos;
+    while (eol < buf.length && buf[eol] !== 13)
+      eol++;
+    if (eol >= buf.length || eol + 1 >= buf.length || buf[eol + 1] !== 10)
+      return null;
+    const sizeLine = decoder.decode(buf.subarray(pos, eol)).trim();
+    const semi = sizeLine.indexOf(";");
+    const hex = (semi >= 0 ? sizeLine.slice(0, semi) : sizeLine).trim();
+    const size = parseInt(hex, 16);
+    if (isNaN(size) || size < 0)
+      return null;
+    pos = eol + 2;
+    if (size === 0) {
+      while (true) {
+        if (pos >= buf.length)
+          return null;
+        if (buf[pos] === 13) {
+          if (pos + 1 >= buf.length || buf[pos + 1] !== 10)
+            return null;
+          pos += 2;
+          return { data: concatU8(parts), end: pos };
+        }
+        let t2 = pos;
+        while (t2 < buf.length && buf[t2] !== 13)
+          t2++;
+        if (t2 >= buf.length || t2 + 1 >= buf.length || buf[t2 + 1] !== 10)
+          return null;
+        pos = t2 + 2;
+      }
+    }
+    if (pos + size > buf.length)
+      return null;
+    parts.push(buf.subarray(pos, pos + size));
+    pos += size;
+    if (pos + 1 >= buf.length || buf[pos] !== 13 || buf[pos + 1] !== 10)
+      return null;
+    pos += 2;
+  }
+  return null;
+}
+function parseHeader(headerStr) {
+  const lines = headerStr.split("\r\n");
+  const first = lines[0];
+  if (!first)
+    return null;
+  const sp1 = first.indexOf(" ");
+  const sp2 = first.lastIndexOf(" ");
+  if (sp1 <= 0 || sp2 <= sp1)
+    return null;
+  const method = first.slice(0, sp1);
+  const target = first.slice(sp1 + 1, sp2);
+  const version = first.slice(sp2 + 1).trim();
+  const headers = {};
+  for (let i2 = 1; i2 < lines.length; i2++) {
+    const line = lines[i2];
+    if (!line)
+      continue;
+    const ci = line.indexOf(":");
+    if (ci <= 0)
+      continue;
+    const name = line.slice(0, ci).trim().toLowerCase();
+    const value = line.slice(ci + 1).trim();
+    if (headers[name] !== void 0)
+      headers[name] = headers[name] + ", " + value;
+    else
+      headers[name] = value;
+  }
+  const te2 = (headers["transfer-encoding"] || "").toLowerCase();
+  const chunked = te2.indexOf("chunked") >= 0;
+  const contentLength = parseInt(headers["content-length"] || "0", 10) || 0;
+  return { method, target, version, headers, chunked, contentLength };
+}
+var HttpServer = class {
+  handler;
+  serverSock = null;
+  conns = /* @__PURE__ */ new Map();
+  closed = false;
+  constructor(handler) {
+    this.handler = handler;
+  }
+  /** Actual bound address, or null if not listening. */
+  address() {
+    if (this.serverSock === null)
+      return null;
+    return sock.getsockname(this.serverSock);
+  }
+  /** Bind and start listening. Returns 0 on success, -1 on failure. */
+  listen(port, host, backlog) {
+    if (this.serverSock !== null)
+      return -1;
+    const s2 = sock.socket();
+    if (s2 < 0)
+      return -1;
+    if (sock.bind(s2, host ?? null, port) !== 0) {
+      sock.closesocket(s2);
+      return -1;
+    }
+    if (sock.listen(s2, backlog ?? 64) !== 0) {
+      sock.closesocket(s2);
+      return -1;
+    }
+    this.serverSock = s2;
+    sock.set_on_event(s2, (event) => {
+      if (event.lNetworkEvents & 8)
+        this.acceptLoop();
+    });
+    return 0;
+  }
+  close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    for (const c2 of Array.from(this.conns.values()))
+      closeConn(c2);
+    this.conns.clear();
+    if (this.serverSock !== null) {
+      sock.closesocket(this.serverSock);
+      this.serverSock = null;
+    }
+  }
+  acceptLoop() {
+    if (this.closed || this.serverSock === null)
+      return;
+    while (true) {
+      const ac = sock.accept(this.serverSock);
+      if (!ac)
+        break;
+      const c2 = {
+        sock: ac.handle,
+        parts: [],
+        pending: null,
+        current: null,
+        outQueue: null,
+        closed: false,
+        closeAfterFlush: false,
+        keepAlive: true,
+        owner: this
+      };
+      this.conns.set(c2.sock, c2);
+      sock.set_on_event(c2.sock, (event) => this.onConnEvent(c2, event));
+    }
+  }
+  onConnEvent(c2, event) {
+    if (c2.closed)
+      return;
+    if (event.lNetworkEvents & 1)
+      onRead(c2);
+    if (event.lNetworkEvents & 2)
+      flushQueue(c2);
+    if (event.lNetworkEvents & 32) {
+      onRead(c2);
+      if (!c2.current && !c2.pending)
+        closeConn(c2);
+    }
+  }
+};
+function createServer(handler) {
+  return new HttpServer(handler);
+}
+function onRead(c2) {
+  if (c2.closed)
+    return;
+  while (true) {
+    const d2 = sock.recv(c2.sock, 8192);
+    if (!d2)
+      break;
+    c2.parts.push(new Uint8Array(d2));
+  }
+  if (!c2.closed)
+    tryProcess(c2);
+}
+function queueSend(c2, data) {
+  if (c2.closed || data.length === 0)
+    return;
+  if (c2.outQueue && c2.outQueue.length > 0) {
+    c2.outQueue = concatU8([c2.outQueue, data]);
+    return;
+  }
+  const ret = sock.send(c2.sock, toArrayBuffer(data));
+  if (ret < 0) {
+    c2.outQueue = data;
+    return;
+  }
+  if (ret < data.length) {
+    c2.outQueue = data.subarray(ret);
+    return;
+  }
+  if (c2.closeAfterFlush)
+    closeConn(c2);
+}
+function flushQueue(c2) {
+  if (c2.closed)
+    return;
+  if (!c2.outQueue || c2.outQueue.length === 0) {
+    if (c2.closeAfterFlush)
+      closeConn(c2);
+    return;
+  }
+  const q2 = c2.outQueue;
+  const ret = sock.send(c2.sock, toArrayBuffer(q2));
+  if (ret < 0)
+    return;
+  if (ret < q2.length) {
+    c2.outQueue = q2.subarray(ret);
+    return;
+  }
+  c2.outQueue = null;
+  if (c2.closeAfterFlush)
+    closeConn(c2);
+}
+function closeConn(c2) {
+  if (c2.closed)
+    return;
+  c2.closed = true;
+  if (c2.sock >= 0)
+    sock.closesocket(c2.sock);
+  c2.owner.conns.delete(c2.sock);
+}
+function whole(c2) {
+  return concatU8(c2.parts);
+}
+function trimParts(c2, buf, consumed) {
+  if (consumed >= buf.length) {
+    c2.parts = [];
+  } else {
+    c2.parts = [buf.subarray(consumed)];
+  }
+}
+function tryProcess(c2) {
+  if (c2.closed || c2.current)
+    return;
+  const buf = whole(c2);
+  if (c2.pending) {
+    const bodyStart2 = c2.pending.bodyStart;
+    const parsed2 = c2.pending.parsed;
+    let body;
+    let end;
+    if (parsed2.chunked) {
+      const dec = decodeChunked(buf, bodyStart2);
+      if (!dec)
+        return;
+      body = dec.data;
+      end = dec.end;
+    } else {
+      const needed = parsed2.contentLength;
+      if (bodyStart2 + needed > buf.length)
+        return;
+      body = buf.subarray(bodyStart2, bodyStart2 + needed);
+      end = bodyStart2 + needed;
+    }
+    c2.pending = null;
+    dispatchRequest(c2, parsed2, body, end);
+    return;
+  }
+  const headerEnd = findCrLfCrLf(buf);
+  if (headerEnd < 0)
+    return;
+  const absEnd = headerEnd + 4;
+  const headerStr = new TextDecoder("utf-8").decode(buf.subarray(0, absEnd));
+  const parsed = parseHeader(headerStr);
+  if (!parsed) {
+    closeConn(c2);
+    return;
+  }
+  const bodyStart = absEnd;
+  if (parsed.chunked) {
+    const dec = decodeChunked(buf, bodyStart);
+    if (!dec) {
+      c2.pending = { parsed, bodyStart };
+      return;
+    }
+    dispatchRequest(c2, parsed, dec.data, dec.end);
+  } else if (parsed.contentLength > 0) {
+    if (bodyStart + parsed.contentLength > buf.length) {
+      c2.pending = { parsed, bodyStart };
+      return;
+    }
+    dispatchRequest(c2, parsed, buf.subarray(bodyStart, bodyStart + parsed.contentLength), bodyStart + parsed.contentLength);
+  } else {
+    dispatchRequest(c2, parsed, new Uint8Array(0), bodyStart);
+  }
+}
+function dispatchRequest(c2, parsed, body, end) {
+  const connHeader = (parsed.headers["connection"] || "").toLowerCase();
+  if (parsed.version === "HTTP/1.1")
+    c2.keepAlive = connHeader.indexOf("close") < 0;
+  else
+    c2.keepAlive = connHeader.indexOf("keep-alive") >= 0;
+  let host = parsed.headers["host"];
+  if (!host) {
+    const a2 = c2.owner.address();
+    const addrStr = a2 ? a2.addr.includes(":") ? `[${a2.addr}]` : a2.addr : "localhost";
+    host = a2 ? addrStr + ":" + a2.port : "localhost";
+  }
+  const isAbsolute = parsed.target.startsWith("http://") || parsed.target.startsWith("https://");
+  const url = isAbsolute ? parsed.target : "http://" + host + parsed.target;
+  const req = new RequestImpl(url, {
+    method: parsed.method,
+    headers: new HeadersImpl(parsed.headers),
+    body: body.length > 0 ? body : void 0
+  });
+  c2.current = { req };
+  trimParts(c2, whole(c2), end);
+  void handleRequest(c2);
+}
+async function handleRequest(c2) {
+  const req = c2.current?.req;
+  if (!req) {
+    c2.current = null;
+    return;
+  }
+  let res;
+  try {
+    const result = await c2.owner.handler(req);
+    if (result instanceof ResponseImpl) {
+      res = result;
+    } else {
+      console.error("[http-server] handler must return a Response");
+      res = new ResponseImpl("Internal Server Error", { status: 500 });
+    }
+  } catch (e2) {
+    console.error("[http-server] handler error:", e2);
+    res = new ResponseImpl("Internal Server Error", { status: 500 });
+  }
+  if (c2.closed)
+    return;
+  await sendResponse(c2, req.method, res);
+  if (c2.closed)
+    return;
+  c2.current = null;
+  if (!c2.closeAfterFlush)
+    tryProcess(c2);
+}
+async function sendResponse(c2, method, res) {
+  const status = res.status;
+  const statusText = res.statusText || STATUS_TEXT[status] || "OK";
+  const headers = new HeadersImpl(res.headers);
+  let body;
+  try {
+    body = await _readStream(res.body);
+  } catch {
+    body = new Uint8Array(0);
+  }
+  if (c2.closed)
+    return;
+  const headOnly = method === "HEAD";
+  const bodyless = status >= 100 && status < 200 || status === 204 || status === 304;
+  if (!headers.has("content-length") && !bodyless)
+    headers.set("Content-Length", String(body.length));
+  if (!headers.has("connection"))
+    headers.set("Connection", c2.keepAlive ? "keep-alive" : "close");
+  const connHdr = (headers.get("connection") || "").toLowerCase();
+  if (!c2.keepAlive || connHdr === "close")
+    c2.closeAfterFlush = true;
+  let head = "HTTP/1.1 " + status + " " + statusText + "\r\n";
+  for (const [name, value] of headers)
+    head += name + ": " + value + "\r\n";
+  head += "\r\n";
+  const headBytes = new TextEncoder().encode(head);
+  const payload = headOnly || body.length === 0 ? headBytes : concatU8([headBytes, body]);
+  queueSend(c2, payload);
+}
+
+// _build/examples/exec_server.js
+import * as os2 from "os";
+var EXEC_TIMEOUT_MS = 6e4;
+function runInWorker(cmd) {
+  return new Promise((resolve, reject) => {
+    const worker = new os2.Worker("data:text/javascript;base64,aW1wb3J0KmFzIGEgZnJvbSJvcyI7aW1wb3J0KmFzIGkgZnJvbSJzdGQiO2Z1bmN0aW9uIGwoYyl7bGV0IHQ9W10sbj1uZXcgVWludDhBcnJheSg0MDk2KTtmb3IoOzspe2xldCByPWMucmVhZChuLmJ1ZmZlciwwLDQwOTYpO2lmKHI8PTApYnJlYWs7dC5wdXNoKG4uc2xpY2UoMCxyKSl9bGV0IHM9MDtmb3IobGV0IHIgb2YgdClzKz1yLmxlbmd0aDtsZXQgbz1uZXcgVWludDhBcnJheShzKSxlPTA7Zm9yKGxldCByIG9mIHQpby5zZXQocixlKSxlKz1yLmxlbmd0aDtyZXR1cm4gb312YXIgZj1hLldvcmtlci5wYXJlbnQ7Zi5vbm1lc3NhZ2U9Yz0+e2xldCB0PWMuZGF0YTtpZih0LnR5cGUhPT0icnVuInx8dHlwZW9mIHQuY21kIT0ic3RyaW5nIilyZXR1cm47bGV0IG49bmV3IFVpbnQ4QXJyYXkoMCkscz0tMSxvPW51bGw7dHJ5e2xldCBlPWkucG9wZW4odC5jbWQsInIiKTtlPyhuPWwoZSkscz1lLmNsb3NlKCkpOm89InBvcGVuIGZhaWxlZCJ9Y2F0Y2goZSl7bz1TdHJpbmcoZSl9Zi5wb3N0TWVzc2FnZSh7dHlwZToicmVzdWx0IixpZDp0LmlkLG91dDpuLGNvZGU6cyxlcnJvcjpvfSl9Owo=");
+    const id = 1;
+    let settled = false;
+    let timer;
+    const finish = (fn) => {
+      if (settled)
+        return;
+      settled = true;
+      os2.clearTimeout(timer);
+      worker.onmessage = null;
+      fn();
+    };
+    timer = os2.setTimeout(() => {
+      finish(() => reject(new Error("exec timeout")));
+    }, EXEC_TIMEOUT_MS);
+    worker.onmessage = (e2) => {
+      const msg = e2.data;
+      if (msg.type !== "result" || msg.id !== id)
+        return;
+      finish(() => resolve({ out: msg.out ?? new Uint8Array(0), code: msg.code ?? -1, error: msg.error ?? null }));
+    };
+    try {
+      worker.postMessage({ type: "run", id, cmd });
+    } catch (ex) {
+      finish(() => reject(ex instanceof Error ? ex : new Error(String(ex))));
+    }
+  });
+}
+var server = createServer(async (req) => {
+  const path = new URL(req.url).pathname;
+  if (req.method === "GET" && (path === "/" || path === "/health")) {
+    return new Response("ok", { headers: { "Content-Type": "text/plain" } });
+  }
+  if (req.method === "POST" && path === "/exec") {
+    const body = await req.json();
+    try {
+      const { out, code, error } = await runInWorker(body.cmd);
+      if (error) {
+        return new Response(JSON.stringify({ error }), {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
         });
+      }
+      return new Response(out, {
+        headers: {
+          "Content-Type": "application/octet-stream",
+          "X-Exit-Code": String(code)
+        }
+      });
+    } catch (ex) {
+      return new Response(JSON.stringify({ error: String(ex) }), {
+        status: 504,
+        headers: { "Content-Type": "application/json" }
+      });
     }
-    return new Response('Not Found', { status: 404 });
+  }
+  return new Response("Not Found", { status: 404 });
 });
-server.listen(8080);
-console.log('listening on http://localhost:8080');
+var rc = server.listen(8080, "0.0.0.0");
+console.log("listen rc=" + rc + " addr=" + JSON.stringify(server.address()));
+/**
+ * @license
+ * web-streams-polyfill v4.3.0
+ * Copyright 2026 Mattias Buelens, Diwank Singh Tomer and other contributors.
+ * This code is released under the MIT license.
+ * SPDX-License-Identifier: MIT
+ */