create-book 1.1.3 → 10.0.1

package/dist/chunk-VMSWFJV3.js

@@ -0,0 +1,3598 @@
+import { createRequire as __createRequire } from 'module'; const require = __createRequire(import.meta.url);
+import {
+  __require
+} from "./chunk-D4XGRVQ6.js";
+
+// ../../node_modules/.pnpm/node-fetch-native@1.6.7/node_modules/node-fetch-native/dist/shared/node-fetch-native.DfbY2q-x.mjs
+var t = Object.defineProperty;
+var o = (e, l) => t(e, "name", { value: l, configurable: true });
+var n = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function f(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+o(f, "getDefaultExportFromCjs");
+
+// ../../node_modules/.pnpm/node-fetch-native@1.6.7/node_modules/node-fetch-native/dist/node.mjs
+import Bt from "node:http";
+import zs from "node:https";
+import st from "node:zlib";
+import me, { PassThrough as dr, pipeline as lt } from "node:stream";
+import { Buffer as M } from "node:buffer";
+import { types as hr, deprecate as pr, promisify as Is } from "node:util";
+import { format as js } from "node:url";
+import { isIP as Ls } from "node:net";
+import { promises as $s, statSync as hi, createReadStream as Ds } from "node:fs";
+import { basename as Ms } from "node:path";
+var Os = Object.defineProperty;
+var fi = (i) => {
+  throw TypeError(i);
+};
+var n2 = (i, o2) => Os(i, "name", { value: o2, configurable: true });
+var ci = (i, o2, a) => o2.has(i) || fi("Cannot " + a);
+var O = (i, o2, a) => (ci(i, o2, "read from private field"), a ? a.call(i) : o2.get(i));
+var be = (i, o2, a) => o2.has(i) ? fi("Cannot add the same private member more than once") : o2 instanceof WeakSet ? o2.add(i) : o2.set(i, a);
+var X = (i, o2, a, f2) => (ci(i, o2, "write to private field"), f2 ? f2.call(i, a) : o2.set(i, a), a);
+var ve;
+var zt;
+var bt;
+var Cr;
+var ze;
+var It;
+var Ft;
+var mt;
+var ee;
+var yt;
+var He;
+var Ve;
+var gt;
+function Us(i) {
+  if (!/^data:/i.test(i)) throw new TypeError('`uri` does not appear to be a Data URI (must begin with "data:")');
+  i = i.replace(/\r?\n/g, "");
+  const o2 = i.indexOf(",");
+  if (o2 === -1 || o2 <= 4) throw new TypeError("malformed data: URI");
+  const a = i.substring(5, o2).split(";");
+  let f2 = "", l = false;
+  const p = a[0] || "text/plain";
+  let h = p;
+  for (let A = 1; A < a.length; A++) a[A] === "base64" ? l = true : a[A] && (h += `;${a[A]}`, a[A].indexOf("charset=") === 0 && (f2 = a[A].substring(8)));
+  !a[0] && !f2.length && (h += ";charset=US-ASCII", f2 = "US-ASCII");
+  const S = l ? "base64" : "ascii", v = unescape(i.substring(o2 + 1)), w = Buffer.from(v, S);
+  return w.type = p, w.typeFull = h, w.charset = f2, w;
+}
+n2(Us, "dataUriToBuffer");
+var pi = {};
+var kt = { exports: {} };
+var xs = kt.exports;
+var bi;
+function Ns() {
+  return bi || (bi = 1, function(i, o2) {
+    (function(a, f2) {
+      f2(o2);
+    })(xs, function(a) {
+      function f2() {
+      }
+      n2(f2, "noop");
+      function l(e) {
+        return typeof e == "object" && e !== null || typeof e == "function";
+      }
+      n2(l, "typeIsObject");
+      const p = f2;
+      function h(e, t2) {
+        try {
+          Object.defineProperty(e, "name", { value: t2, configurable: true });
+        } catch {
+        }
+      }
+      n2(h, "setFunctionName");
+      const S = Promise, v = Promise.prototype.then, w = Promise.reject.bind(S);
+      function A(e) {
+        return new S(e);
+      }
+      n2(A, "newPromise");
+      function T(e) {
+        return A((t2) => t2(e));
+      }
+      n2(T, "promiseResolvedWith");
+      function b(e) {
+        return w(e);
+      }
+      n2(b, "promiseRejectedWith");
+      function q(e, t2, r) {
+        return v.call(e, t2, r);
+      }
+      n2(q, "PerformPromiseThen");
+      function g(e, t2, r) {
+        q(q(e, t2, r), void 0, p);
+      }
+      n2(g, "uponPromise");
+      function V(e, t2) {
+        g(e, t2);
+      }
+      n2(V, "uponFulfillment");
+      function I(e, t2) {
+        g(e, void 0, t2);
+      }
+      n2(I, "uponRejection");
+      function F(e, t2, r) {
+        return q(e, t2, r);
+      }
+      n2(F, "transformPromiseWith");
+      function Q(e) {
+        q(e, void 0, p);
+      }
+      n2(Q, "setPromiseIsHandledToTrue");
+      let ge = n2((e) => {
+        if (typeof queueMicrotask == "function") ge = queueMicrotask;
+        else {
+          const t2 = T(void 0);
+          ge = n2((r) => q(t2, r), "_queueMicrotask");
+        }
+        return ge(e);
+      }, "_queueMicrotask");
+      function z(e, t2, r) {
+        if (typeof e != "function") throw new TypeError("Argument is not a function");
+        return Function.prototype.apply.call(e, t2, r);
+      }
+      n2(z, "reflectCall");
+      function j(e, t2, r) {
+        try {
+          return T(z(e, t2, r));
+        } catch (s) {
+          return b(s);
+        }
+      }
+      n2(j, "promiseCall");
+      const U = 16384, bn = class bn {
+        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(t2) {
+          const r = this._back;
+          let s = r;
+          r._elements.length === U - 1 && (s = { _elements: [], _next: void 0 }), r._elements.push(t2), s !== r && (this._back = s, r._next = s), ++this._size;
+        }
+        shift() {
+          const t2 = this._front;
+          let r = t2;
+          const s = this._cursor;
+          let u = s + 1;
+          const c = t2._elements, d = c[s];
+          return u === U && (r = t2._next, u = 0), --this._size, this._cursor = u, t2 !== r && (this._front = r), c[s] = void 0, d;
+        }
+        forEach(t2) {
+          let r = this._cursor, s = this._front, u = s._elements;
+          for (; (r !== u.length || s._next !== void 0) && !(r === u.length && (s = s._next, u = s._elements, r = 0, u.length === 0)); ) t2(u[r]), ++r;
+        }
+        peek() {
+          const t2 = this._front, r = this._cursor;
+          return t2._elements[r];
+        }
+      };
+      n2(bn, "SimpleQueue");
+      let D = bn;
+      const jt = Symbol("[[AbortSteps]]"), Qn = Symbol("[[ErrorSteps]]"), Ar = Symbol("[[CancelSteps]]"), Br = Symbol("[[PullSteps]]"), kr = Symbol("[[ReleaseSteps]]");
+      function Yn(e, t2) {
+        e._ownerReadableStream = t2, t2._reader = e, t2._state === "readable" ? qr(e) : t2._state === "closed" ? xi(e) : Gn(e, t2._storedError);
+      }
+      n2(Yn, "ReadableStreamReaderGenericInitialize");
+      function Wr(e, t2) {
+        const r = e._ownerReadableStream;
+        return ie(r, t2);
+      }
+      n2(Wr, "ReadableStreamReaderGenericCancel");
+      function _e(e) {
+        const t2 = e._ownerReadableStream;
+        t2._state === "readable" ? Or(e, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")) : Ni(e, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")), t2._readableStreamController[kr](), t2._reader = void 0, e._ownerReadableStream = void 0;
+      }
+      n2(_e, "ReadableStreamReaderGenericRelease");
+      function Lt(e) {
+        return new TypeError("Cannot " + e + " a stream using a released reader");
+      }
+      n2(Lt, "readerLockException");
+      function qr(e) {
+        e._closedPromise = A((t2, r) => {
+          e._closedPromise_resolve = t2, e._closedPromise_reject = r;
+        });
+      }
+      n2(qr, "defaultReaderClosedPromiseInitialize");
+      function Gn(e, t2) {
+        qr(e), Or(e, t2);
+      }
+      n2(Gn, "defaultReaderClosedPromiseInitializeAsRejected");
+      function xi(e) {
+        qr(e), Zn(e);
+      }
+      n2(xi, "defaultReaderClosedPromiseInitializeAsResolved");
+      function Or(e, t2) {
+        e._closedPromise_reject !== void 0 && (Q(e._closedPromise), e._closedPromise_reject(t2), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0);
+      }
+      n2(Or, "defaultReaderClosedPromiseReject");
+      function Ni(e, t2) {
+        Gn(e, t2);
+      }
+      n2(Ni, "defaultReaderClosedPromiseResetToRejected");
+      function Zn(e) {
+        e._closedPromise_resolve !== void 0 && (e._closedPromise_resolve(void 0), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0);
+      }
+      n2(Zn, "defaultReaderClosedPromiseResolve");
+      const Kn = Number.isFinite || function(e) {
+        return typeof e == "number" && isFinite(e);
+      }, Hi = Math.trunc || function(e) {
+        return e < 0 ? Math.ceil(e) : Math.floor(e);
+      };
+      function Vi(e) {
+        return typeof e == "object" || typeof e == "function";
+      }
+      n2(Vi, "isDictionary");
+      function ue(e, t2) {
+        if (e !== void 0 && !Vi(e)) throw new TypeError(`${t2} is not an object.`);
+      }
+      n2(ue, "assertDictionary");
+      function Z(e, t2) {
+        if (typeof e != "function") throw new TypeError(`${t2} is not a function.`);
+      }
+      n2(Z, "assertFunction");
+      function Qi(e) {
+        return typeof e == "object" && e !== null || typeof e == "function";
+      }
+      n2(Qi, "isObject");
+      function Jn(e, t2) {
+        if (!Qi(e)) throw new TypeError(`${t2} is not an object.`);
+      }
+      n2(Jn, "assertObject");
+      function Se(e, t2, r) {
+        if (e === void 0) throw new TypeError(`Parameter ${t2} is required in '${r}'.`);
+      }
+      n2(Se, "assertRequiredArgument");
+      function zr(e, t2, r) {
+        if (e === void 0) throw new TypeError(`${t2} is required in '${r}'.`);
+      }
+      n2(zr, "assertRequiredField");
+      function Ir(e) {
+        return Number(e);
+      }
+      n2(Ir, "convertUnrestrictedDouble");
+      function Xn(e) {
+        return e === 0 ? 0 : e;
+      }
+      n2(Xn, "censorNegativeZero");
+      function Yi(e) {
+        return Xn(Hi(e));
+      }
+      n2(Yi, "integerPart");
+      function Fr(e, t2) {
+        const s = Number.MAX_SAFE_INTEGER;
+        let u = Number(e);
+        if (u = Xn(u), !Kn(u)) throw new TypeError(`${t2} is not a finite number`);
+        if (u = Yi(u), u < 0 || u > s) throw new TypeError(`${t2} is outside the accepted range of 0 to ${s}, inclusive`);
+        return !Kn(u) || u === 0 ? 0 : u;
+      }
+      n2(Fr, "convertUnsignedLongLongWithEnforceRange");
+      function jr(e, t2) {
+        if (!We(e)) throw new TypeError(`${t2} is not a ReadableStream.`);
+      }
+      n2(jr, "assertReadableStream");
+      function Qe(e) {
+        return new fe(e);
+      }
+      n2(Qe, "AcquireReadableStreamDefaultReader");
+      function eo(e, t2) {
+        e._reader._readRequests.push(t2);
+      }
+      n2(eo, "ReadableStreamAddReadRequest");
+      function Lr(e, t2, r) {
+        const u = e._reader._readRequests.shift();
+        r ? u._closeSteps() : u._chunkSteps(t2);
+      }
+      n2(Lr, "ReadableStreamFulfillReadRequest");
+      function $t(e) {
+        return e._reader._readRequests.length;
+      }
+      n2($t, "ReadableStreamGetNumReadRequests");
+      function to(e) {
+        const t2 = e._reader;
+        return !(t2 === void 0 || !Ee(t2));
+      }
+      n2(to, "ReadableStreamHasDefaultReader");
+      const mn = class mn {
+        constructor(t2) {
+          if (Se(t2, 1, "ReadableStreamDefaultReader"), jr(t2, "First parameter"), qe(t2)) throw new TypeError("This stream has already been locked for exclusive reading by another reader");
+          Yn(this, t2), this._readRequests = new D();
+        }
+        get closed() {
+          return Ee(this) ? this._closedPromise : b(Dt("closed"));
+        }
+        cancel(t2 = void 0) {
+          return Ee(this) ? this._ownerReadableStream === void 0 ? b(Lt("cancel")) : Wr(this, t2) : b(Dt("cancel"));
+        }
+        read() {
+          if (!Ee(this)) return b(Dt("read"));
+          if (this._ownerReadableStream === void 0) return b(Lt("read from"));
+          let t2, r;
+          const s = A((c, d) => {
+            t2 = c, r = d;
+          });
+          return _t(this, { _chunkSteps: n2((c) => t2({ value: c, done: false }), "_chunkSteps"), _closeSteps: n2(() => t2({ value: void 0, done: true }), "_closeSteps"), _errorSteps: n2((c) => r(c), "_errorSteps") }), s;
+        }
+        releaseLock() {
+          if (!Ee(this)) throw Dt("releaseLock");
+          this._ownerReadableStream !== void 0 && Gi(this);
+        }
+      };
+      n2(mn, "ReadableStreamDefaultReader");
+      let fe = mn;
+      Object.defineProperties(fe.prototype, { cancel: { enumerable: true }, read: { enumerable: true }, releaseLock: { enumerable: true }, closed: { enumerable: true } }), h(fe.prototype.cancel, "cancel"), h(fe.prototype.read, "read"), h(fe.prototype.releaseLock, "releaseLock"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(fe.prototype, Symbol.toStringTag, { value: "ReadableStreamDefaultReader", configurable: true });
+      function Ee(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_readRequests") ? false : e instanceof fe;
+      }
+      n2(Ee, "IsReadableStreamDefaultReader");
+      function _t(e, t2) {
+        const r = e._ownerReadableStream;
+        r._disturbed = true, r._state === "closed" ? t2._closeSteps() : r._state === "errored" ? t2._errorSteps(r._storedError) : r._readableStreamController[Br](t2);
+      }
+      n2(_t, "ReadableStreamDefaultReaderRead");
+      function Gi(e) {
+        _e(e);
+        const t2 = new TypeError("Reader was released");
+        ro(e, t2);
+      }
+      n2(Gi, "ReadableStreamDefaultReaderRelease");
+      function ro(e, t2) {
+        const r = e._readRequests;
+        e._readRequests = new D(), r.forEach((s) => {
+          s._errorSteps(t2);
+        });
+      }
+      n2(ro, "ReadableStreamDefaultReaderErrorReadRequests");
+      function Dt(e) {
+        return new TypeError(`ReadableStreamDefaultReader.prototype.${e} can only be used on a ReadableStreamDefaultReader`);
+      }
+      n2(Dt, "defaultReaderBrandCheckException");
+      const Zi = Object.getPrototypeOf(Object.getPrototypeOf(async function* () {
+      }).prototype), yn = class yn {
+        constructor(t2, r) {
+          this._ongoingPromise = void 0, this._isFinished = false, this._reader = t2, this._preventCancel = r;
+        }
+        next() {
+          const t2 = n2(() => this._nextSteps(), "nextSteps");
+          return this._ongoingPromise = this._ongoingPromise ? F(this._ongoingPromise, t2, t2) : t2(), this._ongoingPromise;
+        }
+        return(t2) {
+          const r = n2(() => this._returnSteps(t2), "returnSteps");
+          return this._ongoingPromise ? F(this._ongoingPromise, r, r) : r();
+        }
+        _nextSteps() {
+          if (this._isFinished) return Promise.resolve({ value: void 0, done: true });
+          const t2 = this._reader;
+          let r, s;
+          const u = A((d, m) => {
+            r = d, s = m;
+          });
+          return _t(t2, { _chunkSteps: n2((d) => {
+            this._ongoingPromise = void 0, ge(() => r({ value: d, done: false }));
+          }, "_chunkSteps"), _closeSteps: n2(() => {
+            this._ongoingPromise = void 0, this._isFinished = true, _e(t2), r({ value: void 0, done: true });
+          }, "_closeSteps"), _errorSteps: n2((d) => {
+            this._ongoingPromise = void 0, this._isFinished = true, _e(t2), s(d);
+          }, "_errorSteps") }), u;
+        }
+        _returnSteps(t2) {
+          if (this._isFinished) return Promise.resolve({ value: t2, done: true });
+          this._isFinished = true;
+          const r = this._reader;
+          if (!this._preventCancel) {
+            const s = Wr(r, t2);
+            return _e(r), F(s, () => ({ value: t2, done: true }));
+          }
+          return _e(r), T({ value: t2, done: true });
+        }
+      };
+      n2(yn, "ReadableStreamAsyncIteratorImpl");
+      let Mt = yn;
+      const no = { next() {
+        return oo(this) ? this._asyncIteratorImpl.next() : b(io("next"));
+      }, return(e) {
+        return oo(this) ? this._asyncIteratorImpl.return(e) : b(io("return"));
+      } };
+      Object.setPrototypeOf(no, Zi);
+      function Ki(e, t2) {
+        const r = Qe(e), s = new Mt(r, t2), u = Object.create(no);
+        return u._asyncIteratorImpl = s, u;
+      }
+      n2(Ki, "AcquireReadableStreamAsyncIterator");
+      function oo(e) {
+        if (!l(e) || !Object.prototype.hasOwnProperty.call(e, "_asyncIteratorImpl")) return false;
+        try {
+          return e._asyncIteratorImpl instanceof Mt;
+        } catch {
+          return false;
+        }
+      }
+      n2(oo, "IsReadableStreamAsyncIterator");
+      function io(e) {
+        return new TypeError(`ReadableStreamAsyncIterator.${e} can only be used on a ReadableSteamAsyncIterator`);
+      }
+      n2(io, "streamAsyncIteratorBrandCheckException");
+      const ao = Number.isNaN || function(e) {
+        return e !== e;
+      };
+      var $r, Dr, Mr;
+      function St(e) {
+        return e.slice();
+      }
+      n2(St, "CreateArrayFromList");
+      function so(e, t2, r, s, u) {
+        new Uint8Array(e).set(new Uint8Array(r, s, u), t2);
+      }
+      n2(so, "CopyDataBlockBytes");
+      let we = n2((e) => (typeof e.transfer == "function" ? we = n2((t2) => t2.transfer(), "TransferArrayBuffer") : typeof structuredClone == "function" ? we = n2((t2) => structuredClone(t2, { transfer: [t2] }), "TransferArrayBuffer") : we = n2((t2) => t2, "TransferArrayBuffer"), we(e)), "TransferArrayBuffer"), Ae = n2((e) => (typeof e.detached == "boolean" ? Ae = n2((t2) => t2.detached, "IsDetachedBuffer") : Ae = n2((t2) => t2.byteLength === 0, "IsDetachedBuffer"), Ae(e)), "IsDetachedBuffer");
+      function lo(e, t2, r) {
+        if (e.slice) return e.slice(t2, r);
+        const s = r - t2, u = new ArrayBuffer(s);
+        return so(u, 0, e, t2, s), u;
+      }
+      n2(lo, "ArrayBufferSlice");
+      function Ut(e, t2) {
+        const r = e[t2];
+        if (r != null) {
+          if (typeof r != "function") throw new TypeError(`${String(t2)} is not a function`);
+          return r;
+        }
+      }
+      n2(Ut, "GetMethod");
+      function Ji(e) {
+        const t2 = { [Symbol.iterator]: () => e.iterator }, r = async function* () {
+          return yield* t2;
+        }(), s = r.next;
+        return { iterator: r, nextMethod: s, done: false };
+      }
+      n2(Ji, "CreateAsyncFromSyncIterator");
+      const Ur = (Mr = ($r = Symbol.asyncIterator) !== null && $r !== void 0 ? $r : (Dr = Symbol.for) === null || Dr === void 0 ? void 0 : Dr.call(Symbol, "Symbol.asyncIterator")) !== null && Mr !== void 0 ? Mr : "@@asyncIterator";
+      function uo(e, t2 = "sync", r) {
+        if (r === void 0) if (t2 === "async") {
+          if (r = Ut(e, Ur), r === void 0) {
+            const c = Ut(e, Symbol.iterator), d = uo(e, "sync", c);
+            return Ji(d);
+          }
+        } else r = Ut(e, Symbol.iterator);
+        if (r === void 0) throw new TypeError("The object is not iterable");
+        const s = z(r, e, []);
+        if (!l(s)) throw new TypeError("The iterator method must return an object");
+        const u = s.next;
+        return { iterator: s, nextMethod: u, done: false };
+      }
+      n2(uo, "GetIterator");
+      function Xi(e) {
+        const t2 = z(e.nextMethod, e.iterator, []);
+        if (!l(t2)) throw new TypeError("The iterator.next() method must return an object");
+        return t2;
+      }
+      n2(Xi, "IteratorNext");
+      function ea(e) {
+        return !!e.done;
+      }
+      n2(ea, "IteratorComplete");
+      function ta(e) {
+        return e.value;
+      }
+      n2(ta, "IteratorValue");
+      function ra(e) {
+        return !(typeof e != "number" || ao(e) || e < 0);
+      }
+      n2(ra, "IsNonNegativeNumber");
+      function fo(e) {
+        const t2 = lo(e.buffer, e.byteOffset, e.byteOffset + e.byteLength);
+        return new Uint8Array(t2);
+      }
+      n2(fo, "CloneAsUint8Array");
+      function xr(e) {
+        const t2 = e._queue.shift();
+        return e._queueTotalSize -= t2.size, e._queueTotalSize < 0 && (e._queueTotalSize = 0), t2.value;
+      }
+      n2(xr, "DequeueValue");
+      function Nr(e, t2, r) {
+        if (!ra(r) || r === 1 / 0) throw new RangeError("Size must be a finite, non-NaN, non-negative number.");
+        e._queue.push({ value: t2, size: r }), e._queueTotalSize += r;
+      }
+      n2(Nr, "EnqueueValueWithSize");
+      function na(e) {
+        return e._queue.peek().value;
+      }
+      n2(na, "PeekQueueValue");
+      function Be(e) {
+        e._queue = new D(), e._queueTotalSize = 0;
+      }
+      n2(Be, "ResetQueue");
+      function co(e) {
+        return e === DataView;
+      }
+      n2(co, "isDataViewConstructor");
+      function oa(e) {
+        return co(e.constructor);
+      }
+      n2(oa, "isDataView");
+      function ia(e) {
+        return co(e) ? 1 : e.BYTES_PER_ELEMENT;
+      }
+      n2(ia, "arrayBufferViewElementSize");
+      const gn = class gn {
+        constructor() {
+          throw new TypeError("Illegal constructor");
+        }
+        get view() {
+          if (!Hr(this)) throw Zr("view");
+          return this._view;
+        }
+        respond(t2) {
+          if (!Hr(this)) throw Zr("respond");
+          if (Se(t2, 1, "respond"), t2 = Fr(t2, "First parameter"), this._associatedReadableByteStreamController === void 0) throw new TypeError("This BYOB request has been invalidated");
+          if (Ae(this._view.buffer)) throw new TypeError("The BYOB request's buffer has been detached and so cannot be used as a response");
+          Vt(this._associatedReadableByteStreamController, t2);
+        }
+        respondWithNewView(t2) {
+          if (!Hr(this)) throw Zr("respondWithNewView");
+          if (Se(t2, 1, "respondWithNewView"), !ArrayBuffer.isView(t2)) throw new TypeError("You can only respond with array buffer views");
+          if (this._associatedReadableByteStreamController === void 0) throw new TypeError("This BYOB request has been invalidated");
+          if (Ae(t2.buffer)) throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");
+          Qt(this._associatedReadableByteStreamController, t2);
+        }
+      };
+      n2(gn, "ReadableStreamBYOBRequest");
+      let Re = gn;
+      Object.defineProperties(Re.prototype, { respond: { enumerable: true }, respondWithNewView: { enumerable: true }, view: { enumerable: true } }), h(Re.prototype.respond, "respond"), h(Re.prototype.respondWithNewView, "respondWithNewView"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(Re.prototype, Symbol.toStringTag, { value: "ReadableStreamBYOBRequest", configurable: true });
+      const _n = class _n {
+        constructor() {
+          throw new TypeError("Illegal constructor");
+        }
+        get byobRequest() {
+          if (!Ie(this)) throw Rt("byobRequest");
+          return Gr(this);
+        }
+        get desiredSize() {
+          if (!Ie(this)) throw Rt("desiredSize");
+          return Ro(this);
+        }
+        close() {
+          if (!Ie(this)) throw Rt("close");
+          if (this._closeRequested) throw new TypeError("The stream has already been closed; do not close it again!");
+          const t2 = this._controlledReadableByteStream._state;
+          if (t2 !== "readable") throw new TypeError(`The stream (in ${t2} state) is not in the readable state and cannot be closed`);
+          wt(this);
+        }
+        enqueue(t2) {
+          if (!Ie(this)) throw Rt("enqueue");
+          if (Se(t2, 1, "enqueue"), !ArrayBuffer.isView(t2)) throw new TypeError("chunk must be an array buffer view");
+          if (t2.byteLength === 0) throw new TypeError("chunk must have non-zero byteLength");
+          if (t2.buffer.byteLength === 0) throw new TypeError("chunk's buffer must have non-zero byteLength");
+          if (this._closeRequested) throw new TypeError("stream is closed or draining");
+          const r = this._controlledReadableByteStream._state;
+          if (r !== "readable") throw new TypeError(`The stream (in ${r} state) is not in the readable state and cannot be enqueued to`);
+          Ht(this, t2);
+        }
+        error(t2 = void 0) {
+          if (!Ie(this)) throw Rt("error");
+          K(this, t2);
+        }
+        [Ar](t2) {
+          ho(this), Be(this);
+          const r = this._cancelAlgorithm(t2);
+          return Nt(this), r;
+        }
+        [Br](t2) {
+          const r = this._controlledReadableByteStream;
+          if (this._queueTotalSize > 0) {
+            wo(this, t2);
+            return;
+          }
+          const s = this._autoAllocateChunkSize;
+          if (s !== void 0) {
+            let u;
+            try {
+              u = new ArrayBuffer(s);
+            } catch (d) {
+              t2._errorSteps(d);
+              return;
+            }
+            const c = { buffer: u, bufferByteLength: s, byteOffset: 0, byteLength: s, bytesFilled: 0, minimumFill: 1, elementSize: 1, viewConstructor: Uint8Array, readerType: "default" };
+            this._pendingPullIntos.push(c);
+          }
+          eo(r, t2), Fe(this);
+        }
+        [kr]() {
+          if (this._pendingPullIntos.length > 0) {
+            const t2 = this._pendingPullIntos.peek();
+            t2.readerType = "none", this._pendingPullIntos = new D(), this._pendingPullIntos.push(t2);
+          }
+        }
+      };
+      n2(_n, "ReadableByteStreamController");
+      let te = _n;
+      Object.defineProperties(te.prototype, { close: { enumerable: true }, enqueue: { enumerable: true }, error: { enumerable: true }, byobRequest: { enumerable: true }, desiredSize: { enumerable: true } }), h(te.prototype.close, "close"), h(te.prototype.enqueue, "enqueue"), h(te.prototype.error, "error"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(te.prototype, Symbol.toStringTag, { value: "ReadableByteStreamController", configurable: true });
+      function Ie(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_controlledReadableByteStream") ? false : e instanceof te;
+      }
+      n2(Ie, "IsReadableByteStreamController");
+      function Hr(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_associatedReadableByteStreamController") ? false : e instanceof Re;
+      }
+      n2(Hr, "IsReadableStreamBYOBRequest");
+      function Fe(e) {
+        if (!fa(e)) return;
+        if (e._pulling) {
+          e._pullAgain = true;
+          return;
+        }
+        e._pulling = true;
+        const r = e._pullAlgorithm();
+        g(r, () => (e._pulling = false, e._pullAgain && (e._pullAgain = false, Fe(e)), null), (s) => (K(e, s), null));
+      }
+      n2(Fe, "ReadableByteStreamControllerCallPullIfNeeded");
+      function ho(e) {
+        Qr(e), e._pendingPullIntos = new D();
+      }
+      n2(ho, "ReadableByteStreamControllerClearPendingPullIntos");
+      function Vr(e, t2) {
+        let r = false;
+        e._state === "closed" && (r = true);
+        const s = po(t2);
+        t2.readerType === "default" ? Lr(e, s, r) : ma(e, s, r);
+      }
+      n2(Vr, "ReadableByteStreamControllerCommitPullIntoDescriptor");
+      function po(e) {
+        const t2 = e.bytesFilled, r = e.elementSize;
+        return new e.viewConstructor(e.buffer, e.byteOffset, t2 / r);
+      }
+      n2(po, "ReadableByteStreamControllerConvertPullIntoDescriptor");
+      function xt(e, t2, r, s) {
+        e._queue.push({ buffer: t2, byteOffset: r, byteLength: s }), e._queueTotalSize += s;
+      }
+      n2(xt, "ReadableByteStreamControllerEnqueueChunkToQueue");
+      function bo(e, t2, r, s) {
+        let u;
+        try {
+          u = lo(t2, r, r + s);
+        } catch (c) {
+          throw K(e, c), c;
+        }
+        xt(e, u, 0, s);
+      }
+      n2(bo, "ReadableByteStreamControllerEnqueueClonedChunkToQueue");
+      function mo(e, t2) {
+        t2.bytesFilled > 0 && bo(e, t2.buffer, t2.byteOffset, t2.bytesFilled), Ye(e);
+      }
+      n2(mo, "ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue");
+      function yo(e, t2) {
+        const r = Math.min(e._queueTotalSize, t2.byteLength - t2.bytesFilled), s = t2.bytesFilled + r;
+        let u = r, c = false;
+        const d = s % t2.elementSize, m = s - d;
+        m >= t2.minimumFill && (u = m - t2.bytesFilled, c = true);
+        const R = e._queue;
+        for (; u > 0; ) {
+          const y = R.peek(), C = Math.min(u, y.byteLength), P = t2.byteOffset + t2.bytesFilled;
+          so(t2.buffer, P, y.buffer, y.byteOffset, C), y.byteLength === C ? R.shift() : (y.byteOffset += C, y.byteLength -= C), e._queueTotalSize -= C, go(e, C, t2), u -= C;
+        }
+        return c;
+      }
+      n2(yo, "ReadableByteStreamControllerFillPullIntoDescriptorFromQueue");
+      function go(e, t2, r) {
+        r.bytesFilled += t2;
+      }
+      n2(go, "ReadableByteStreamControllerFillHeadPullIntoDescriptor");
+      function _o(e) {
+        e._queueTotalSize === 0 && e._closeRequested ? (Nt(e), At(e._controlledReadableByteStream)) : Fe(e);
+      }
+      n2(_o, "ReadableByteStreamControllerHandleQueueDrain");
+      function Qr(e) {
+        e._byobRequest !== null && (e._byobRequest._associatedReadableByteStreamController = void 0, e._byobRequest._view = null, e._byobRequest = null);
+      }
+      n2(Qr, "ReadableByteStreamControllerInvalidateBYOBRequest");
+      function Yr(e) {
+        for (; e._pendingPullIntos.length > 0; ) {
+          if (e._queueTotalSize === 0) return;
+          const t2 = e._pendingPullIntos.peek();
+          yo(e, t2) && (Ye(e), Vr(e._controlledReadableByteStream, t2));
+        }
+      }
+      n2(Yr, "ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue");
+      function aa(e) {
+        const t2 = e._controlledReadableByteStream._reader;
+        for (; t2._readRequests.length > 0; ) {
+          if (e._queueTotalSize === 0) return;
+          const r = t2._readRequests.shift();
+          wo(e, r);
+        }
+      }
+      n2(aa, "ReadableByteStreamControllerProcessReadRequestsUsingQueue");
+      function sa(e, t2, r, s) {
+        const u = e._controlledReadableByteStream, c = t2.constructor, d = ia(c), { byteOffset: m, byteLength: R } = t2, y = r * d;
+        let C;
+        try {
+          C = we(t2.buffer);
+        } catch (B) {
+          s._errorSteps(B);
+          return;
+        }
+        const P = { buffer: C, bufferByteLength: C.byteLength, byteOffset: m, byteLength: R, bytesFilled: 0, minimumFill: y, elementSize: d, viewConstructor: c, readerType: "byob" };
+        if (e._pendingPullIntos.length > 0) {
+          e._pendingPullIntos.push(P), Po(u, s);
+          return;
+        }
+        if (u._state === "closed") {
+          const B = new c(P.buffer, P.byteOffset, 0);
+          s._closeSteps(B);
+          return;
+        }
+        if (e._queueTotalSize > 0) {
+          if (yo(e, P)) {
+            const B = po(P);
+            _o(e), s._chunkSteps(B);
+            return;
+          }
+          if (e._closeRequested) {
+            const B = new TypeError("Insufficient bytes to fill elements in the given buffer");
+            K(e, B), s._errorSteps(B);
+            return;
+          }
+        }
+        e._pendingPullIntos.push(P), Po(u, s), Fe(e);
+      }
+      n2(sa, "ReadableByteStreamControllerPullInto");
+      function la(e, t2) {
+        t2.readerType === "none" && Ye(e);
+        const r = e._controlledReadableByteStream;
+        if (Kr(r)) for (; vo(r) > 0; ) {
+          const s = Ye(e);
+          Vr(r, s);
+        }
+      }
+      n2(la, "ReadableByteStreamControllerRespondInClosedState");
+      function ua(e, t2, r) {
+        if (go(e, t2, r), r.readerType === "none") {
+          mo(e, r), Yr(e);
+          return;
+        }
+        if (r.bytesFilled < r.minimumFill) return;
+        Ye(e);
+        const s = r.bytesFilled % r.elementSize;
+        if (s > 0) {
+          const u = r.byteOffset + r.bytesFilled;
+          bo(e, r.buffer, u - s, s);
+        }
+        r.bytesFilled -= s, Vr(e._controlledReadableByteStream, r), Yr(e);
+      }
+      n2(ua, "ReadableByteStreamControllerRespondInReadableState");
+      function So(e, t2) {
+        const r = e._pendingPullIntos.peek();
+        Qr(e), e._controlledReadableByteStream._state === "closed" ? la(e, r) : ua(e, t2, r), Fe(e);
+      }
+      n2(So, "ReadableByteStreamControllerRespondInternal");
+      function Ye(e) {
+        return e._pendingPullIntos.shift();
+      }
+      n2(Ye, "ReadableByteStreamControllerShiftPendingPullInto");
+      function fa(e) {
+        const t2 = e._controlledReadableByteStream;
+        return t2._state !== "readable" || e._closeRequested || !e._started ? false : !!(to(t2) && $t(t2) > 0 || Kr(t2) && vo(t2) > 0 || Ro(e) > 0);
+      }
+      n2(fa, "ReadableByteStreamControllerShouldCallPull");
+      function Nt(e) {
+        e._pullAlgorithm = void 0, e._cancelAlgorithm = void 0;
+      }
+      n2(Nt, "ReadableByteStreamControllerClearAlgorithms");
+      function wt(e) {
+        const t2 = e._controlledReadableByteStream;
+        if (!(e._closeRequested || t2._state !== "readable")) {
+          if (e._queueTotalSize > 0) {
+            e._closeRequested = true;
+            return;
+          }
+          if (e._pendingPullIntos.length > 0) {
+            const r = e._pendingPullIntos.peek();
+            if (r.bytesFilled % r.elementSize !== 0) {
+              const s = new TypeError("Insufficient bytes to fill elements in the given buffer");
+              throw K(e, s), s;
+            }
+          }
+          Nt(e), At(t2);
+        }
+      }
+      n2(wt, "ReadableByteStreamControllerClose");
+      function Ht(e, t2) {
+        const r = e._controlledReadableByteStream;
+        if (e._closeRequested || r._state !== "readable") return;
+        const { buffer: s, byteOffset: u, byteLength: c } = t2;
+        if (Ae(s)) throw new TypeError("chunk's buffer is detached and so cannot be enqueued");
+        const d = we(s);
+        if (e._pendingPullIntos.length > 0) {
+          const m = e._pendingPullIntos.peek();
+          if (Ae(m.buffer)) throw new TypeError("The BYOB request's buffer has been detached and so cannot be filled with an enqueued chunk");
+          Qr(e), m.buffer = we(m.buffer), m.readerType === "none" && mo(e, m);
+        }
+        if (to(r)) if (aa(e), $t(r) === 0) xt(e, d, u, c);
+        else {
+          e._pendingPullIntos.length > 0 && Ye(e);
+          const m = new Uint8Array(d, u, c);
+          Lr(r, m, false);
+        }
+        else Kr(r) ? (xt(e, d, u, c), Yr(e)) : xt(e, d, u, c);
+        Fe(e);
+      }
+      n2(Ht, "ReadableByteStreamControllerEnqueue");
+      function K(e, t2) {
+        const r = e._controlledReadableByteStream;
+        r._state === "readable" && (ho(e), Be(e), Nt(e), Zo(r, t2));
+      }
+      n2(K, "ReadableByteStreamControllerError");
+      function wo(e, t2) {
+        const r = e._queue.shift();
+        e._queueTotalSize -= r.byteLength, _o(e);
+        const s = new Uint8Array(r.buffer, r.byteOffset, r.byteLength);
+        t2._chunkSteps(s);
+      }
+      n2(wo, "ReadableByteStreamControllerFillReadRequestFromQueue");
+      function Gr(e) {
+        if (e._byobRequest === null && e._pendingPullIntos.length > 0) {
+          const t2 = e._pendingPullIntos.peek(), r = new Uint8Array(t2.buffer, t2.byteOffset + t2.bytesFilled, t2.byteLength - t2.bytesFilled), s = Object.create(Re.prototype);
+          da(s, e, r), e._byobRequest = s;
+        }
+        return e._byobRequest;
+      }
+      n2(Gr, "ReadableByteStreamControllerGetBYOBRequest");
+      function Ro(e) {
+        const t2 = e._controlledReadableByteStream._state;
+        return t2 === "errored" ? null : t2 === "closed" ? 0 : e._strategyHWM - e._queueTotalSize;
+      }
+      n2(Ro, "ReadableByteStreamControllerGetDesiredSize");
+      function Vt(e, t2) {
+        const r = e._pendingPullIntos.peek();
+        if (e._controlledReadableByteStream._state === "closed") {
+          if (t2 !== 0) throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream");
+        } else {
+          if (t2 === 0) throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");
+          if (r.bytesFilled + t2 > r.byteLength) throw new RangeError("bytesWritten out of range");
+        }
+        r.buffer = we(r.buffer), So(e, t2);
+      }
+      n2(Vt, "ReadableByteStreamControllerRespond");
+      function Qt(e, t2) {
+        const r = e._pendingPullIntos.peek();
+        if (e._controlledReadableByteStream._state === "closed") {
+          if (t2.byteLength !== 0) throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream");
+        } else if (t2.byteLength === 0) throw new TypeError("The view's length must be greater than 0 when calling respondWithNewView() on a readable stream");
+        if (r.byteOffset + r.bytesFilled !== t2.byteOffset) throw new RangeError("The region specified by view does not match byobRequest");
+        if (r.bufferByteLength !== t2.buffer.byteLength) throw new RangeError("The buffer of view has different capacity than byobRequest");
+        if (r.bytesFilled + t2.byteLength > r.byteLength) throw new RangeError("The region specified by view is larger than byobRequest");
+        const u = t2.byteLength;
+        r.buffer = we(t2.buffer), So(e, u);
+      }
+      n2(Qt, "ReadableByteStreamControllerRespondWithNewView");
+      function To(e, t2, r, s, u, c, d) {
+        t2._controlledReadableByteStream = e, t2._pullAgain = false, t2._pulling = false, t2._byobRequest = null, t2._queue = t2._queueTotalSize = void 0, Be(t2), t2._closeRequested = false, t2._started = false, t2._strategyHWM = c, t2._pullAlgorithm = s, t2._cancelAlgorithm = u, t2._autoAllocateChunkSize = d, t2._pendingPullIntos = new D(), e._readableStreamController = t2;
+        const m = r();
+        g(T(m), () => (t2._started = true, Fe(t2), null), (R) => (K(t2, R), null));
+      }
+      n2(To, "SetUpReadableByteStreamController");
+      function ca(e, t2, r) {
+        const s = Object.create(te.prototype);
+        let u, c, d;
+        t2.start !== void 0 ? u = n2(() => t2.start(s), "startAlgorithm") : u = n2(() => {
+        }, "startAlgorithm"), t2.pull !== void 0 ? c = n2(() => t2.pull(s), "pullAlgorithm") : c = n2(() => T(void 0), "pullAlgorithm"), t2.cancel !== void 0 ? d = n2((R) => t2.cancel(R), "cancelAlgorithm") : d = n2(() => T(void 0), "cancelAlgorithm");
+        const m = t2.autoAllocateChunkSize;
+        if (m === 0) throw new TypeError("autoAllocateChunkSize must be greater than 0");
+        To(e, s, u, c, d, r, m);
+      }
+      n2(ca, "SetUpReadableByteStreamControllerFromUnderlyingSource");
+      function da(e, t2, r) {
+        e._associatedReadableByteStreamController = t2, e._view = r;
+      }
+      n2(da, "SetUpReadableStreamBYOBRequest");
+      function Zr(e) {
+        return new TypeError(`ReadableStreamBYOBRequest.prototype.${e} can only be used on a ReadableStreamBYOBRequest`);
+      }
+      n2(Zr, "byobRequestBrandCheckException");
+      function Rt(e) {
+        return new TypeError(`ReadableByteStreamController.prototype.${e} can only be used on a ReadableByteStreamController`);
+      }
+      n2(Rt, "byteStreamControllerBrandCheckException");
+      function ha(e, t2) {
+        ue(e, t2);
+        const r = e?.mode;
+        return { mode: r === void 0 ? void 0 : pa(r, `${t2} has member 'mode' that`) };
+      }
+      n2(ha, "convertReaderOptions");
+      function pa(e, t2) {
+        if (e = `${e}`, e !== "byob") throw new TypeError(`${t2} '${e}' is not a valid enumeration value for ReadableStreamReaderMode`);
+        return e;
+      }
+      n2(pa, "convertReadableStreamReaderMode");
+      function ba(e, t2) {
+        var r;
+        ue(e, t2);
+        const s = (r = e?.min) !== null && r !== void 0 ? r : 1;
+        return { min: Fr(s, `${t2} has member 'min' that`) };
+      }
+      n2(ba, "convertByobReadOptions");
+      function Co(e) {
+        return new ce(e);
+      }
+      n2(Co, "AcquireReadableStreamBYOBReader");
+      function Po(e, t2) {
+        e._reader._readIntoRequests.push(t2);
+      }
+      n2(Po, "ReadableStreamAddReadIntoRequest");
+      function ma(e, t2, r) {
+        const u = e._reader._readIntoRequests.shift();
+        r ? u._closeSteps(t2) : u._chunkSteps(t2);
+      }
+      n2(ma, "ReadableStreamFulfillReadIntoRequest");
+      function vo(e) {
+        return e._reader._readIntoRequests.length;
+      }
+      n2(vo, "ReadableStreamGetNumReadIntoRequests");
+      function Kr(e) {
+        const t2 = e._reader;
+        return !(t2 === void 0 || !je(t2));
+      }
+      n2(Kr, "ReadableStreamHasBYOBReader");
+      const Sn = class Sn {
+        constructor(t2) {
+          if (Se(t2, 1, "ReadableStreamBYOBReader"), jr(t2, "First parameter"), qe(t2)) throw new TypeError("This stream has already been locked for exclusive reading by another reader");
+          if (!Ie(t2._readableStreamController)) throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");
+          Yn(this, t2), this._readIntoRequests = new D();
+        }
+        get closed() {
+          return je(this) ? this._closedPromise : b(Yt("closed"));
+        }
+        cancel(t2 = void 0) {
+          return je(this) ? this._ownerReadableStream === void 0 ? b(Lt("cancel")) : Wr(this, t2) : b(Yt("cancel"));
+        }
+        read(t2, r = {}) {
+          if (!je(this)) return b(Yt("read"));
+          if (!ArrayBuffer.isView(t2)) return b(new TypeError("view must be an array buffer view"));
+          if (t2.byteLength === 0) return b(new TypeError("view must have non-zero byteLength"));
+          if (t2.buffer.byteLength === 0) return b(new TypeError("view's buffer must have non-zero byteLength"));
+          if (Ae(t2.buffer)) return b(new TypeError("view's buffer has been detached"));
+          let s;
+          try {
+            s = ba(r, "options");
+          } catch (y) {
+            return b(y);
+          }
+          const u = s.min;
+          if (u === 0) return b(new TypeError("options.min must be greater than 0"));
+          if (oa(t2)) {
+            if (u > t2.byteLength) return b(new RangeError("options.min must be less than or equal to view's byteLength"));
+          } else if (u > t2.length) return b(new RangeError("options.min must be less than or equal to view's length"));
+          if (this._ownerReadableStream === void 0) return b(Lt("read from"));
+          let c, d;
+          const m = A((y, C) => {
+            c = y, d = C;
+          });
+          return Eo(this, t2, u, { _chunkSteps: n2((y) => c({ value: y, done: false }), "_chunkSteps"), _closeSteps: n2((y) => c({ value: y, done: true }), "_closeSteps"), _errorSteps: n2((y) => d(y), "_errorSteps") }), m;
+        }
+        releaseLock() {
+          if (!je(this)) throw Yt("releaseLock");
+          this._ownerReadableStream !== void 0 && ya(this);
+        }
+      };
+      n2(Sn, "ReadableStreamBYOBReader");
+      let ce = Sn;
+      Object.defineProperties(ce.prototype, { cancel: { enumerable: true }, read: { enumerable: true }, releaseLock: { enumerable: true }, closed: { enumerable: true } }), h(ce.prototype.cancel, "cancel"), h(ce.prototype.read, "read"), h(ce.prototype.releaseLock, "releaseLock"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(ce.prototype, Symbol.toStringTag, { value: "ReadableStreamBYOBReader", configurable: true });
+      function je(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_readIntoRequests") ? false : e instanceof ce;
+      }
+      n2(je, "IsReadableStreamBYOBReader");
+      function Eo(e, t2, r, s) {
+        const u = e._ownerReadableStream;
+        u._disturbed = true, u._state === "errored" ? s._errorSteps(u._storedError) : sa(u._readableStreamController, t2, r, s);
+      }
+      n2(Eo, "ReadableStreamBYOBReaderRead");
+      function ya(e) {
+        _e(e);
+        const t2 = new TypeError("Reader was released");
+        Ao(e, t2);
+      }
+      n2(ya, "ReadableStreamBYOBReaderRelease");
+      function Ao(e, t2) {
+        const r = e._readIntoRequests;
+        e._readIntoRequests = new D(), r.forEach((s) => {
+          s._errorSteps(t2);
+        });
+      }
+      n2(Ao, "ReadableStreamBYOBReaderErrorReadIntoRequests");
+      function Yt(e) {
+        return new TypeError(`ReadableStreamBYOBReader.prototype.${e} can only be used on a ReadableStreamBYOBReader`);
+      }
+      n2(Yt, "byobReaderBrandCheckException");
+      function Tt(e, t2) {
+        const { highWaterMark: r } = e;
+        if (r === void 0) return t2;
+        if (ao(r) || r < 0) throw new RangeError("Invalid highWaterMark");
+        return r;
+      }
+      n2(Tt, "ExtractHighWaterMark");
+      function Gt(e) {
+        const { size: t2 } = e;
+        return t2 || (() => 1);
+      }
+      n2(Gt, "ExtractSizeAlgorithm");
+      function Zt(e, t2) {
+        ue(e, t2);
+        const r = e?.highWaterMark, s = e?.size;
+        return { highWaterMark: r === void 0 ? void 0 : Ir(r), size: s === void 0 ? void 0 : ga(s, `${t2} has member 'size' that`) };
+      }
+      n2(Zt, "convertQueuingStrategy");
+      function ga(e, t2) {
+        return Z(e, t2), (r) => Ir(e(r));
+      }
+      n2(ga, "convertQueuingStrategySize");
+      function _a(e, t2) {
+        ue(e, t2);
+        const r = e?.abort, s = e?.close, u = e?.start, c = e?.type, d = e?.write;
+        return { abort: r === void 0 ? void 0 : Sa(r, e, `${t2} has member 'abort' that`), close: s === void 0 ? void 0 : wa(s, e, `${t2} has member 'close' that`), start: u === void 0 ? void 0 : Ra(u, e, `${t2} has member 'start' that`), write: d === void 0 ? void 0 : Ta(d, e, `${t2} has member 'write' that`), type: c };
+      }
+      n2(_a, "convertUnderlyingSink");
+      function Sa(e, t2, r) {
+        return Z(e, r), (s) => j(e, t2, [s]);
+      }
+      n2(Sa, "convertUnderlyingSinkAbortCallback");
+      function wa(e, t2, r) {
+        return Z(e, r), () => j(e, t2, []);
+      }
+      n2(wa, "convertUnderlyingSinkCloseCallback");
+      function Ra(e, t2, r) {
+        return Z(e, r), (s) => z(e, t2, [s]);
+      }
+      n2(Ra, "convertUnderlyingSinkStartCallback");
+      function Ta(e, t2, r) {
+        return Z(e, r), (s, u) => j(e, t2, [s, u]);
+      }
+      n2(Ta, "convertUnderlyingSinkWriteCallback");
+      function Bo(e, t2) {
+        if (!Ge(e)) throw new TypeError(`${t2} is not a WritableStream.`);
+      }
+      n2(Bo, "assertWritableStream");
+      function Ca(e) {
+        if (typeof e != "object" || e === null) return false;
+        try {
+          return typeof e.aborted == "boolean";
+        } catch {
+          return false;
+        }
+      }
+      n2(Ca, "isAbortSignal");
+      const Pa = typeof AbortController == "function";
+      function va() {
+        if (Pa) return new AbortController();
+      }
+      n2(va, "createAbortController");
+      const wn = class wn {
+        constructor(t2 = {}, r = {}) {
+          t2 === void 0 ? t2 = null : Jn(t2, "First parameter");
+          const s = Zt(r, "Second parameter"), u = _a(t2, "First parameter");
+          if (Wo(this), u.type !== void 0) throw new RangeError("Invalid type is specified");
+          const d = Gt(s), m = Tt(s, 1);
+          Da(this, u, m, d);
+        }
+        get locked() {
+          if (!Ge(this)) throw tr("locked");
+          return Ze(this);
+        }
+        abort(t2 = void 0) {
+          return Ge(this) ? Ze(this) ? b(new TypeError("Cannot abort a stream that already has a writer")) : Kt(this, t2) : b(tr("abort"));
+        }
+        close() {
+          return Ge(this) ? Ze(this) ? b(new TypeError("Cannot close a stream that already has a writer")) : he(this) ? b(new TypeError("Cannot close an already-closing stream")) : qo(this) : b(tr("close"));
+        }
+        getWriter() {
+          if (!Ge(this)) throw tr("getWriter");
+          return ko(this);
+        }
+      };
+      n2(wn, "WritableStream");
+      let de = wn;
+      Object.defineProperties(de.prototype, { abort: { enumerable: true }, close: { enumerable: true }, getWriter: { enumerable: true }, locked: { enumerable: true } }), h(de.prototype.abort, "abort"), h(de.prototype.close, "close"), h(de.prototype.getWriter, "getWriter"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(de.prototype, Symbol.toStringTag, { value: "WritableStream", configurable: true });
+      function ko(e) {
+        return new re(e);
+      }
+      n2(ko, "AcquireWritableStreamDefaultWriter");
+      function Ea(e, t2, r, s, u = 1, c = () => 1) {
+        const d = Object.create(de.prototype);
+        Wo(d);
+        const m = Object.create(ke.prototype);
+        return Lo(d, m, e, t2, r, s, u, c), d;
+      }
+      n2(Ea, "CreateWritableStream");
+      function Wo(e) {
+        e._state = "writable", e._storedError = void 0, e._writer = void 0, e._writableStreamController = void 0, e._writeRequests = new D(), e._inFlightWriteRequest = void 0, e._closeRequest = void 0, e._inFlightCloseRequest = void 0, e._pendingAbortRequest = void 0, e._backpressure = false;
+      }
+      n2(Wo, "InitializeWritableStream");
+      function Ge(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_writableStreamController") ? false : e instanceof de;
+      }
+      n2(Ge, "IsWritableStream");
+      function Ze(e) {
+        return e._writer !== void 0;
+      }
+      n2(Ze, "IsWritableStreamLocked");
+      function Kt(e, t2) {
+        var r;
+        if (e._state === "closed" || e._state === "errored") return T(void 0);
+        e._writableStreamController._abortReason = t2, (r = e._writableStreamController._abortController) === null || r === void 0 || r.abort(t2);
+        const s = e._state;
+        if (s === "closed" || s === "errored") return T(void 0);
+        if (e._pendingAbortRequest !== void 0) return e._pendingAbortRequest._promise;
+        let u = false;
+        s === "erroring" && (u = true, t2 = void 0);
+        const c = A((d, m) => {
+          e._pendingAbortRequest = { _promise: void 0, _resolve: d, _reject: m, _reason: t2, _wasAlreadyErroring: u };
+        });
+        return e._pendingAbortRequest._promise = c, u || Xr(e, t2), c;
+      }
+      n2(Kt, "WritableStreamAbort");
+      function qo(e) {
+        const t2 = e._state;
+        if (t2 === "closed" || t2 === "errored") return b(new TypeError(`The stream (in ${t2} state) is not in the writable state and cannot be closed`));
+        const r = A((u, c) => {
+          const d = { _resolve: u, _reject: c };
+          e._closeRequest = d;
+        }), s = e._writer;
+        return s !== void 0 && e._backpressure && t2 === "writable" && ln(s), Ma(e._writableStreamController), r;
+      }
+      n2(qo, "WritableStreamClose");
+      function Aa(e) {
+        return A((r, s) => {
+          const u = { _resolve: r, _reject: s };
+          e._writeRequests.push(u);
+        });
+      }
+      n2(Aa, "WritableStreamAddWriteRequest");
+      function Jr(e, t2) {
+        if (e._state === "writable") {
+          Xr(e, t2);
+          return;
+        }
+        en(e);
+      }
+      n2(Jr, "WritableStreamDealWithRejection");
+      function Xr(e, t2) {
+        const r = e._writableStreamController;
+        e._state = "erroring", e._storedError = t2;
+        const s = e._writer;
+        s !== void 0 && zo(s, t2), !Oa(e) && r._started && en(e);
+      }
+      n2(Xr, "WritableStreamStartErroring");
+      function en(e) {
+        e._state = "errored", e._writableStreamController[Qn]();
+        const t2 = e._storedError;
+        if (e._writeRequests.forEach((u) => {
+          u._reject(t2);
+        }), e._writeRequests = new D(), e._pendingAbortRequest === void 0) {
+          Jt(e);
+          return;
+        }
+        const r = e._pendingAbortRequest;
+        if (e._pendingAbortRequest = void 0, r._wasAlreadyErroring) {
+          r._reject(t2), Jt(e);
+          return;
+        }
+        const s = e._writableStreamController[jt](r._reason);
+        g(s, () => (r._resolve(), Jt(e), null), (u) => (r._reject(u), Jt(e), null));
+      }
+      n2(en, "WritableStreamFinishErroring");
+      function Ba(e) {
+        e._inFlightWriteRequest._resolve(void 0), e._inFlightWriteRequest = void 0;
+      }
+      n2(Ba, "WritableStreamFinishInFlightWrite");
+      function ka(e, t2) {
+        e._inFlightWriteRequest._reject(t2), e._inFlightWriteRequest = void 0, Jr(e, t2);
+      }
+      n2(ka, "WritableStreamFinishInFlightWriteWithError");
+      function Wa(e) {
+        e._inFlightCloseRequest._resolve(void 0), e._inFlightCloseRequest = void 0, e._state === "erroring" && (e._storedError = void 0, e._pendingAbortRequest !== void 0 && (e._pendingAbortRequest._resolve(), e._pendingAbortRequest = void 0)), e._state = "closed";
+        const r = e._writer;
+        r !== void 0 && Uo(r);
+      }
+      n2(Wa, "WritableStreamFinishInFlightClose");
+      function qa(e, t2) {
+        e._inFlightCloseRequest._reject(t2), e._inFlightCloseRequest = void 0, e._pendingAbortRequest !== void 0 && (e._pendingAbortRequest._reject(t2), e._pendingAbortRequest = void 0), Jr(e, t2);
+      }
+      n2(qa, "WritableStreamFinishInFlightCloseWithError");
+      function he(e) {
+        return !(e._closeRequest === void 0 && e._inFlightCloseRequest === void 0);
+      }
+      n2(he, "WritableStreamCloseQueuedOrInFlight");
+      function Oa(e) {
+        return !(e._inFlightWriteRequest === void 0 && e._inFlightCloseRequest === void 0);
+      }
+      n2(Oa, "WritableStreamHasOperationMarkedInFlight");
+      function za(e) {
+        e._inFlightCloseRequest = e._closeRequest, e._closeRequest = void 0;
+      }
+      n2(za, "WritableStreamMarkCloseRequestInFlight");
+      function Ia(e) {
+        e._inFlightWriteRequest = e._writeRequests.shift();
+      }
+      n2(Ia, "WritableStreamMarkFirstWriteRequestInFlight");
+      function Jt(e) {
+        e._closeRequest !== void 0 && (e._closeRequest._reject(e._storedError), e._closeRequest = void 0);
+        const t2 = e._writer;
+        t2 !== void 0 && an(t2, e._storedError);
+      }
+      n2(Jt, "WritableStreamRejectCloseAndClosedPromiseIfNeeded");
+      function tn(e, t2) {
+        const r = e._writer;
+        r !== void 0 && t2 !== e._backpressure && (t2 ? Ya(r) : ln(r)), e._backpressure = t2;
+      }
+      n2(tn, "WritableStreamUpdateBackpressure");
+      const Rn = class Rn {
+        constructor(t2) {
+          if (Se(t2, 1, "WritableStreamDefaultWriter"), Bo(t2, "First parameter"), Ze(t2)) throw new TypeError("This stream has already been locked for exclusive writing by another writer");
+          this._ownerWritableStream = t2, t2._writer = this;
+          const r = t2._state;
+          if (r === "writable") !he(t2) && t2._backpressure ? nr(this) : xo(this), rr(this);
+          else if (r === "erroring") sn(this, t2._storedError), rr(this);
+          else if (r === "closed") xo(this), Va(this);
+          else {
+            const s = t2._storedError;
+            sn(this, s), Mo(this, s);
+          }
+        }
+        get closed() {
+          return Le(this) ? this._closedPromise : b($e("closed"));
+        }
+        get desiredSize() {
+          if (!Le(this)) throw $e("desiredSize");
+          if (this._ownerWritableStream === void 0) throw Pt("desiredSize");
+          return $a(this);
+        }
+        get ready() {
+          return Le(this) ? this._readyPromise : b($e("ready"));
+        }
+        abort(t2 = void 0) {
+          return Le(this) ? this._ownerWritableStream === void 0 ? b(Pt("abort")) : Fa(this, t2) : b($e("abort"));
+        }
+        close() {
+          if (!Le(this)) return b($e("close"));
+          const t2 = this._ownerWritableStream;
+          return t2 === void 0 ? b(Pt("close")) : he(t2) ? b(new TypeError("Cannot close an already-closing stream")) : Oo(this);
+        }
+        releaseLock() {
+          if (!Le(this)) throw $e("releaseLock");
+          this._ownerWritableStream !== void 0 && Io(this);
+        }
+        write(t2 = void 0) {
+          return Le(this) ? this._ownerWritableStream === void 0 ? b(Pt("write to")) : Fo(this, t2) : b($e("write"));
+        }
+      };
+      n2(Rn, "WritableStreamDefaultWriter");
+      let re = Rn;
+      Object.defineProperties(re.prototype, { abort: { enumerable: true }, close: { enumerable: true }, releaseLock: { enumerable: true }, write: { enumerable: true }, closed: { enumerable: true }, desiredSize: { enumerable: true }, ready: { enumerable: true } }), h(re.prototype.abort, "abort"), h(re.prototype.close, "close"), h(re.prototype.releaseLock, "releaseLock"), h(re.prototype.write, "write"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(re.prototype, Symbol.toStringTag, { value: "WritableStreamDefaultWriter", configurable: true });
+      function Le(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_ownerWritableStream") ? false : e instanceof re;
+      }
+      n2(Le, "IsWritableStreamDefaultWriter");
+      function Fa(e, t2) {
+        const r = e._ownerWritableStream;
+        return Kt(r, t2);
+      }
+      n2(Fa, "WritableStreamDefaultWriterAbort");
+      function Oo(e) {
+        const t2 = e._ownerWritableStream;
+        return qo(t2);
+      }
+      n2(Oo, "WritableStreamDefaultWriterClose");
+      function ja(e) {
+        const t2 = e._ownerWritableStream, r = t2._state;
+        return he(t2) || r === "closed" ? T(void 0) : r === "errored" ? b(t2._storedError) : Oo(e);
+      }
+      n2(ja, "WritableStreamDefaultWriterCloseWithErrorPropagation");
+      function La(e, t2) {
+        e._closedPromiseState === "pending" ? an(e, t2) : Qa(e, t2);
+      }
+      n2(La, "WritableStreamDefaultWriterEnsureClosedPromiseRejected");
+      function zo(e, t2) {
+        e._readyPromiseState === "pending" ? No(e, t2) : Ga(e, t2);
+      }
+      n2(zo, "WritableStreamDefaultWriterEnsureReadyPromiseRejected");
+      function $a(e) {
+        const t2 = e._ownerWritableStream, r = t2._state;
+        return r === "errored" || r === "erroring" ? null : r === "closed" ? 0 : $o(t2._writableStreamController);
+      }
+      n2($a, "WritableStreamDefaultWriterGetDesiredSize");
+      function Io(e) {
+        const t2 = e._ownerWritableStream, r = new TypeError("Writer was released and can no longer be used to monitor the stream's closedness");
+        zo(e, r), La(e, r), t2._writer = void 0, e._ownerWritableStream = void 0;
+      }
+      n2(Io, "WritableStreamDefaultWriterRelease");
+      function Fo(e, t2) {
+        const r = e._ownerWritableStream, s = r._writableStreamController, u = Ua(s, t2);
+        if (r !== e._ownerWritableStream) return b(Pt("write to"));
+        const c = r._state;
+        if (c === "errored") return b(r._storedError);
+        if (he(r) || c === "closed") return b(new TypeError("The stream is closing or closed and cannot be written to"));
+        if (c === "erroring") return b(r._storedError);
+        const d = Aa(r);
+        return xa(s, t2, u), d;
+      }
+      n2(Fo, "WritableStreamDefaultWriterWrite");
+      const jo = {}, Tn = class Tn {
+        constructor() {
+          throw new TypeError("Illegal constructor");
+        }
+        get abortReason() {
+          if (!rn(this)) throw on("abortReason");
+          return this._abortReason;
+        }
+        get signal() {
+          if (!rn(this)) throw on("signal");
+          if (this._abortController === void 0) throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported");
+          return this._abortController.signal;
+        }
+        error(t2 = void 0) {
+          if (!rn(this)) throw on("error");
+          this._controlledWritableStream._state === "writable" && Do(this, t2);
+        }
+        [jt](t2) {
+          const r = this._abortAlgorithm(t2);
+          return Xt(this), r;
+        }
+        [Qn]() {
+          Be(this);
+        }
+      };
+      n2(Tn, "WritableStreamDefaultController");
+      let ke = Tn;
+      Object.defineProperties(ke.prototype, { abortReason: { enumerable: true }, signal: { enumerable: true }, error: { enumerable: true } }), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(ke.prototype, Symbol.toStringTag, { value: "WritableStreamDefaultController", configurable: true });
+      function rn(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_controlledWritableStream") ? false : e instanceof ke;
+      }
+      n2(rn, "IsWritableStreamDefaultController");
+      function Lo(e, t2, r, s, u, c, d, m) {
+        t2._controlledWritableStream = e, e._writableStreamController = t2, t2._queue = void 0, t2._queueTotalSize = void 0, Be(t2), t2._abortReason = void 0, t2._abortController = va(), t2._started = false, t2._strategySizeAlgorithm = m, t2._strategyHWM = d, t2._writeAlgorithm = s, t2._closeAlgorithm = u, t2._abortAlgorithm = c;
+        const R = nn(t2);
+        tn(e, R);
+        const y = r(), C = T(y);
+        g(C, () => (t2._started = true, er(t2), null), (P) => (t2._started = true, Jr(e, P), null));
+      }
+      n2(Lo, "SetUpWritableStreamDefaultController");
+      function Da(e, t2, r, s) {
+        const u = Object.create(ke.prototype);
+        let c, d, m, R;
+        t2.start !== void 0 ? c = n2(() => t2.start(u), "startAlgorithm") : c = n2(() => {
+        }, "startAlgorithm"), t2.write !== void 0 ? d = n2((y) => t2.write(y, u), "writeAlgorithm") : d = n2(() => T(void 0), "writeAlgorithm"), t2.close !== void 0 ? m = n2(() => t2.close(), "closeAlgorithm") : m = n2(() => T(void 0), "closeAlgorithm"), t2.abort !== void 0 ? R = n2((y) => t2.abort(y), "abortAlgorithm") : R = n2(() => T(void 0), "abortAlgorithm"), Lo(e, u, c, d, m, R, r, s);
+      }
+      n2(Da, "SetUpWritableStreamDefaultControllerFromUnderlyingSink");
+      function Xt(e) {
+        e._writeAlgorithm = void 0, e._closeAlgorithm = void 0, e._abortAlgorithm = void 0, e._strategySizeAlgorithm = void 0;
+      }
+      n2(Xt, "WritableStreamDefaultControllerClearAlgorithms");
+      function Ma(e) {
+        Nr(e, jo, 0), er(e);
+      }
+      n2(Ma, "WritableStreamDefaultControllerClose");
+      function Ua(e, t2) {
+        try {
+          return e._strategySizeAlgorithm(t2);
+        } catch (r) {
+          return Ct(e, r), 1;
+        }
+      }
+      n2(Ua, "WritableStreamDefaultControllerGetChunkSize");
+      function $o(e) {
+        return e._strategyHWM - e._queueTotalSize;
+      }
+      n2($o, "WritableStreamDefaultControllerGetDesiredSize");
+      function xa(e, t2, r) {
+        try {
+          Nr(e, t2, r);
+        } catch (u) {
+          Ct(e, u);
+          return;
+        }
+        const s = e._controlledWritableStream;
+        if (!he(s) && s._state === "writable") {
+          const u = nn(e);
+          tn(s, u);
+        }
+        er(e);
+      }
+      n2(xa, "WritableStreamDefaultControllerWrite");
+      function er(e) {
+        const t2 = e._controlledWritableStream;
+        if (!e._started || t2._inFlightWriteRequest !== void 0) return;
+        if (t2._state === "erroring") {
+          en(t2);
+          return;
+        }
+        if (e._queue.length === 0) return;
+        const s = na(e);
+        s === jo ? Na(e) : Ha(e, s);
+      }
+      n2(er, "WritableStreamDefaultControllerAdvanceQueueIfNeeded");
+      function Ct(e, t2) {
+        e._controlledWritableStream._state === "writable" && Do(e, t2);
+      }
+      n2(Ct, "WritableStreamDefaultControllerErrorIfNeeded");
+      function Na(e) {
+        const t2 = e._controlledWritableStream;
+        za(t2), xr(e);
+        const r = e._closeAlgorithm();
+        Xt(e), g(r, () => (Wa(t2), null), (s) => (qa(t2, s), null));
+      }
+      n2(Na, "WritableStreamDefaultControllerProcessClose");
+      function Ha(e, t2) {
+        const r = e._controlledWritableStream;
+        Ia(r);
+        const s = e._writeAlgorithm(t2);
+        g(s, () => {
+          Ba(r);
+          const u = r._state;
+          if (xr(e), !he(r) && u === "writable") {
+            const c = nn(e);
+            tn(r, c);
+          }
+          return er(e), null;
+        }, (u) => (r._state === "writable" && Xt(e), ka(r, u), null));
+      }
+      n2(Ha, "WritableStreamDefaultControllerProcessWrite");
+      function nn(e) {
+        return $o(e) <= 0;
+      }
+      n2(nn, "WritableStreamDefaultControllerGetBackpressure");
+      function Do(e, t2) {
+        const r = e._controlledWritableStream;
+        Xt(e), Xr(r, t2);
+      }
+      n2(Do, "WritableStreamDefaultControllerError");
+      function tr(e) {
+        return new TypeError(`WritableStream.prototype.${e} can only be used on a WritableStream`);
+      }
+      n2(tr, "streamBrandCheckException$2");
+      function on(e) {
+        return new TypeError(`WritableStreamDefaultController.prototype.${e} can only be used on a WritableStreamDefaultController`);
+      }
+      n2(on, "defaultControllerBrandCheckException$2");
+      function $e(e) {
+        return new TypeError(`WritableStreamDefaultWriter.prototype.${e} can only be used on a WritableStreamDefaultWriter`);
+      }
+      n2($e, "defaultWriterBrandCheckException");
+      function Pt(e) {
+        return new TypeError("Cannot " + e + " a stream using a released writer");
+      }
+      n2(Pt, "defaultWriterLockException");
+      function rr(e) {
+        e._closedPromise = A((t2, r) => {
+          e._closedPromise_resolve = t2, e._closedPromise_reject = r, e._closedPromiseState = "pending";
+        });
+      }
+      n2(rr, "defaultWriterClosedPromiseInitialize");
+      function Mo(e, t2) {
+        rr(e), an(e, t2);
+      }
+      n2(Mo, "defaultWriterClosedPromiseInitializeAsRejected");
+      function Va(e) {
+        rr(e), Uo(e);
+      }
+      n2(Va, "defaultWriterClosedPromiseInitializeAsResolved");
+      function an(e, t2) {
+        e._closedPromise_reject !== void 0 && (Q(e._closedPromise), e._closedPromise_reject(t2), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0, e._closedPromiseState = "rejected");
+      }
+      n2(an, "defaultWriterClosedPromiseReject");
+      function Qa(e, t2) {
+        Mo(e, t2);
+      }
+      n2(Qa, "defaultWriterClosedPromiseResetToRejected");
+      function Uo(e) {
+        e._closedPromise_resolve !== void 0 && (e._closedPromise_resolve(void 0), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0, e._closedPromiseState = "resolved");
+      }
+      n2(Uo, "defaultWriterClosedPromiseResolve");
+      function nr(e) {
+        e._readyPromise = A((t2, r) => {
+          e._readyPromise_resolve = t2, e._readyPromise_reject = r;
+        }), e._readyPromiseState = "pending";
+      }
+      n2(nr, "defaultWriterReadyPromiseInitialize");
+      function sn(e, t2) {
+        nr(e), No(e, t2);
+      }
+      n2(sn, "defaultWriterReadyPromiseInitializeAsRejected");
+      function xo(e) {
+        nr(e), ln(e);
+      }
+      n2(xo, "defaultWriterReadyPromiseInitializeAsResolved");
+      function No(e, t2) {
+        e._readyPromise_reject !== void 0 && (Q(e._readyPromise), e._readyPromise_reject(t2), e._readyPromise_resolve = void 0, e._readyPromise_reject = void 0, e._readyPromiseState = "rejected");
+      }
+      n2(No, "defaultWriterReadyPromiseReject");
+      function Ya(e) {
+        nr(e);
+      }
+      n2(Ya, "defaultWriterReadyPromiseReset");
+      function Ga(e, t2) {
+        sn(e, t2);
+      }
+      n2(Ga, "defaultWriterReadyPromiseResetToRejected");
+      function ln(e) {
+        e._readyPromise_resolve !== void 0 && (e._readyPromise_resolve(void 0), e._readyPromise_resolve = void 0, e._readyPromise_reject = void 0, e._readyPromiseState = "fulfilled");
+      }
+      n2(ln, "defaultWriterReadyPromiseResolve");
+      function Za() {
+        if (typeof globalThis < "u") return globalThis;
+        if (typeof self < "u") return self;
+        if (typeof n < "u") return n;
+      }
+      n2(Za, "getGlobals");
+      const un = Za();
+      function Ka(e) {
+        if (!(typeof e == "function" || typeof e == "object") || e.name !== "DOMException") return false;
+        try {
+          return new e(), true;
+        } catch {
+          return false;
+        }
+      }
+      n2(Ka, "isDOMExceptionConstructor");
+      function Ja() {
+        const e = un?.DOMException;
+        return Ka(e) ? e : void 0;
+      }
+      n2(Ja, "getFromGlobal");
+      function Xa() {
+        const e = n2(function(r, s) {
+          this.message = r || "", this.name = s || "Error", Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
+        }, "DOMException");
+        return h(e, "DOMException"), e.prototype = Object.create(Error.prototype), Object.defineProperty(e.prototype, "constructor", { value: e, writable: true, configurable: true }), e;
+      }
+      n2(Xa, "createPolyfill");
+      const es = Ja() || Xa();
+      function Ho(e, t2, r, s, u, c) {
+        const d = Qe(e), m = ko(t2);
+        e._disturbed = true;
+        let R = false, y = T(void 0);
+        return A((C, P) => {
+          let B;
+          if (c !== void 0) {
+            if (B = n2(() => {
+              const _ = c.reason !== void 0 ? c.reason : new es("Aborted", "AbortError"), E = [];
+              s || E.push(() => t2._state === "writable" ? Kt(t2, _) : T(void 0)), u || E.push(() => e._state === "readable" ? ie(e, _) : T(void 0)), N(() => Promise.all(E.map((k) => k())), true, _);
+            }, "abortAlgorithm"), c.aborted) {
+              B();
+              return;
+            }
+            c.addEventListener("abort", B);
+          }
+          function ae() {
+            return A((_, E) => {
+              function k(Y) {
+                Y ? _() : q(nt(), k, E);
+              }
+              n2(k, "next"), k(false);
+            });
+          }
+          n2(ae, "pipeLoop");
+          function nt() {
+            return R ? T(true) : q(m._readyPromise, () => A((_, E) => {
+              _t(d, { _chunkSteps: n2((k) => {
+                y = q(Fo(m, k), void 0, f2), _(false);
+              }, "_chunkSteps"), _closeSteps: n2(() => _(true), "_closeSteps"), _errorSteps: E });
+            }));
+          }
+          if (n2(nt, "pipeStep"), Te(e, d._closedPromise, (_) => (s ? J(true, _) : N(() => Kt(t2, _), true, _), null)), Te(t2, m._closedPromise, (_) => (u ? J(true, _) : N(() => ie(e, _), true, _), null)), x(e, d._closedPromise, () => (r ? J() : N(() => ja(m)), null)), he(t2) || t2._state === "closed") {
+            const _ = new TypeError("the destination writable stream closed before all data could be piped to it");
+            u ? J(true, _) : N(() => ie(e, _), true, _);
+          }
+          Q(ae());
+          function Oe() {
+            const _ = y;
+            return q(y, () => _ !== y ? Oe() : void 0);
+          }
+          n2(Oe, "waitForWritesToFinish");
+          function Te(_, E, k) {
+            _._state === "errored" ? k(_._storedError) : I(E, k);
+          }
+          n2(Te, "isOrBecomesErrored");
+          function x(_, E, k) {
+            _._state === "closed" ? k() : V(E, k);
+          }
+          n2(x, "isOrBecomesClosed");
+          function N(_, E, k) {
+            if (R) return;
+            R = true, t2._state === "writable" && !he(t2) ? V(Oe(), Y) : Y();
+            function Y() {
+              return g(_(), () => Ce(E, k), (ot) => Ce(true, ot)), null;
+            }
+            n2(Y, "doTheRest");
+          }
+          n2(N, "shutdownWithAction");
+          function J(_, E) {
+            R || (R = true, t2._state === "writable" && !he(t2) ? V(Oe(), () => Ce(_, E)) : Ce(_, E));
+          }
+          n2(J, "shutdown");
+          function Ce(_, E) {
+            return Io(m), _e(d), c !== void 0 && c.removeEventListener("abort", B), _ ? P(E) : C(void 0), null;
+          }
+          n2(Ce, "finalize");
+        });
+      }
+      n2(Ho, "ReadableStreamPipeTo");
+      const Cn = class Cn {
+        constructor() {
+          throw new TypeError("Illegal constructor");
+        }
+        get desiredSize() {
+          if (!or(this)) throw ar("desiredSize");
+          return fn(this);
+        }
+        close() {
+          if (!or(this)) throw ar("close");
+          if (!Je(this)) throw new TypeError("The stream is not in a state that permits close");
+          De(this);
+        }
+        enqueue(t2 = void 0) {
+          if (!or(this)) throw ar("enqueue");
+          if (!Je(this)) throw new TypeError("The stream is not in a state that permits enqueue");
+          return Ke(this, t2);
+        }
+        error(t2 = void 0) {
+          if (!or(this)) throw ar("error");
+          oe(this, t2);
+        }
+        [Ar](t2) {
+          Be(this);
+          const r = this._cancelAlgorithm(t2);
+          return ir(this), r;
+        }
+        [Br](t2) {
+          const r = this._controlledReadableStream;
+          if (this._queue.length > 0) {
+            const s = xr(this);
+            this._closeRequested && this._queue.length === 0 ? (ir(this), At(r)) : vt(this), t2._chunkSteps(s);
+          } else eo(r, t2), vt(this);
+        }
+        [kr]() {
+        }
+      };
+      n2(Cn, "ReadableStreamDefaultController");
+      let ne = Cn;
+      Object.defineProperties(ne.prototype, { close: { enumerable: true }, enqueue: { enumerable: true }, error: { enumerable: true }, desiredSize: { enumerable: true } }), h(ne.prototype.close, "close"), h(ne.prototype.enqueue, "enqueue"), h(ne.prototype.error, "error"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(ne.prototype, Symbol.toStringTag, { value: "ReadableStreamDefaultController", configurable: true });
+      function or(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_controlledReadableStream") ? false : e instanceof ne;
+      }
+      n2(or, "IsReadableStreamDefaultController");
+      function vt(e) {
+        if (!Vo(e)) return;
+        if (e._pulling) {
+          e._pullAgain = true;
+          return;
+        }
+        e._pulling = true;
+        const r = e._pullAlgorithm();
+        g(r, () => (e._pulling = false, e._pullAgain && (e._pullAgain = false, vt(e)), null), (s) => (oe(e, s), null));
+      }
+      n2(vt, "ReadableStreamDefaultControllerCallPullIfNeeded");
+      function Vo(e) {
+        const t2 = e._controlledReadableStream;
+        return !Je(e) || !e._started ? false : !!(qe(t2) && $t(t2) > 0 || fn(e) > 0);
+      }
+      n2(Vo, "ReadableStreamDefaultControllerShouldCallPull");
+      function ir(e) {
+        e._pullAlgorithm = void 0, e._cancelAlgorithm = void 0, e._strategySizeAlgorithm = void 0;
+      }
+      n2(ir, "ReadableStreamDefaultControllerClearAlgorithms");
+      function De(e) {
+        if (!Je(e)) return;
+        const t2 = e._controlledReadableStream;
+        e._closeRequested = true, e._queue.length === 0 && (ir(e), At(t2));
+      }
+      n2(De, "ReadableStreamDefaultControllerClose");
+      function Ke(e, t2) {
+        if (!Je(e)) return;
+        const r = e._controlledReadableStream;
+        if (qe(r) && $t(r) > 0) Lr(r, t2, false);
+        else {
+          let s;
+          try {
+            s = e._strategySizeAlgorithm(t2);
+          } catch (u) {
+            throw oe(e, u), u;
+          }
+          try {
+            Nr(e, t2, s);
+          } catch (u) {
+            throw oe(e, u), u;
+          }
+        }
+        vt(e);
+      }
+      n2(Ke, "ReadableStreamDefaultControllerEnqueue");
+      function oe(e, t2) {
+        const r = e._controlledReadableStream;
+        r._state === "readable" && (Be(e), ir(e), Zo(r, t2));
+      }
+      n2(oe, "ReadableStreamDefaultControllerError");
+      function fn(e) {
+        const t2 = e._controlledReadableStream._state;
+        return t2 === "errored" ? null : t2 === "closed" ? 0 : e._strategyHWM - e._queueTotalSize;
+      }
+      n2(fn, "ReadableStreamDefaultControllerGetDesiredSize");
+      function ts(e) {
+        return !Vo(e);
+      }
+      n2(ts, "ReadableStreamDefaultControllerHasBackpressure");
+      function Je(e) {
+        const t2 = e._controlledReadableStream._state;
+        return !e._closeRequested && t2 === "readable";
+      }
+      n2(Je, "ReadableStreamDefaultControllerCanCloseOrEnqueue");
+      function Qo(e, t2, r, s, u, c, d) {
+        t2._controlledReadableStream = e, t2._queue = void 0, t2._queueTotalSize = void 0, Be(t2), t2._started = false, t2._closeRequested = false, t2._pullAgain = false, t2._pulling = false, t2._strategySizeAlgorithm = d, t2._strategyHWM = c, t2._pullAlgorithm = s, t2._cancelAlgorithm = u, e._readableStreamController = t2;
+        const m = r();
+        g(T(m), () => (t2._started = true, vt(t2), null), (R) => (oe(t2, R), null));
+      }
+      n2(Qo, "SetUpReadableStreamDefaultController");
+      function rs(e, t2, r, s) {
+        const u = Object.create(ne.prototype);
+        let c, d, m;
+        t2.start !== void 0 ? c = n2(() => t2.start(u), "startAlgorithm") : c = n2(() => {
+        }, "startAlgorithm"), t2.pull !== void 0 ? d = n2(() => t2.pull(u), "pullAlgorithm") : d = n2(() => T(void 0), "pullAlgorithm"), t2.cancel !== void 0 ? m = n2((R) => t2.cancel(R), "cancelAlgorithm") : m = n2(() => T(void 0), "cancelAlgorithm"), Qo(e, u, c, d, m, r, s);
+      }
+      n2(rs, "SetUpReadableStreamDefaultControllerFromUnderlyingSource");
+      function ar(e) {
+        return new TypeError(`ReadableStreamDefaultController.prototype.${e} can only be used on a ReadableStreamDefaultController`);
+      }
+      n2(ar, "defaultControllerBrandCheckException$1");
+      function ns(e, t2) {
+        return Ie(e._readableStreamController) ? is(e) : os(e);
+      }
+      n2(ns, "ReadableStreamTee");
+      function os(e, t2) {
+        const r = Qe(e);
+        let s = false, u = false, c = false, d = false, m, R, y, C, P;
+        const B = A((x) => {
+          P = x;
+        });
+        function ae() {
+          return s ? (u = true, T(void 0)) : (s = true, _t(r, { _chunkSteps: n2((N) => {
+            ge(() => {
+              u = false;
+              const J = N, Ce = N;
+              c || Ke(y._readableStreamController, J), d || Ke(C._readableStreamController, Ce), s = false, u && ae();
+            });
+          }, "_chunkSteps"), _closeSteps: n2(() => {
+            s = false, c || De(y._readableStreamController), d || De(C._readableStreamController), (!c || !d) && P(void 0);
+          }, "_closeSteps"), _errorSteps: n2(() => {
+            s = false;
+          }, "_errorSteps") }), T(void 0));
+        }
+        n2(ae, "pullAlgorithm");
+        function nt(x) {
+          if (c = true, m = x, d) {
+            const N = St([m, R]), J = ie(e, N);
+            P(J);
+          }
+          return B;
+        }
+        n2(nt, "cancel1Algorithm");
+        function Oe(x) {
+          if (d = true, R = x, c) {
+            const N = St([m, R]), J = ie(e, N);
+            P(J);
+          }
+          return B;
+        }
+        n2(Oe, "cancel2Algorithm");
+        function Te() {
+        }
+        return n2(Te, "startAlgorithm"), y = Et(Te, ae, nt), C = Et(Te, ae, Oe), I(r._closedPromise, (x) => (oe(y._readableStreamController, x), oe(C._readableStreamController, x), (!c || !d) && P(void 0), null)), [y, C];
+      }
+      n2(os, "ReadableStreamDefaultTee");
+      function is(e) {
+        let t2 = Qe(e), r = false, s = false, u = false, c = false, d = false, m, R, y, C, P;
+        const B = A((_) => {
+          P = _;
+        });
+        function ae(_) {
+          I(_._closedPromise, (E) => (_ !== t2 || (K(y._readableStreamController, E), K(C._readableStreamController, E), (!c || !d) && P(void 0)), null));
+        }
+        n2(ae, "forwardReaderError");
+        function nt() {
+          je(t2) && (_e(t2), t2 = Qe(e), ae(t2)), _t(t2, { _chunkSteps: n2((E) => {
+            ge(() => {
+              s = false, u = false;
+              const k = E;
+              let Y = E;
+              if (!c && !d) try {
+                Y = fo(E);
+              } catch (ot) {
+                K(y._readableStreamController, ot), K(C._readableStreamController, ot), P(ie(e, ot));
+                return;
+              }
+              c || Ht(y._readableStreamController, k), d || Ht(C._readableStreamController, Y), r = false, s ? Te() : u && x();
+            });
+          }, "_chunkSteps"), _closeSteps: n2(() => {
+            r = false, c || wt(y._readableStreamController), d || wt(C._readableStreamController), y._readableStreamController._pendingPullIntos.length > 0 && Vt(y._readableStreamController, 0), C._readableStreamController._pendingPullIntos.length > 0 && Vt(C._readableStreamController, 0), (!c || !d) && P(void 0);
+          }, "_closeSteps"), _errorSteps: n2(() => {
+            r = false;
+          }, "_errorSteps") });
+        }
+        n2(nt, "pullWithDefaultReader");
+        function Oe(_, E) {
+          Ee(t2) && (_e(t2), t2 = Co(e), ae(t2));
+          const k = E ? C : y, Y = E ? y : C;
+          Eo(t2, _, 1, { _chunkSteps: n2((it) => {
+            ge(() => {
+              s = false, u = false;
+              const at = E ? d : c;
+              if (E ? c : d) at || Qt(k._readableStreamController, it);
+              else {
+                let ui;
+                try {
+                  ui = fo(it);
+                } catch (kn) {
+                  K(k._readableStreamController, kn), K(Y._readableStreamController, kn), P(ie(e, kn));
+                  return;
+                }
+                at || Qt(k._readableStreamController, it), Ht(Y._readableStreamController, ui);
+              }
+              r = false, s ? Te() : u && x();
+            });
+          }, "_chunkSteps"), _closeSteps: n2((it) => {
+            r = false;
+            const at = E ? d : c, cr = E ? c : d;
+            at || wt(k._readableStreamController), cr || wt(Y._readableStreamController), it !== void 0 && (at || Qt(k._readableStreamController, it), !cr && Y._readableStreamController._pendingPullIntos.length > 0 && Vt(Y._readableStreamController, 0)), (!at || !cr) && P(void 0);
+          }, "_closeSteps"), _errorSteps: n2(() => {
+            r = false;
+          }, "_errorSteps") });
+        }
+        n2(Oe, "pullWithBYOBReader");
+        function Te() {
+          if (r) return s = true, T(void 0);
+          r = true;
+          const _ = Gr(y._readableStreamController);
+          return _ === null ? nt() : Oe(_._view, false), T(void 0);
+        }
+        n2(Te, "pull1Algorithm");
+        function x() {
+          if (r) return u = true, T(void 0);
+          r = true;
+          const _ = Gr(C._readableStreamController);
+          return _ === null ? nt() : Oe(_._view, true), T(void 0);
+        }
+        n2(x, "pull2Algorithm");
+        function N(_) {
+          if (c = true, m = _, d) {
+            const E = St([m, R]), k = ie(e, E);
+            P(k);
+          }
+          return B;
+        }
+        n2(N, "cancel1Algorithm");
+        function J(_) {
+          if (d = true, R = _, c) {
+            const E = St([m, R]), k = ie(e, E);
+            P(k);
+          }
+          return B;
+        }
+        n2(J, "cancel2Algorithm");
+        function Ce() {
+        }
+        return n2(Ce, "startAlgorithm"), y = Go(Ce, Te, N), C = Go(Ce, x, J), ae(t2), [y, C];
+      }
+      n2(is, "ReadableByteStreamTee");
+      function as(e) {
+        return l(e) && typeof e.getReader < "u";
+      }
+      n2(as, "isReadableStreamLike");
+      function ss(e) {
+        return as(e) ? us(e.getReader()) : ls(e);
+      }
+      n2(ss, "ReadableStreamFrom");
+      function ls(e) {
+        let t2;
+        const r = uo(e, "async"), s = f2;
+        function u() {
+          let d;
+          try {
+            d = Xi(r);
+          } catch (R) {
+            return b(R);
+          }
+          const m = T(d);
+          return F(m, (R) => {
+            if (!l(R)) throw new TypeError("The promise returned by the iterator.next() method must fulfill with an object");
+            if (ea(R)) De(t2._readableStreamController);
+            else {
+              const C = ta(R);
+              Ke(t2._readableStreamController, C);
+            }
+          });
+        }
+        n2(u, "pullAlgorithm");
+        function c(d) {
+          const m = r.iterator;
+          let R;
+          try {
+            R = Ut(m, "return");
+          } catch (P) {
+            return b(P);
+          }
+          if (R === void 0) return T(void 0);
+          let y;
+          try {
+            y = z(R, m, [d]);
+          } catch (P) {
+            return b(P);
+          }
+          const C = T(y);
+          return F(C, (P) => {
+            if (!l(P)) throw new TypeError("The promise returned by the iterator.return() method must fulfill with an object");
+          });
+        }
+        return n2(c, "cancelAlgorithm"), t2 = Et(s, u, c, 0), t2;
+      }
+      n2(ls, "ReadableStreamFromIterable");
+      function us(e) {
+        let t2;
+        const r = f2;
+        function s() {
+          let c;
+          try {
+            c = e.read();
+          } catch (d) {
+            return b(d);
+          }
+          return F(c, (d) => {
+            if (!l(d)) throw new TypeError("The promise returned by the reader.read() method must fulfill with an object");
+            if (d.done) De(t2._readableStreamController);
+            else {
+              const m = d.value;
+              Ke(t2._readableStreamController, m);
+            }
+          });
+        }
+        n2(s, "pullAlgorithm");
+        function u(c) {
+          try {
+            return T(e.cancel(c));
+          } catch (d) {
+            return b(d);
+          }
+        }
+        return n2(u, "cancelAlgorithm"), t2 = Et(r, s, u, 0), t2;
+      }
+      n2(us, "ReadableStreamFromDefaultReader");
+      function fs(e, t2) {
+        ue(e, t2);
+        const r = e, s = r?.autoAllocateChunkSize, u = r?.cancel, c = r?.pull, d = r?.start, m = r?.type;
+        return { autoAllocateChunkSize: s === void 0 ? void 0 : Fr(s, `${t2} has member 'autoAllocateChunkSize' that`), cancel: u === void 0 ? void 0 : cs(u, r, `${t2} has member 'cancel' that`), pull: c === void 0 ? void 0 : ds(c, r, `${t2} has member 'pull' that`), start: d === void 0 ? void 0 : hs(d, r, `${t2} has member 'start' that`), type: m === void 0 ? void 0 : ps(m, `${t2} has member 'type' that`) };
+      }
+      n2(fs, "convertUnderlyingDefaultOrByteSource");
+      function cs(e, t2, r) {
+        return Z(e, r), (s) => j(e, t2, [s]);
+      }
+      n2(cs, "convertUnderlyingSourceCancelCallback");
+      function ds(e, t2, r) {
+        return Z(e, r), (s) => j(e, t2, [s]);
+      }
+      n2(ds, "convertUnderlyingSourcePullCallback");
+      function hs(e, t2, r) {
+        return Z(e, r), (s) => z(e, t2, [s]);
+      }
+      n2(hs, "convertUnderlyingSourceStartCallback");
+      function ps(e, t2) {
+        if (e = `${e}`, e !== "bytes") throw new TypeError(`${t2} '${e}' is not a valid enumeration value for ReadableStreamType`);
+        return e;
+      }
+      n2(ps, "convertReadableStreamType");
+      function bs(e, t2) {
+        return ue(e, t2), { preventCancel: !!e?.preventCancel };
+      }
+      n2(bs, "convertIteratorOptions");
+      function Yo(e, t2) {
+        ue(e, t2);
+        const r = e?.preventAbort, s = e?.preventCancel, u = e?.preventClose, c = e?.signal;
+        return c !== void 0 && ms(c, `${t2} has member 'signal' that`), { preventAbort: !!r, preventCancel: !!s, preventClose: !!u, signal: c };
+      }
+      n2(Yo, "convertPipeOptions");
+      function ms(e, t2) {
+        if (!Ca(e)) throw new TypeError(`${t2} is not an AbortSignal.`);
+      }
+      n2(ms, "assertAbortSignal");
+      function ys(e, t2) {
+        ue(e, t2);
+        const r = e?.readable;
+        zr(r, "readable", "ReadableWritablePair"), jr(r, `${t2} has member 'readable' that`);
+        const s = e?.writable;
+        return zr(s, "writable", "ReadableWritablePair"), Bo(s, `${t2} has member 'writable' that`), { readable: r, writable: s };
+      }
+      n2(ys, "convertReadableWritablePair");
+      const Pn = class Pn {
+        constructor(t2 = {}, r = {}) {
+          t2 === void 0 ? t2 = null : Jn(t2, "First parameter");
+          const s = Zt(r, "Second parameter"), u = fs(t2, "First parameter");
+          if (cn(this), u.type === "bytes") {
+            if (s.size !== void 0) throw new RangeError("The strategy for a byte stream cannot have a size function");
+            const c = Tt(s, 0);
+            ca(this, u, c);
+          } else {
+            const c = Gt(s), d = Tt(s, 1);
+            rs(this, u, d, c);
+          }
+        }
+        get locked() {
+          if (!We(this)) throw Me("locked");
+          return qe(this);
+        }
+        cancel(t2 = void 0) {
+          return We(this) ? qe(this) ? b(new TypeError("Cannot cancel a stream that already has a reader")) : ie(this, t2) : b(Me("cancel"));
+        }
+        getReader(t2 = void 0) {
+          if (!We(this)) throw Me("getReader");
+          return ha(t2, "First parameter").mode === void 0 ? Qe(this) : Co(this);
+        }
+        pipeThrough(t2, r = {}) {
+          if (!We(this)) throw Me("pipeThrough");
+          Se(t2, 1, "pipeThrough");
+          const s = ys(t2, "First parameter"), u = Yo(r, "Second parameter");
+          if (qe(this)) throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");
+          if (Ze(s.writable)) throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");
+          const c = Ho(this, s.writable, u.preventClose, u.preventAbort, u.preventCancel, u.signal);
+          return Q(c), s.readable;
+        }
+        pipeTo(t2, r = {}) {
+          if (!We(this)) return b(Me("pipeTo"));
+          if (t2 === void 0) return b("Parameter 1 is required in 'pipeTo'.");
+          if (!Ge(t2)) return b(new TypeError("ReadableStream.prototype.pipeTo's first argument must be a WritableStream"));
+          let s;
+          try {
+            s = Yo(r, "Second parameter");
+          } catch (u) {
+            return b(u);
+          }
+          return qe(this) ? b(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream")) : Ze(t2) ? b(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream")) : Ho(this, t2, s.preventClose, s.preventAbort, s.preventCancel, s.signal);
+        }
+        tee() {
+          if (!We(this)) throw Me("tee");
+          const t2 = ns(this);
+          return St(t2);
+        }
+        values(t2 = void 0) {
+          if (!We(this)) throw Me("values");
+          const r = bs(t2, "First parameter");
+          return Ki(this, r.preventCancel);
+        }
+        [Ur](t2) {
+          return this.values(t2);
+        }
+        static from(t2) {
+          return ss(t2);
+        }
+      };
+      n2(Pn, "ReadableStream");
+      let L = Pn;
+      Object.defineProperties(L, { from: { enumerable: true } }), Object.defineProperties(L.prototype, { cancel: { enumerable: true }, getReader: { enumerable: true }, pipeThrough: { enumerable: true }, pipeTo: { enumerable: true }, tee: { enumerable: true }, values: { enumerable: true }, locked: { enumerable: true } }), h(L.from, "from"), h(L.prototype.cancel, "cancel"), h(L.prototype.getReader, "getReader"), h(L.prototype.pipeThrough, "pipeThrough"), h(L.prototype.pipeTo, "pipeTo"), h(L.prototype.tee, "tee"), h(L.prototype.values, "values"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(L.prototype, Symbol.toStringTag, { value: "ReadableStream", configurable: true }), Object.defineProperty(L.prototype, Ur, { value: L.prototype.values, writable: true, configurable: true });
+      function Et(e, t2, r, s = 1, u = () => 1) {
+        const c = Object.create(L.prototype);
+        cn(c);
+        const d = Object.create(ne.prototype);
+        return Qo(c, d, e, t2, r, s, u), c;
+      }
+      n2(Et, "CreateReadableStream");
+      function Go(e, t2, r) {
+        const s = Object.create(L.prototype);
+        cn(s);
+        const u = Object.create(te.prototype);
+        return To(s, u, e, t2, r, 0, void 0), s;
+      }
+      n2(Go, "CreateReadableByteStream");
+      function cn(e) {
+        e._state = "readable", e._reader = void 0, e._storedError = void 0, e._disturbed = false;
+      }
+      n2(cn, "InitializeReadableStream");
+      function We(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_readableStreamController") ? false : e instanceof L;
+      }
+      n2(We, "IsReadableStream");
+      function qe(e) {
+        return e._reader !== void 0;
+      }
+      n2(qe, "IsReadableStreamLocked");
+      function ie(e, t2) {
+        if (e._disturbed = true, e._state === "closed") return T(void 0);
+        if (e._state === "errored") return b(e._storedError);
+        At(e);
+        const r = e._reader;
+        if (r !== void 0 && je(r)) {
+          const u = r._readIntoRequests;
+          r._readIntoRequests = new D(), u.forEach((c) => {
+            c._closeSteps(void 0);
+          });
+        }
+        const s = e._readableStreamController[Ar](t2);
+        return F(s, f2);
+      }
+      n2(ie, "ReadableStreamCancel");
+      function At(e) {
+        e._state = "closed";
+        const t2 = e._reader;
+        if (t2 !== void 0 && (Zn(t2), Ee(t2))) {
+          const r = t2._readRequests;
+          t2._readRequests = new D(), r.forEach((s) => {
+            s._closeSteps();
+          });
+        }
+      }
+      n2(At, "ReadableStreamClose");
+      function Zo(e, t2) {
+        e._state = "errored", e._storedError = t2;
+        const r = e._reader;
+        r !== void 0 && (Or(r, t2), Ee(r) ? ro(r, t2) : Ao(r, t2));
+      }
+      n2(Zo, "ReadableStreamError");
+      function Me(e) {
+        return new TypeError(`ReadableStream.prototype.${e} can only be used on a ReadableStream`);
+      }
+      n2(Me, "streamBrandCheckException$1");
+      function Ko(e, t2) {
+        ue(e, t2);
+        const r = e?.highWaterMark;
+        return zr(r, "highWaterMark", "QueuingStrategyInit"), { highWaterMark: Ir(r) };
+      }
+      n2(Ko, "convertQueuingStrategyInit");
+      const Jo = n2((e) => e.byteLength, "byteLengthSizeFunction");
+      h(Jo, "size");
+      const vn = class vn {
+        constructor(t2) {
+          Se(t2, 1, "ByteLengthQueuingStrategy"), t2 = Ko(t2, "First parameter"), this._byteLengthQueuingStrategyHighWaterMark = t2.highWaterMark;
+        }
+        get highWaterMark() {
+          if (!ei(this)) throw Xo("highWaterMark");
+          return this._byteLengthQueuingStrategyHighWaterMark;
+        }
+        get size() {
+          if (!ei(this)) throw Xo("size");
+          return Jo;
+        }
+      };
+      n2(vn, "ByteLengthQueuingStrategy");
+      let Xe = vn;
+      Object.defineProperties(Xe.prototype, { highWaterMark: { enumerable: true }, size: { enumerable: true } }), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(Xe.prototype, Symbol.toStringTag, { value: "ByteLengthQueuingStrategy", configurable: true });
+      function Xo(e) {
+        return new TypeError(`ByteLengthQueuingStrategy.prototype.${e} can only be used on a ByteLengthQueuingStrategy`);
+      }
+      n2(Xo, "byteLengthBrandCheckException");
+      function ei(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_byteLengthQueuingStrategyHighWaterMark") ? false : e instanceof Xe;
+      }
+      n2(ei, "IsByteLengthQueuingStrategy");
+      const ti = n2(() => 1, "countSizeFunction");
+      h(ti, "size");
+      const En = class En {
+        constructor(t2) {
+          Se(t2, 1, "CountQueuingStrategy"), t2 = Ko(t2, "First parameter"), this._countQueuingStrategyHighWaterMark = t2.highWaterMark;
+        }
+        get highWaterMark() {
+          if (!ni(this)) throw ri("highWaterMark");
+          return this._countQueuingStrategyHighWaterMark;
+        }
+        get size() {
+          if (!ni(this)) throw ri("size");
+          return ti;
+        }
+      };
+      n2(En, "CountQueuingStrategy");
+      let et = En;
+      Object.defineProperties(et.prototype, { highWaterMark: { enumerable: true }, size: { enumerable: true } }), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(et.prototype, Symbol.toStringTag, { value: "CountQueuingStrategy", configurable: true });
+      function ri(e) {
+        return new TypeError(`CountQueuingStrategy.prototype.${e} can only be used on a CountQueuingStrategy`);
+      }
+      n2(ri, "countBrandCheckException");
+      function ni(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_countQueuingStrategyHighWaterMark") ? false : e instanceof et;
+      }
+      n2(ni, "IsCountQueuingStrategy");
+      function gs(e, t2) {
+        ue(e, t2);
+        const r = e?.cancel, s = e?.flush, u = e?.readableType, c = e?.start, d = e?.transform, m = e?.writableType;
+        return { cancel: r === void 0 ? void 0 : Rs(r, e, `${t2} has member 'cancel' that`), flush: s === void 0 ? void 0 : _s(s, e, `${t2} has member 'flush' that`), readableType: u, start: c === void 0 ? void 0 : Ss(c, e, `${t2} has member 'start' that`), transform: d === void 0 ? void 0 : ws(d, e, `${t2} has member 'transform' that`), writableType: m };
+      }
+      n2(gs, "convertTransformer");
+      function _s(e, t2, r) {
+        return Z(e, r), (s) => j(e, t2, [s]);
+      }
+      n2(_s, "convertTransformerFlushCallback");
+      function Ss(e, t2, r) {
+        return Z(e, r), (s) => z(e, t2, [s]);
+      }
+      n2(Ss, "convertTransformerStartCallback");
+      function ws(e, t2, r) {
+        return Z(e, r), (s, u) => j(e, t2, [s, u]);
+      }
+      n2(ws, "convertTransformerTransformCallback");
+      function Rs(e, t2, r) {
+        return Z(e, r), (s) => j(e, t2, [s]);
+      }
+      n2(Rs, "convertTransformerCancelCallback");
+      const An = class An {
+        constructor(t2 = {}, r = {}, s = {}) {
+          t2 === void 0 && (t2 = null);
+          const u = Zt(r, "Second parameter"), c = Zt(s, "Third parameter"), d = gs(t2, "First parameter");
+          if (d.readableType !== void 0) throw new RangeError("Invalid readableType specified");
+          if (d.writableType !== void 0) throw new RangeError("Invalid writableType specified");
+          const m = Tt(c, 0), R = Gt(c), y = Tt(u, 1), C = Gt(u);
+          let P;
+          const B = A((ae) => {
+            P = ae;
+          });
+          Ts(this, B, y, C, m, R), Ps(this, d), d.start !== void 0 ? P(d.start(this._transformStreamController)) : P(void 0);
+        }
+        get readable() {
+          if (!oi(this)) throw li("readable");
+          return this._readable;
+        }
+        get writable() {
+          if (!oi(this)) throw li("writable");
+          return this._writable;
+        }
+      };
+      n2(An, "TransformStream");
+      let tt = An;
+      Object.defineProperties(tt.prototype, { readable: { enumerable: true }, writable: { enumerable: true } }), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(tt.prototype, Symbol.toStringTag, { value: "TransformStream", configurable: true });
+      function Ts(e, t2, r, s, u, c) {
+        function d() {
+          return t2;
+        }
+        n2(d, "startAlgorithm");
+        function m(B) {
+          return As(e, B);
+        }
+        n2(m, "writeAlgorithm");
+        function R(B) {
+          return Bs(e, B);
+        }
+        n2(R, "abortAlgorithm");
+        function y() {
+          return ks(e);
+        }
+        n2(y, "closeAlgorithm"), e._writable = Ea(d, m, y, R, r, s);
+        function C() {
+          return Ws(e);
+        }
+        n2(C, "pullAlgorithm");
+        function P(B) {
+          return qs(e, B);
+        }
+        n2(P, "cancelAlgorithm"), e._readable = Et(d, C, P, u, c), e._backpressure = void 0, e._backpressureChangePromise = void 0, e._backpressureChangePromise_resolve = void 0, sr(e, true), e._transformStreamController = void 0;
+      }
+      n2(Ts, "InitializeTransformStream");
+      function oi(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_transformStreamController") ? false : e instanceof tt;
+      }
+      n2(oi, "IsTransformStream");
+      function ii(e, t2) {
+        oe(e._readable._readableStreamController, t2), dn(e, t2);
+      }
+      n2(ii, "TransformStreamError");
+      function dn(e, t2) {
+        ur(e._transformStreamController), Ct(e._writable._writableStreamController, t2), hn(e);
+      }
+      n2(dn, "TransformStreamErrorWritableAndUnblockWrite");
+      function hn(e) {
+        e._backpressure && sr(e, false);
+      }
+      n2(hn, "TransformStreamUnblockWrite");
+      function sr(e, t2) {
+        e._backpressureChangePromise !== void 0 && e._backpressureChangePromise_resolve(), e._backpressureChangePromise = A((r) => {
+          e._backpressureChangePromise_resolve = r;
+        }), e._backpressure = t2;
+      }
+      n2(sr, "TransformStreamSetBackpressure");
+      const Bn = class Bn {
+        constructor() {
+          throw new TypeError("Illegal constructor");
+        }
+        get desiredSize() {
+          if (!lr(this)) throw fr("desiredSize");
+          const t2 = this._controlledTransformStream._readable._readableStreamController;
+          return fn(t2);
+        }
+        enqueue(t2 = void 0) {
+          if (!lr(this)) throw fr("enqueue");
+          ai(this, t2);
+        }
+        error(t2 = void 0) {
+          if (!lr(this)) throw fr("error");
+          vs(this, t2);
+        }
+        terminate() {
+          if (!lr(this)) throw fr("terminate");
+          Es(this);
+        }
+      };
+      n2(Bn, "TransformStreamDefaultController");
+      let pe = Bn;
+      Object.defineProperties(pe.prototype, { enqueue: { enumerable: true }, error: { enumerable: true }, terminate: { enumerable: true }, desiredSize: { enumerable: true } }), h(pe.prototype.enqueue, "enqueue"), h(pe.prototype.error, "error"), h(pe.prototype.terminate, "terminate"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(pe.prototype, Symbol.toStringTag, { value: "TransformStreamDefaultController", configurable: true });
+      function lr(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_controlledTransformStream") ? false : e instanceof pe;
+      }
+      n2(lr, "IsTransformStreamDefaultController");
+      function Cs(e, t2, r, s, u) {
+        t2._controlledTransformStream = e, e._transformStreamController = t2, t2._transformAlgorithm = r, t2._flushAlgorithm = s, t2._cancelAlgorithm = u, t2._finishPromise = void 0, t2._finishPromise_resolve = void 0, t2._finishPromise_reject = void 0;
+      }
+      n2(Cs, "SetUpTransformStreamDefaultController");
+      function Ps(e, t2) {
+        const r = Object.create(pe.prototype);
+        let s, u, c;
+        t2.transform !== void 0 ? s = n2((d) => t2.transform(d, r), "transformAlgorithm") : s = n2((d) => {
+          try {
+            return ai(r, d), T(void 0);
+          } catch (m) {
+            return b(m);
+          }
+        }, "transformAlgorithm"), t2.flush !== void 0 ? u = n2(() => t2.flush(r), "flushAlgorithm") : u = n2(() => T(void 0), "flushAlgorithm"), t2.cancel !== void 0 ? c = n2((d) => t2.cancel(d), "cancelAlgorithm") : c = n2(() => T(void 0), "cancelAlgorithm"), Cs(e, r, s, u, c);
+      }
+      n2(Ps, "SetUpTransformStreamDefaultControllerFromTransformer");
+      function ur(e) {
+        e._transformAlgorithm = void 0, e._flushAlgorithm = void 0, e._cancelAlgorithm = void 0;
+      }
+      n2(ur, "TransformStreamDefaultControllerClearAlgorithms");
+      function ai(e, t2) {
+        const r = e._controlledTransformStream, s = r._readable._readableStreamController;
+        if (!Je(s)) throw new TypeError("Readable side is not in a state that permits enqueue");
+        try {
+          Ke(s, t2);
+        } catch (c) {
+          throw dn(r, c), r._readable._storedError;
+        }
+        ts(s) !== r._backpressure && sr(r, true);
+      }
+      n2(ai, "TransformStreamDefaultControllerEnqueue");
+      function vs(e, t2) {
+        ii(e._controlledTransformStream, t2);
+      }
+      n2(vs, "TransformStreamDefaultControllerError");
+      function si(e, t2) {
+        const r = e._transformAlgorithm(t2);
+        return F(r, void 0, (s) => {
+          throw ii(e._controlledTransformStream, s), s;
+        });
+      }
+      n2(si, "TransformStreamDefaultControllerPerformTransform");
+      function Es(e) {
+        const t2 = e._controlledTransformStream, r = t2._readable._readableStreamController;
+        De(r);
+        const s = new TypeError("TransformStream terminated");
+        dn(t2, s);
+      }
+      n2(Es, "TransformStreamDefaultControllerTerminate");
+      function As(e, t2) {
+        const r = e._transformStreamController;
+        if (e._backpressure) {
+          const s = e._backpressureChangePromise;
+          return F(s, () => {
+            const u = e._writable;
+            if (u._state === "erroring") throw u._storedError;
+            return si(r, t2);
+          });
+        }
+        return si(r, t2);
+      }
+      n2(As, "TransformStreamDefaultSinkWriteAlgorithm");
+      function Bs(e, t2) {
+        const r = e._transformStreamController;
+        if (r._finishPromise !== void 0) return r._finishPromise;
+        const s = e._readable;
+        r._finishPromise = A((c, d) => {
+          r._finishPromise_resolve = c, r._finishPromise_reject = d;
+        });
+        const u = r._cancelAlgorithm(t2);
+        return ur(r), g(u, () => (s._state === "errored" ? rt(r, s._storedError) : (oe(s._readableStreamController, t2), pn(r)), null), (c) => (oe(s._readableStreamController, c), rt(r, c), null)), r._finishPromise;
+      }
+      n2(Bs, "TransformStreamDefaultSinkAbortAlgorithm");
+      function ks(e) {
+        const t2 = e._transformStreamController;
+        if (t2._finishPromise !== void 0) return t2._finishPromise;
+        const r = e._readable;
+        t2._finishPromise = A((u, c) => {
+          t2._finishPromise_resolve = u, t2._finishPromise_reject = c;
+        });
+        const s = t2._flushAlgorithm();
+        return ur(t2), g(s, () => (r._state === "errored" ? rt(t2, r._storedError) : (De(r._readableStreamController), pn(t2)), null), (u) => (oe(r._readableStreamController, u), rt(t2, u), null)), t2._finishPromise;
+      }
+      n2(ks, "TransformStreamDefaultSinkCloseAlgorithm");
+      function Ws(e) {
+        return sr(e, false), e._backpressureChangePromise;
+      }
+      n2(Ws, "TransformStreamDefaultSourcePullAlgorithm");
+      function qs(e, t2) {
+        const r = e._transformStreamController;
+        if (r._finishPromise !== void 0) return r._finishPromise;
+        const s = e._writable;
+        r._finishPromise = A((c, d) => {
+          r._finishPromise_resolve = c, r._finishPromise_reject = d;
+        });
+        const u = r._cancelAlgorithm(t2);
+        return ur(r), g(u, () => (s._state === "errored" ? rt(r, s._storedError) : (Ct(s._writableStreamController, t2), hn(e), pn(r)), null), (c) => (Ct(s._writableStreamController, c), hn(e), rt(r, c), null)), r._finishPromise;
+      }
+      n2(qs, "TransformStreamDefaultSourceCancelAlgorithm");
+      function fr(e) {
+        return new TypeError(`TransformStreamDefaultController.prototype.${e} can only be used on a TransformStreamDefaultController`);
+      }
+      n2(fr, "defaultControllerBrandCheckException");
+      function pn(e) {
+        e._finishPromise_resolve !== void 0 && (e._finishPromise_resolve(), e._finishPromise_resolve = void 0, e._finishPromise_reject = void 0);
+      }
+      n2(pn, "defaultControllerFinishPromiseResolve");
+      function rt(e, t2) {
+        e._finishPromise_reject !== void 0 && (Q(e._finishPromise), e._finishPromise_reject(t2), e._finishPromise_resolve = void 0, e._finishPromise_reject = void 0);
+      }
+      n2(rt, "defaultControllerFinishPromiseReject");
+      function li(e) {
+        return new TypeError(`TransformStream.prototype.${e} can only be used on a TransformStream`);
+      }
+      n2(li, "streamBrandCheckException"), a.ByteLengthQueuingStrategy = Xe, a.CountQueuingStrategy = et, a.ReadableByteStreamController = te, a.ReadableStream = L, a.ReadableStreamBYOBReader = ce, a.ReadableStreamBYOBRequest = Re, a.ReadableStreamDefaultController = ne, a.ReadableStreamDefaultReader = fe, a.TransformStream = tt, a.TransformStreamDefaultController = pe, a.WritableStream = de, a.WritableStreamDefaultController = ke, a.WritableStreamDefaultWriter = re;
+    });
+  }(kt, kt.exports)), kt.exports;
+}
+n2(Ns, "requirePonyfill_es2018");
+var mi;
+function Hs() {
+  if (mi) return pi;
+  mi = 1;
+  const i = 65536;
+  if (!globalThis.ReadableStream) try {
+    const o2 = __require("node:process"), { emitWarning: a } = o2;
+    try {
+      o2.emitWarning = () => {
+      }, Object.assign(globalThis, __require("node:stream/web")), o2.emitWarning = a;
+    } catch (f2) {
+      throw o2.emitWarning = a, f2;
+    }
+  } catch {
+    Object.assign(globalThis, Ns());
+  }
+  try {
+    const { Blob: o2 } = __require("buffer");
+    o2 && !o2.prototype.stream && (o2.prototype.stream = n2(function(f2) {
+      let l = 0;
+      const p = this;
+      return new ReadableStream({ type: "bytes", async pull(h) {
+        const v = await p.slice(l, Math.min(p.size, l + i)).arrayBuffer();
+        l += v.byteLength, h.enqueue(new Uint8Array(v)), l === p.size && h.close();
+      } });
+    }, "name"));
+  } catch {
+  }
+  return pi;
+}
+n2(Hs, "requireStreams"), Hs();
+var yi = 65536;
+async function* Wn(i, o2 = true) {
+  for (const a of i) if ("stream" in a) yield* a.stream();
+  else if (ArrayBuffer.isView(a)) if (o2) {
+    let f2 = a.byteOffset;
+    const l = a.byteOffset + a.byteLength;
+    for (; f2 !== l; ) {
+      const p = Math.min(l - f2, yi), h = a.buffer.slice(f2, f2 + p);
+      f2 += h.byteLength, yield new Uint8Array(h);
+    }
+  } else yield a;
+  else {
+    let f2 = 0, l = a;
+    for (; f2 !== l.size; ) {
+      const h = await l.slice(f2, Math.min(l.size, f2 + yi)).arrayBuffer();
+      f2 += h.byteLength, yield new Uint8Array(h);
+    }
+  }
+}
+n2(Wn, "toIterator");
+var gi = (ze = class {
+  constructor(o2 = [], a = {}) {
+    be(this, ve, []);
+    be(this, zt, "");
+    be(this, bt, 0);
+    be(this, Cr, "transparent");
+    if (typeof o2 != "object" || o2 === null) throw new TypeError("Failed to construct 'Blob': The provided value cannot be converted to a sequence.");
+    if (typeof o2[Symbol.iterator] != "function") throw new TypeError("Failed to construct 'Blob': The object must have a callable @@iterator property.");
+    if (typeof a != "object" && typeof a != "function") throw new TypeError("Failed to construct 'Blob': parameter 2 cannot convert to dictionary.");
+    a === null && (a = {});
+    const f2 = new TextEncoder();
+    for (const p of o2) {
+      let h;
+      ArrayBuffer.isView(p) ? h = new Uint8Array(p.buffer.slice(p.byteOffset, p.byteOffset + p.byteLength)) : p instanceof ArrayBuffer ? h = new Uint8Array(p.slice(0)) : p instanceof ze ? h = p : h = f2.encode(`${p}`), X(this, bt, O(this, bt) + (ArrayBuffer.isView(h) ? h.byteLength : h.size)), O(this, ve).push(h);
+    }
+    X(this, Cr, `${a.endings === void 0 ? "transparent" : a.endings}`);
+    const l = a.type === void 0 ? "" : String(a.type);
+    X(this, zt, /^[\x20-\x7E]*$/.test(l) ? l : "");
+  }
+  get size() {
+    return O(this, bt);
+  }
+  get type() {
+    return O(this, zt);
+  }
+  async text() {
+    const o2 = new TextDecoder();
+    let a = "";
+    for await (const f2 of Wn(O(this, ve), false)) a += o2.decode(f2, { stream: true });
+    return a += o2.decode(), a;
+  }
+  async arrayBuffer() {
+    const o2 = new Uint8Array(this.size);
+    let a = 0;
+    for await (const f2 of Wn(O(this, ve), false)) o2.set(f2, a), a += f2.length;
+    return o2.buffer;
+  }
+  stream() {
+    const o2 = Wn(O(this, ve), true);
+    return new globalThis.ReadableStream({ type: "bytes", async pull(a) {
+      const f2 = await o2.next();
+      f2.done ? a.close() : a.enqueue(f2.value);
+    }, async cancel() {
+      await o2.return();
+    } });
+  }
+  slice(o2 = 0, a = this.size, f2 = "") {
+    const { size: l } = this;
+    let p = o2 < 0 ? Math.max(l + o2, 0) : Math.min(o2, l), h = a < 0 ? Math.max(l + a, 0) : Math.min(a, l);
+    const S = Math.max(h - p, 0), v = O(this, ve), w = [];
+    let A = 0;
+    for (const b of v) {
+      if (A >= S) break;
+      const q = ArrayBuffer.isView(b) ? b.byteLength : b.size;
+      if (p && q <= p) p -= q, h -= q;
+      else {
+        let g;
+        ArrayBuffer.isView(b) ? (g = b.subarray(p, Math.min(q, h)), A += g.byteLength) : (g = b.slice(p, Math.min(q, h)), A += g.size), h -= q, w.push(g), p = 0;
+      }
+    }
+    const T = new ze([], { type: String(f2).toLowerCase() });
+    return X(T, bt, S), X(T, ve, w), T;
+  }
+  get [Symbol.toStringTag]() {
+    return "Blob";
+  }
+  static [Symbol.hasInstance](o2) {
+    return o2 && typeof o2 == "object" && typeof o2.constructor == "function" && (typeof o2.stream == "function" || typeof o2.arrayBuffer == "function") && /^(Blob|File)$/.test(o2[Symbol.toStringTag]);
+  }
+}, ve = /* @__PURE__ */ new WeakMap(), zt = /* @__PURE__ */ new WeakMap(), bt = /* @__PURE__ */ new WeakMap(), Cr = /* @__PURE__ */ new WeakMap(), n2(ze, "Blob"), ze);
+Object.defineProperties(gi.prototype, { size: { enumerable: true }, type: { enumerable: true }, slice: { enumerable: true } });
+var ut = gi;
+var Vs = (mt = class extends ut {
+  constructor(a, f2, l = {}) {
+    if (arguments.length < 2) throw new TypeError(`Failed to construct 'File': 2 arguments required, but only ${arguments.length} present.`);
+    super(a, l);
+    be(this, It, 0);
+    be(this, Ft, "");
+    l === null && (l = {});
+    const p = l.lastModified === void 0 ? Date.now() : Number(l.lastModified);
+    Number.isNaN(p) || X(this, It, p), X(this, Ft, String(f2));
+  }
+  get name() {
+    return O(this, Ft);
+  }
+  get lastModified() {
+    return O(this, It);
+  }
+  get [Symbol.toStringTag]() {
+    return "File";
+  }
+  static [Symbol.hasInstance](a) {
+    return !!a && a instanceof ut && /^(File)$/.test(a[Symbol.toStringTag]);
+  }
+}, It = /* @__PURE__ */ new WeakMap(), Ft = /* @__PURE__ */ new WeakMap(), n2(mt, "File"), mt);
+var qn = Vs;
+var { toStringTag: Wt, iterator: Qs, hasInstance: Ys } = Symbol;
+var _i = Math.random;
+var Gs = "append,set,get,getAll,delete,keys,values,entries,forEach,constructor".split(",");
+var Si = n2((i, o2, a) => (i += "", /^(Blob|File)$/.test(o2 && o2[Wt]) ? [(a = a !== void 0 ? a + "" : o2[Wt] == "File" ? o2.name : "blob", i), o2.name !== a || o2[Wt] == "blob" ? new qn([o2], a, o2) : o2] : [i, o2 + ""]), "f");
+var On = n2((i, o2) => (o2 ? i : i.replace(/\r?\n|\r/g, `\r
+`)).replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22"), "e$1");
+var Ue = n2((i, o2, a) => {
+  if (o2.length < a) throw new TypeError(`Failed to execute '${i}' on 'FormData': ${a} arguments required, but only ${o2.length} present.`);
+}, "x");
+var br = (yt = class {
+  constructor(...o2) {
+    be(this, ee, []);
+    if (o2.length) throw new TypeError("Failed to construct 'FormData': parameter 1 is not of type 'HTMLFormElement'.");
+  }
+  get [Wt]() {
+    return "FormData";
+  }
+  [Qs]() {
+    return this.entries();
+  }
+  static [Ys](o2) {
+    return o2 && typeof o2 == "object" && o2[Wt] === "FormData" && !Gs.some((a) => typeof o2[a] != "function");
+  }
+  append(...o2) {
+    Ue("append", arguments, 2), O(this, ee).push(Si(...o2));
+  }
+  delete(o2) {
+    Ue("delete", arguments, 1), o2 += "", X(this, ee, O(this, ee).filter(([a]) => a !== o2));
+  }
+  get(o2) {
+    Ue("get", arguments, 1), o2 += "";
+    for (var a = O(this, ee), f2 = a.length, l = 0; l < f2; l++) if (a[l][0] === o2) return a[l][1];
+    return null;
+  }
+  getAll(o2, a) {
+    return Ue("getAll", arguments, 1), a = [], o2 += "", O(this, ee).forEach((f2) => f2[0] === o2 && a.push(f2[1])), a;
+  }
+  has(o2) {
+    return Ue("has", arguments, 1), o2 += "", O(this, ee).some((a) => a[0] === o2);
+  }
+  forEach(o2, a) {
+    Ue("forEach", arguments, 1);
+    for (var [f2, l] of this) o2.call(a, l, f2, this);
+  }
+  set(...o2) {
+    Ue("set", arguments, 2);
+    var a = [], f2 = true;
+    o2 = Si(...o2), O(this, ee).forEach((l) => {
+      l[0] === o2[0] ? f2 && (f2 = !a.push(o2)) : a.push(l);
+    }), f2 && a.push(o2), X(this, ee, a);
+  }
+  *entries() {
+    yield* O(this, ee);
+  }
+  *keys() {
+    for (var [o2] of this) yield o2;
+  }
+  *values() {
+    for (var [, o2] of this) yield o2;
+  }
+}, ee = /* @__PURE__ */ new WeakMap(), n2(yt, "FormData"), yt);
+function Zs(i, o2 = ut) {
+  var a = `${_i()}${_i()}`.replace(/\./g, "").slice(-28).padStart(32, "-"), f2 = [], l = `--${a}\r
+Content-Disposition: form-data; name="`;
+  return i.forEach((p, h) => typeof p == "string" ? f2.push(l + On(h) + `"\r
+\r
+${p.replace(/\r(?!\n)|(?<!\r)\n/g, `\r
+`)}\r
+`) : f2.push(l + On(h) + `"; filename="${On(p.name, 1)}"\r
+Content-Type: ${p.type || "application/octet-stream"}\r
+\r
+`, p, `\r
+`)), f2.push(`--${a}--`), new o2(f2, { type: "multipart/form-data; boundary=" + a });
+}
+n2(Zs, "formDataToBlob");
+var Un = class Un2 extends Error {
+  constructor(o2, a) {
+    super(o2), Error.captureStackTrace(this, this.constructor), this.type = a;
+  }
+  get name() {
+    return this.constructor.name;
+  }
+  get [Symbol.toStringTag]() {
+    return this.constructor.name;
+  }
+};
+n2(Un, "FetchBaseError");
+var ft = Un;
+var xn = class xn2 extends ft {
+  constructor(o2, a, f2) {
+    super(o2, a), f2 && (this.code = this.errno = f2.code, this.erroredSysCall = f2.syscall);
+  }
+};
+n2(xn, "FetchError");
+var G = xn;
+var mr = Symbol.toStringTag;
+var wi = n2((i) => typeof i == "object" && typeof i.append == "function" && typeof i.delete == "function" && typeof i.get == "function" && typeof i.getAll == "function" && typeof i.has == "function" && typeof i.set == "function" && typeof i.sort == "function" && i[mr] === "URLSearchParams", "isURLSearchParameters");
+var yr = n2((i) => i && typeof i == "object" && typeof i.arrayBuffer == "function" && typeof i.type == "string" && typeof i.stream == "function" && typeof i.constructor == "function" && /^(Blob|File)$/.test(i[mr]), "isBlob");
+var Ks = n2((i) => typeof i == "object" && (i[mr] === "AbortSignal" || i[mr] === "EventTarget"), "isAbortSignal");
+var Js = n2((i, o2) => {
+  const a = new URL(o2).hostname, f2 = new URL(i).hostname;
+  return a === f2 || a.endsWith(`.${f2}`);
+}, "isDomainOrSubdomain");
+var Xs = n2((i, o2) => {
+  const a = new URL(o2).protocol, f2 = new URL(i).protocol;
+  return a === f2;
+}, "isSameProtocol");
+var el = Is(me.pipeline);
+var H = Symbol("Body internals");
+var Nn = class Nn2 {
+  constructor(o2, { size: a = 0 } = {}) {
+    let f2 = null;
+    o2 === null ? o2 = null : wi(o2) ? o2 = M.from(o2.toString()) : yr(o2) || M.isBuffer(o2) || (hr.isAnyArrayBuffer(o2) ? o2 = M.from(o2) : ArrayBuffer.isView(o2) ? o2 = M.from(o2.buffer, o2.byteOffset, o2.byteLength) : o2 instanceof me || (o2 instanceof br ? (o2 = Zs(o2), f2 = o2.type.split("=")[1]) : o2 = M.from(String(o2))));
+    let l = o2;
+    M.isBuffer(o2) ? l = me.Readable.from(o2) : yr(o2) && (l = me.Readable.from(o2.stream())), this[H] = { body: o2, stream: l, boundary: f2, disturbed: false, error: null }, this.size = a, o2 instanceof me && o2.on("error", (p) => {
+      const h = p instanceof ft ? p : new G(`Invalid response body while trying to fetch ${this.url}: ${p.message}`, "system", p);
+      this[H].error = h;
+    });
+  }
+  get body() {
+    return this[H].stream;
+  }
+  get bodyUsed() {
+    return this[H].disturbed;
+  }
+  async arrayBuffer() {
+    const { buffer: o2, byteOffset: a, byteLength: f2 } = await zn(this);
+    return o2.slice(a, a + f2);
+  }
+  async formData() {
+    const o2 = this.headers.get("content-type");
+    if (o2.startsWith("application/x-www-form-urlencoded")) {
+      const f2 = new br(), l = new URLSearchParams(await this.text());
+      for (const [p, h] of l) f2.append(p, h);
+      return f2;
+    }
+    const { toFormData: a } = await import("./multipart-parser-PQ4MHJFX.js");
+    return a(this.body, o2);
+  }
+  async blob() {
+    const o2 = this.headers && this.headers.get("content-type") || this[H].body && this[H].body.type || "", a = await this.arrayBuffer();
+    return new ut([a], { type: o2 });
+  }
+  async json() {
+    const o2 = await this.text();
+    return JSON.parse(o2);
+  }
+  async text() {
+    const o2 = await zn(this);
+    return new TextDecoder().decode(o2);
+  }
+  buffer() {
+    return zn(this);
+  }
+};
+n2(Nn, "Body");
+var xe = Nn;
+xe.prototype.buffer = pr(xe.prototype.buffer, "Please use 'response.arrayBuffer()' instead of 'response.buffer()'", "node-fetch#buffer"), Object.defineProperties(xe.prototype, { body: { enumerable: true }, bodyUsed: { enumerable: true }, arrayBuffer: { enumerable: true }, blob: { enumerable: true }, json: { enumerable: true }, text: { enumerable: true }, data: { get: pr(() => {
+}, "data doesn't exist, use json(), text(), arrayBuffer(), or body instead", "https://github.com/node-fetch/node-fetch/issues/1000 (response)") } });
+async function zn(i) {
+  if (i[H].disturbed) throw new TypeError(`body used already for: ${i.url}`);
+  if (i[H].disturbed = true, i[H].error) throw i[H].error;
+  const { body: o2 } = i;
+  if (o2 === null) return M.alloc(0);
+  if (!(o2 instanceof me)) return M.alloc(0);
+  const a = [];
+  let f2 = 0;
+  try {
+    for await (const l of o2) {
+      if (i.size > 0 && f2 + l.length > i.size) {
+        const p = new G(`content size at ${i.url} over limit: ${i.size}`, "max-size");
+        throw o2.destroy(p), p;
+      }
+      f2 += l.length, a.push(l);
+    }
+  } catch (l) {
+    throw l instanceof ft ? l : new G(`Invalid response body while trying to fetch ${i.url}: ${l.message}`, "system", l);
+  }
+  if (o2.readableEnded === true || o2._readableState.ended === true) try {
+    return a.every((l) => typeof l == "string") ? M.from(a.join("")) : M.concat(a, f2);
+  } catch (l) {
+    throw new G(`Could not create Buffer from response body for ${i.url}: ${l.message}`, "system", l);
+  }
+  else throw new G(`Premature close of server response while trying to fetch ${i.url}`);
+}
+n2(zn, "consumeBody");
+var In = n2((i, o2) => {
+  let a, f2, { body: l } = i[H];
+  if (i.bodyUsed) throw new Error("cannot clone body after it is used");
+  return l instanceof me && typeof l.getBoundary != "function" && (a = new dr({ highWaterMark: o2 }), f2 = new dr({ highWaterMark: o2 }), l.pipe(a), l.pipe(f2), i[H].stream = a, l = f2), l;
+}, "clone");
+var tl = pr((i) => i.getBoundary(), "form-data doesn't follow the spec and requires special treatment. Use alternative package", "https://github.com/node-fetch/node-fetch/issues/1167");
+var Ri = n2((i, o2) => i === null ? null : typeof i == "string" ? "text/plain;charset=UTF-8" : wi(i) ? "application/x-www-form-urlencoded;charset=UTF-8" : yr(i) ? i.type || null : M.isBuffer(i) || hr.isAnyArrayBuffer(i) || ArrayBuffer.isView(i) ? null : i instanceof br ? `multipart/form-data; boundary=${o2[H].boundary}` : i && typeof i.getBoundary == "function" ? `multipart/form-data;boundary=${tl(i)}` : i instanceof me ? null : "text/plain;charset=UTF-8", "extractContentType");
+var rl = n2((i) => {
+  const { body: o2 } = i[H];
+  return o2 === null ? 0 : yr(o2) ? o2.size : M.isBuffer(o2) ? o2.length : o2 && typeof o2.getLengthSync == "function" && o2.hasKnownLength && o2.hasKnownLength() ? o2.getLengthSync() : null;
+}, "getTotalBytes");
+var nl = n2(async (i, { body: o2 }) => {
+  o2 === null ? i.end() : await el(o2, i);
+}, "writeToStream");
+var gr = typeof Bt.validateHeaderName == "function" ? Bt.validateHeaderName : (i) => {
+  if (!/^[\^`\-\w!#$%&'*+.|~]+$/.test(i)) {
+    const o2 = new TypeError(`Header name must be a valid HTTP token [${i}]`);
+    throw Object.defineProperty(o2, "code", { value: "ERR_INVALID_HTTP_TOKEN" }), o2;
+  }
+};
+var Fn = typeof Bt.validateHeaderValue == "function" ? Bt.validateHeaderValue : (i, o2) => {
+  if (/[^\t\u0020-\u007E\u0080-\u00FF]/.test(o2)) {
+    const a = new TypeError(`Invalid character in header content ["${i}"]`);
+    throw Object.defineProperty(a, "code", { value: "ERR_INVALID_CHAR" }), a;
+  }
+};
+var Pr = class Pr2 extends URLSearchParams {
+  constructor(o2) {
+    let a = [];
+    if (o2 instanceof Pr2) {
+      const f2 = o2.raw();
+      for (const [l, p] of Object.entries(f2)) a.push(...p.map((h) => [l, h]));
+    } else if (o2 != null) if (typeof o2 == "object" && !hr.isBoxedPrimitive(o2)) {
+      const f2 = o2[Symbol.iterator];
+      if (f2 == null) a.push(...Object.entries(o2));
+      else {
+        if (typeof f2 != "function") throw new TypeError("Header pairs must be iterable");
+        a = [...o2].map((l) => {
+          if (typeof l != "object" || hr.isBoxedPrimitive(l)) throw new TypeError("Each header pair must be an iterable object");
+          return [...l];
+        }).map((l) => {
+          if (l.length !== 2) throw new TypeError("Each header pair must be a name/value tuple");
+          return [...l];
+        });
+      }
+    } else throw new TypeError("Failed to construct 'Headers': The provided value is not of type '(sequence<sequence<ByteString>> or record<ByteString, ByteString>)");
+    return a = a.length > 0 ? a.map(([f2, l]) => (gr(f2), Fn(f2, String(l)), [String(f2).toLowerCase(), String(l)])) : void 0, super(a), new Proxy(this, { get(f2, l, p) {
+      switch (l) {
+        case "append":
+        case "set":
+          return (h, S) => (gr(h), Fn(h, String(S)), URLSearchParams.prototype[l].call(f2, String(h).toLowerCase(), String(S)));
+        case "delete":
+        case "has":
+        case "getAll":
+          return (h) => (gr(h), URLSearchParams.prototype[l].call(f2, String(h).toLowerCase()));
+        case "keys":
+          return () => (f2.sort(), new Set(URLSearchParams.prototype.keys.call(f2)).keys());
+        default:
+          return Reflect.get(f2, l, p);
+      }
+    } });
+  }
+  get [Symbol.toStringTag]() {
+    return this.constructor.name;
+  }
+  toString() {
+    return Object.prototype.toString.call(this);
+  }
+  get(o2) {
+    const a = this.getAll(o2);
+    if (a.length === 0) return null;
+    let f2 = a.join(", ");
+    return /^content-encoding$/i.test(o2) && (f2 = f2.toLowerCase()), f2;
+  }
+  forEach(o2, a = void 0) {
+    for (const f2 of this.keys()) Reflect.apply(o2, a, [this.get(f2), f2, this]);
+  }
+  *values() {
+    for (const o2 of this.keys()) yield this.get(o2);
+  }
+  *entries() {
+    for (const o2 of this.keys()) yield [o2, this.get(o2)];
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  raw() {
+    return [...this.keys()].reduce((o2, a) => (o2[a] = this.getAll(a), o2), {});
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return [...this.keys()].reduce((o2, a) => {
+      const f2 = this.getAll(a);
+      return a === "host" ? o2[a] = f2[0] : o2[a] = f2.length > 1 ? f2 : f2[0], o2;
+    }, {});
+  }
+};
+n2(Pr, "Headers");
+var ye = Pr;
+Object.defineProperties(ye.prototype, ["get", "entries", "forEach", "values"].reduce((i, o2) => (i[o2] = { enumerable: true }, i), {}));
+function ol(i = []) {
+  return new ye(i.reduce((o2, a, f2, l) => (f2 % 2 === 0 && o2.push(l.slice(f2, f2 + 2)), o2), []).filter(([o2, a]) => {
+    try {
+      return gr(o2), Fn(o2, String(a)), true;
+    } catch {
+      return false;
+    }
+  }));
+}
+n2(ol, "fromRawHeaders");
+var il = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+var jn = n2((i) => il.has(i), "isRedirect");
+var se = Symbol("Response internals");
+var Ne = class Ne2 extends xe {
+  constructor(o2 = null, a = {}) {
+    super(o2, a);
+    const f2 = a.status != null ? a.status : 200, l = new ye(a.headers);
+    if (o2 !== null && !l.has("Content-Type")) {
+      const p = Ri(o2, this);
+      p && l.append("Content-Type", p);
+    }
+    this[se] = { type: "default", url: a.url, status: f2, statusText: a.statusText || "", headers: l, counter: a.counter, highWaterMark: a.highWaterMark };
+  }
+  get type() {
+    return this[se].type;
+  }
+  get url() {
+    return this[se].url || "";
+  }
+  get status() {
+    return this[se].status;
+  }
+  get ok() {
+    return this[se].status >= 200 && this[se].status < 300;
+  }
+  get redirected() {
+    return this[se].counter > 0;
+  }
+  get statusText() {
+    return this[se].statusText;
+  }
+  get headers() {
+    return this[se].headers;
+  }
+  get highWaterMark() {
+    return this[se].highWaterMark;
+  }
+  clone() {
+    return new Ne2(In(this, this.highWaterMark), { type: this.type, url: this.url, status: this.status, statusText: this.statusText, headers: this.headers, ok: this.ok, redirected: this.redirected, size: this.size, highWaterMark: this.highWaterMark });
+  }
+  static redirect(o2, a = 302) {
+    if (!jn(a)) throw new RangeError('Failed to execute "redirect" on "response": Invalid status code');
+    return new Ne2(null, { headers: { location: new URL(o2).toString() }, status: a });
+  }
+  static error() {
+    const o2 = new Ne2(null, { status: 0, statusText: "" });
+    return o2[se].type = "error", o2;
+  }
+  static json(o2 = void 0, a = {}) {
+    const f2 = JSON.stringify(o2);
+    if (f2 === void 0) throw new TypeError("data is not JSON serializable");
+    const l = new ye(a && a.headers);
+    return l.has("content-type") || l.set("content-type", "application/json"), new Ne2(f2, { ...a, headers: l });
+  }
+  get [Symbol.toStringTag]() {
+    return "Response";
+  }
+};
+n2(Ne, "Response");
+var le = Ne;
+Object.defineProperties(le.prototype, { type: { enumerable: true }, url: { enumerable: true }, status: { enumerable: true }, ok: { enumerable: true }, redirected: { enumerable: true }, statusText: { enumerable: true }, headers: { enumerable: true }, clone: { enumerable: true } });
+var al = n2((i) => {
+  if (i.search) return i.search;
+  const o2 = i.href.length - 1, a = i.hash || (i.href[o2] === "#" ? "#" : "");
+  return i.href[o2 - a.length] === "?" ? "?" : "";
+}, "getSearch");
+function Ti(i, o2 = false) {
+  return i == null || (i = new URL(i), /^(about|blob|data):$/.test(i.protocol)) ? "no-referrer" : (i.username = "", i.password = "", i.hash = "", o2 && (i.pathname = "", i.search = ""), i);
+}
+n2(Ti, "stripURLForUseAsAReferrer");
+var Ci = /* @__PURE__ */ new Set(["", "no-referrer", "no-referrer-when-downgrade", "same-origin", "origin", "strict-origin", "origin-when-cross-origin", "strict-origin-when-cross-origin", "unsafe-url"]);
+var sl = "strict-origin-when-cross-origin";
+function ll(i) {
+  if (!Ci.has(i)) throw new TypeError(`Invalid referrerPolicy: ${i}`);
+  return i;
+}
+n2(ll, "validateReferrerPolicy");
+function ul(i) {
+  if (/^(http|ws)s:$/.test(i.protocol)) return true;
+  const o2 = i.host.replace(/(^\[)|(]$)/g, ""), a = Ls(o2);
+  return a === 4 && /^127\./.test(o2) || a === 6 && /^(((0+:){7})|(::(0+:){0,6}))0*1$/.test(o2) ? true : i.host === "localhost" || i.host.endsWith(".localhost") ? false : i.protocol === "file:";
+}
+n2(ul, "isOriginPotentiallyTrustworthy");
+function ct(i) {
+  return /^about:(blank|srcdoc)$/.test(i) || i.protocol === "data:" || /^(blob|filesystem):$/.test(i.protocol) ? true : ul(i);
+}
+n2(ct, "isUrlPotentiallyTrustworthy");
+function fl(i, { referrerURLCallback: o2, referrerOriginCallback: a } = {}) {
+  if (i.referrer === "no-referrer" || i.referrerPolicy === "") return null;
+  const f2 = i.referrerPolicy;
+  if (i.referrer === "about:client") return "no-referrer";
+  const l = i.referrer;
+  let p = Ti(l), h = Ti(l, true);
+  p.toString().length > 4096 && (p = h), o2 && (p = o2(p)), a && (h = a(h));
+  const S = new URL(i.url);
+  switch (f2) {
+    case "no-referrer":
+      return "no-referrer";
+    case "origin":
+      return h;
+    case "unsafe-url":
+      return p;
+    case "strict-origin":
+      return ct(p) && !ct(S) ? "no-referrer" : h.toString();
+    case "strict-origin-when-cross-origin":
+      return p.origin === S.origin ? p : ct(p) && !ct(S) ? "no-referrer" : h;
+    case "same-origin":
+      return p.origin === S.origin ? p : "no-referrer";
+    case "origin-when-cross-origin":
+      return p.origin === S.origin ? p : h;
+    case "no-referrer-when-downgrade":
+      return ct(p) && !ct(S) ? "no-referrer" : p;
+    default:
+      throw new TypeError(`Invalid referrerPolicy: ${f2}`);
+  }
+}
+n2(fl, "determineRequestsReferrer");
+function cl(i) {
+  const o2 = (i.get("referrer-policy") || "").split(/[,\s]+/);
+  let a = "";
+  for (const f2 of o2) f2 && Ci.has(f2) && (a = f2);
+  return a;
+}
+n2(cl, "parseReferrerPolicyFromHeader");
+var $ = Symbol("Request internals");
+var qt = n2((i) => typeof i == "object" && typeof i[$] == "object", "isRequest");
+var dl = pr(() => {
+}, ".data is not a valid RequestInit property, use .body instead", "https://github.com/node-fetch/node-fetch/issues/1000 (request)");
+var vr = class vr2 extends xe {
+  constructor(o2, a = {}) {
+    let f2;
+    if (qt(o2) ? f2 = new URL(o2.url) : (f2 = new URL(o2), o2 = {}), f2.username !== "" || f2.password !== "") throw new TypeError(`${f2} is an url with embedded credentials.`);
+    let l = a.method || o2.method || "GET";
+    if (/^(delete|get|head|options|post|put)$/i.test(l) && (l = l.toUpperCase()), !qt(a) && "data" in a && dl(), (a.body != null || qt(o2) && o2.body !== null) && (l === "GET" || l === "HEAD")) throw new TypeError("Request with GET/HEAD method cannot have body");
+    const p = a.body ? a.body : qt(o2) && o2.body !== null ? In(o2) : null;
+    super(p, { size: a.size || o2.size || 0 });
+    const h = new ye(a.headers || o2.headers || {});
+    if (p !== null && !h.has("Content-Type")) {
+      const w = Ri(p, this);
+      w && h.set("Content-Type", w);
+    }
+    let S = qt(o2) ? o2.signal : null;
+    if ("signal" in a && (S = a.signal), S != null && !Ks(S)) throw new TypeError("Expected signal to be an instanceof AbortSignal or EventTarget");
+    let v = a.referrer == null ? o2.referrer : a.referrer;
+    if (v === "") v = "no-referrer";
+    else if (v) {
+      const w = new URL(v);
+      v = /^about:(\/\/)?client$/.test(w) ? "client" : w;
+    } else v = void 0;
+    this[$] = { method: l, redirect: a.redirect || o2.redirect || "follow", headers: h, parsedURL: f2, signal: S, referrer: v }, this.follow = a.follow === void 0 ? o2.follow === void 0 ? 20 : o2.follow : a.follow, this.compress = a.compress === void 0 ? o2.compress === void 0 ? true : o2.compress : a.compress, this.counter = a.counter || o2.counter || 0, this.agent = a.agent || o2.agent, this.highWaterMark = a.highWaterMark || o2.highWaterMark || 16384, this.insecureHTTPParser = a.insecureHTTPParser || o2.insecureHTTPParser || false, this.referrerPolicy = a.referrerPolicy || o2.referrerPolicy || "";
+  }
+  get method() {
+    return this[$].method;
+  }
+  get url() {
+    return js(this[$].parsedURL);
+  }
+  get headers() {
+    return this[$].headers;
+  }
+  get redirect() {
+    return this[$].redirect;
+  }
+  get signal() {
+    return this[$].signal;
+  }
+  get referrer() {
+    if (this[$].referrer === "no-referrer") return "";
+    if (this[$].referrer === "client") return "about:client";
+    if (this[$].referrer) return this[$].referrer.toString();
+  }
+  get referrerPolicy() {
+    return this[$].referrerPolicy;
+  }
+  set referrerPolicy(o2) {
+    this[$].referrerPolicy = ll(o2);
+  }
+  clone() {
+    return new vr2(this);
+  }
+  get [Symbol.toStringTag]() {
+    return "Request";
+  }
+};
+n2(vr, "Request");
+var dt = vr;
+Object.defineProperties(dt.prototype, { method: { enumerable: true }, url: { enumerable: true }, headers: { enumerable: true }, redirect: { enumerable: true }, clone: { enumerable: true }, signal: { enumerable: true }, referrer: { enumerable: true }, referrerPolicy: { enumerable: true } });
+var hl = n2((i) => {
+  const { parsedURL: o2 } = i[$], a = new ye(i[$].headers);
+  a.has("Accept") || a.set("Accept", "*/*");
+  let f2 = null;
+  if (i.body === null && /^(post|put)$/i.test(i.method) && (f2 = "0"), i.body !== null) {
+    const S = rl(i);
+    typeof S == "number" && !Number.isNaN(S) && (f2 = String(S));
+  }
+  f2 && a.set("Content-Length", f2), i.referrerPolicy === "" && (i.referrerPolicy = sl), i.referrer && i.referrer !== "no-referrer" ? i[$].referrer = fl(i) : i[$].referrer = "no-referrer", i[$].referrer instanceof URL && a.set("Referer", i.referrer), a.has("User-Agent") || a.set("User-Agent", "node-fetch"), i.compress && !a.has("Accept-Encoding") && a.set("Accept-Encoding", "gzip, deflate, br");
+  let { agent: l } = i;
+  typeof l == "function" && (l = l(o2));
+  const p = al(o2), h = { path: o2.pathname + p, method: i.method, headers: a[Symbol.for("nodejs.util.inspect.custom")](), insecureHTTPParser: i.insecureHTTPParser, agent: l };
+  return { parsedURL: o2, options: h };
+}, "getNodeRequestOptions");
+var Hn = class Hn2 extends ft {
+  constructor(o2, a = "aborted") {
+    super(o2, a);
+  }
+};
+n2(Hn, "AbortError");
+var _r = Hn;
+var Ln;
+var Pi;
+function pl() {
+  if (Pi) return Ln;
+  if (Pi = 1, !globalThis.DOMException) try {
+    const { MessageChannel: i } = __require("worker_threads"), o2 = new i().port1, a = new ArrayBuffer();
+    o2.postMessage(a, [a, a]);
+  } catch (i) {
+    i.constructor.name === "DOMException" && (globalThis.DOMException = i.constructor);
+  }
+  return Ln = globalThis.DOMException, Ln;
+}
+n2(pl, "requireNodeDomexception");
+var bl = pl();
+var ml = f(bl);
+var { stat: $n } = $s;
+var yl = n2((i, o2) => vi(hi(i), i, o2), "blobFromSync");
+var gl = n2((i, o2) => $n(i).then((a) => vi(a, i, o2)), "blobFrom");
+var _l = n2((i, o2) => $n(i).then((a) => Ei(a, i, o2)), "fileFrom");
+var Sl = n2((i, o2) => Ei(hi(i), i, o2), "fileFromSync");
+var vi = n2((i, o2, a = "") => new ut([new Sr({ path: o2, size: i.size, lastModified: i.mtimeMs, start: 0 })], { type: a }), "fromBlob");
+var Ei = n2((i, o2, a = "") => new qn([new Sr({ path: o2, size: i.size, lastModified: i.mtimeMs, start: 0 })], Ms(o2), { type: a, lastModified: i.mtimeMs }), "fromFile");
+var Er = class Er2 {
+  constructor(o2) {
+    be(this, He);
+    be(this, Ve);
+    X(this, He, o2.path), X(this, Ve, o2.start), this.size = o2.size, this.lastModified = o2.lastModified;
+  }
+  slice(o2, a) {
+    return new Er2({ path: O(this, He), lastModified: this.lastModified, size: a - o2, start: O(this, Ve) + o2 });
+  }
+  async *stream() {
+    const { mtimeMs: o2 } = await $n(O(this, He));
+    if (o2 > this.lastModified) throw new ml("The requested file could not be read, typically due to permission problems that have occurred after a reference to a file was acquired.", "NotReadableError");
+    yield* Ds(O(this, He), { start: O(this, Ve), end: O(this, Ve) + this.size - 1 });
+  }
+  get [Symbol.toStringTag]() {
+    return "Blob";
+  }
+};
+He = /* @__PURE__ */ new WeakMap(), Ve = /* @__PURE__ */ new WeakMap(), n2(Er, "BlobDataItem");
+var Sr = Er;
+var wl = /* @__PURE__ */ new Set(["data:", "http:", "https:"]);
+async function Ai(i, o2) {
+  return new Promise((a, f2) => {
+    const l = new dt(i, o2), { parsedURL: p, options: h } = hl(l);
+    if (!wl.has(p.protocol)) throw new TypeError(`node-fetch cannot load ${i}. URL scheme "${p.protocol.replace(/:$/, "")}" is not supported.`);
+    if (p.protocol === "data:") {
+      const g = Us(l.url), V = new le(g, { headers: { "Content-Type": g.typeFull } });
+      a(V);
+      return;
+    }
+    const S = (p.protocol === "https:" ? zs : Bt).request, { signal: v } = l;
+    let w = null;
+    const A = n2(() => {
+      const g = new _r("The operation was aborted.");
+      f2(g), l.body && l.body instanceof me.Readable && l.body.destroy(g), !(!w || !w.body) && w.body.emit("error", g);
+    }, "abort");
+    if (v && v.aborted) {
+      A();
+      return;
+    }
+    const T = n2(() => {
+      A(), q();
+    }, "abortAndFinalize"), b = S(p.toString(), h);
+    v && v.addEventListener("abort", T);
+    const q = n2(() => {
+      b.abort(), v && v.removeEventListener("abort", T);
+    }, "finalize");
+    b.on("error", (g) => {
+      f2(new G(`request to ${l.url} failed, reason: ${g.message}`, "system", g)), q();
+    }), Rl(b, (g) => {
+      w && w.body && w.body.destroy(g);
+    }), process.version < "v14" && b.on("socket", (g) => {
+      let V;
+      g.prependListener("end", () => {
+        V = g._eventsCount;
+      }), g.prependListener("close", (I) => {
+        if (w && V < g._eventsCount && !I) {
+          const F = new Error("Premature close");
+          F.code = "ERR_STREAM_PREMATURE_CLOSE", w.body.emit("error", F);
+        }
+      });
+    }), b.on("response", (g) => {
+      b.setTimeout(0);
+      const V = ol(g.rawHeaders);
+      if (jn(g.statusCode)) {
+        const z = V.get("Location");
+        let j = null;
+        try {
+          j = z === null ? null : new URL(z, l.url);
+        } catch {
+          if (l.redirect !== "manual") {
+            f2(new G(`uri requested responds with an invalid redirect URL: ${z}`, "invalid-redirect")), q();
+            return;
+          }
+        }
+        switch (l.redirect) {
+          case "error":
+            f2(new G(`uri requested responds with a redirect, redirect mode is set to error: ${l.url}`, "no-redirect")), q();
+            return;
+          case "manual":
+            break;
+          case "follow": {
+            if (j === null) break;
+            if (l.counter >= l.follow) {
+              f2(new G(`maximum redirect reached at: ${l.url}`, "max-redirect")), q();
+              return;
+            }
+            const U = { headers: new ye(l.headers), follow: l.follow, counter: l.counter + 1, agent: l.agent, compress: l.compress, method: l.method, body: In(l), signal: l.signal, size: l.size, referrer: l.referrer, referrerPolicy: l.referrerPolicy };
+            if (!Js(l.url, j) || !Xs(l.url, j)) for (const jt of ["authorization", "www-authenticate", "cookie", "cookie2"]) U.headers.delete(jt);
+            if (g.statusCode !== 303 && l.body && o2.body instanceof me.Readable) {
+              f2(new G("Cannot follow redirect with body being a readable stream", "unsupported-redirect")), q();
+              return;
+            }
+            (g.statusCode === 303 || (g.statusCode === 301 || g.statusCode === 302) && l.method === "POST") && (U.method = "GET", U.body = void 0, U.headers.delete("content-length"));
+            const D = cl(V);
+            D && (U.referrerPolicy = D), a(Ai(new dt(j, U))), q();
+            return;
+          }
+          default:
+            return f2(new TypeError(`Redirect option '${l.redirect}' is not a valid value of RequestRedirect`));
+        }
+      }
+      v && g.once("end", () => {
+        v.removeEventListener("abort", T);
+      });
+      let I = lt(g, new dr(), (z) => {
+        z && f2(z);
+      });
+      process.version < "v12.10" && g.on("aborted", T);
+      const F = { url: l.url, status: g.statusCode, statusText: g.statusMessage, headers: V, size: l.size, counter: l.counter, highWaterMark: l.highWaterMark }, Q = V.get("Content-Encoding");
+      if (!l.compress || l.method === "HEAD" || Q === null || g.statusCode === 204 || g.statusCode === 304) {
+        w = new le(I, F), a(w);
+        return;
+      }
+      const ge = { flush: st.Z_SYNC_FLUSH, finishFlush: st.Z_SYNC_FLUSH };
+      if (Q === "gzip" || Q === "x-gzip") {
+        I = lt(I, st.createGunzip(ge), (z) => {
+          z && f2(z);
+        }), w = new le(I, F), a(w);
+        return;
+      }
+      if (Q === "deflate" || Q === "x-deflate") {
+        const z = lt(g, new dr(), (j) => {
+          j && f2(j);
+        });
+        z.once("data", (j) => {
+          (j[0] & 15) === 8 ? I = lt(I, st.createInflate(), (U) => {
+            U && f2(U);
+          }) : I = lt(I, st.createInflateRaw(), (U) => {
+            U && f2(U);
+          }), w = new le(I, F), a(w);
+        }), z.once("end", () => {
+          w || (w = new le(I, F), a(w));
+        });
+        return;
+      }
+      if (Q === "br") {
+        I = lt(I, st.createBrotliDecompress(), (z) => {
+          z && f2(z);
+        }), w = new le(I, F), a(w);
+        return;
+      }
+      w = new le(I, F), a(w);
+    }), nl(b, l).catch(f2);
+  });
+}
+n2(Ai, "fetch$1");
+function Rl(i, o2) {
+  const a = M.from(`0\r
+\r
+`);
+  let f2 = false, l = false, p;
+  i.on("response", (h) => {
+    const { headers: S } = h;
+    f2 = S["transfer-encoding"] === "chunked" && !S["content-length"];
+  }), i.on("socket", (h) => {
+    const S = n2(() => {
+      if (f2 && !l) {
+        const w = new Error("Premature close");
+        w.code = "ERR_STREAM_PREMATURE_CLOSE", o2(w);
+      }
+    }, "onSocketClose"), v = n2((w) => {
+      l = M.compare(w.slice(-5), a) === 0, !l && p && (l = M.compare(p.slice(-3), a.slice(0, 3)) === 0 && M.compare(w.slice(-2), a.slice(3)) === 0), p = w;
+    }, "onData");
+    h.prependListener("close", S), h.on("data", v), i.on("close", () => {
+      h.removeListener("close", S), h.removeListener("data", v);
+    });
+  });
+}
+n2(Rl, "fixResponseChunkedTransferBadEnding");
+var Bi = /* @__PURE__ */ new WeakMap();
+var Dn = /* @__PURE__ */ new WeakMap();
+function W(i) {
+  const o2 = Bi.get(i);
+  return console.assert(o2 != null, "'this' is expected an Event object, but got", i), o2;
+}
+n2(W, "pd");
+function ki(i) {
+  if (i.passiveListener != null) {
+    typeof console < "u" && typeof console.error == "function" && console.error("Unable to preventDefault inside passive event listener invocation.", i.passiveListener);
+    return;
+  }
+  i.event.cancelable && (i.canceled = true, typeof i.event.preventDefault == "function" && i.event.preventDefault());
+}
+n2(ki, "setCancelFlag");
+function ht(i, o2) {
+  Bi.set(this, { eventTarget: i, event: o2, eventPhase: 2, currentTarget: i, canceled: false, stopped: false, immediateStopped: false, passiveListener: null, timeStamp: o2.timeStamp || Date.now() }), Object.defineProperty(this, "isTrusted", { value: false, enumerable: true });
+  const a = Object.keys(o2);
+  for (let f2 = 0; f2 < a.length; ++f2) {
+    const l = a[f2];
+    l in this || Object.defineProperty(this, l, Wi(l));
+  }
+}
+n2(ht, "Event"), ht.prototype = { get type() {
+  return W(this).event.type;
+}, get target() {
+  return W(this).eventTarget;
+}, get currentTarget() {
+  return W(this).currentTarget;
+}, composedPath() {
+  const i = W(this).currentTarget;
+  return i == null ? [] : [i];
+}, get NONE() {
+  return 0;
+}, get CAPTURING_PHASE() {
+  return 1;
+}, get AT_TARGET() {
+  return 2;
+}, get BUBBLING_PHASE() {
+  return 3;
+}, get eventPhase() {
+  return W(this).eventPhase;
+}, stopPropagation() {
+  const i = W(this);
+  i.stopped = true, typeof i.event.stopPropagation == "function" && i.event.stopPropagation();
+}, stopImmediatePropagation() {
+  const i = W(this);
+  i.stopped = true, i.immediateStopped = true, typeof i.event.stopImmediatePropagation == "function" && i.event.stopImmediatePropagation();
+}, get bubbles() {
+  return !!W(this).event.bubbles;
+}, get cancelable() {
+  return !!W(this).event.cancelable;
+}, preventDefault() {
+  ki(W(this));
+}, get defaultPrevented() {
+  return W(this).canceled;
+}, get composed() {
+  return !!W(this).event.composed;
+}, get timeStamp() {
+  return W(this).timeStamp;
+}, get srcElement() {
+  return W(this).eventTarget;
+}, get cancelBubble() {
+  return W(this).stopped;
+}, set cancelBubble(i) {
+  if (!i) return;
+  const o2 = W(this);
+  o2.stopped = true, typeof o2.event.cancelBubble == "boolean" && (o2.event.cancelBubble = true);
+}, get returnValue() {
+  return !W(this).canceled;
+}, set returnValue(i) {
+  i || ki(W(this));
+}, initEvent() {
+} }, Object.defineProperty(ht.prototype, "constructor", { value: ht, configurable: true, writable: true }), typeof window < "u" && typeof window.Event < "u" && (Object.setPrototypeOf(ht.prototype, window.Event.prototype), Dn.set(window.Event.prototype, ht));
+function Wi(i) {
+  return { get() {
+    return W(this).event[i];
+  }, set(o2) {
+    W(this).event[i] = o2;
+  }, configurable: true, enumerable: true };
+}
+n2(Wi, "defineRedirectDescriptor");
+function Tl(i) {
+  return { value() {
+    const o2 = W(this).event;
+    return o2[i].apply(o2, arguments);
+  }, configurable: true, enumerable: true };
+}
+n2(Tl, "defineCallDescriptor");
+function Cl(i, o2) {
+  const a = Object.keys(o2);
+  if (a.length === 0) return i;
+  function f2(l, p) {
+    i.call(this, l, p);
+  }
+  n2(f2, "CustomEvent"), f2.prototype = Object.create(i.prototype, { constructor: { value: f2, configurable: true, writable: true } });
+  for (let l = 0; l < a.length; ++l) {
+    const p = a[l];
+    if (!(p in i.prototype)) {
+      const S = typeof Object.getOwnPropertyDescriptor(o2, p).value == "function";
+      Object.defineProperty(f2.prototype, p, S ? Tl(p) : Wi(p));
+    }
+  }
+  return f2;
+}
+n2(Cl, "defineWrapper");
+function qi(i) {
+  if (i == null || i === Object.prototype) return ht;
+  let o2 = Dn.get(i);
+  return o2 == null && (o2 = Cl(qi(Object.getPrototypeOf(i)), i), Dn.set(i, o2)), o2;
+}
+n2(qi, "getWrapper");
+function Pl(i, o2) {
+  const a = qi(Object.getPrototypeOf(o2));
+  return new a(i, o2);
+}
+n2(Pl, "wrapEvent");
+function vl(i) {
+  return W(i).immediateStopped;
+}
+n2(vl, "isStopped");
+function El(i, o2) {
+  W(i).eventPhase = o2;
+}
+n2(El, "setEventPhase");
+function Al(i, o2) {
+  W(i).currentTarget = o2;
+}
+n2(Al, "setCurrentTarget");
+function Oi(i, o2) {
+  W(i).passiveListener = o2;
+}
+n2(Oi, "setPassiveListener");
+var zi = /* @__PURE__ */ new WeakMap();
+var Ii = 1;
+var Fi = 2;
+var wr = 3;
+function Rr(i) {
+  return i !== null && typeof i == "object";
+}
+n2(Rr, "isObject");
+function Ot(i) {
+  const o2 = zi.get(i);
+  if (o2 == null) throw new TypeError("'this' is expected an EventTarget object, but got another value.");
+  return o2;
+}
+n2(Ot, "getListeners");
+function Bl(i) {
+  return { get() {
+    let a = Ot(this).get(i);
+    for (; a != null; ) {
+      if (a.listenerType === wr) return a.listener;
+      a = a.next;
+    }
+    return null;
+  }, set(o2) {
+    typeof o2 != "function" && !Rr(o2) && (o2 = null);
+    const a = Ot(this);
+    let f2 = null, l = a.get(i);
+    for (; l != null; ) l.listenerType === wr ? f2 !== null ? f2.next = l.next : l.next !== null ? a.set(i, l.next) : a.delete(i) : f2 = l, l = l.next;
+    if (o2 !== null) {
+      const p = { listener: o2, listenerType: wr, passive: false, once: false, next: null };
+      f2 === null ? a.set(i, p) : f2.next = p;
+    }
+  }, configurable: true, enumerable: true };
+}
+n2(Bl, "defineEventAttributeDescriptor");
+function ji(i, o2) {
+  Object.defineProperty(i, `on${o2}`, Bl(o2));
+}
+n2(ji, "defineEventAttribute");
+function Li(i) {
+  function o2() {
+    Pe.call(this);
+  }
+  n2(o2, "CustomEventTarget"), o2.prototype = Object.create(Pe.prototype, { constructor: { value: o2, configurable: true, writable: true } });
+  for (let a = 0; a < i.length; ++a) ji(o2.prototype, i[a]);
+  return o2;
+}
+n2(Li, "defineCustomEventTarget");
+function Pe() {
+  if (this instanceof Pe) {
+    zi.set(this, /* @__PURE__ */ new Map());
+    return;
+  }
+  if (arguments.length === 1 && Array.isArray(arguments[0])) return Li(arguments[0]);
+  if (arguments.length > 0) {
+    const i = new Array(arguments.length);
+    for (let o2 = 0; o2 < arguments.length; ++o2) i[o2] = arguments[o2];
+    return Li(i);
+  }
+  throw new TypeError("Cannot call a class as a function");
+}
+n2(Pe, "EventTarget"), Pe.prototype = { addEventListener(i, o2, a) {
+  if (o2 == null) return;
+  if (typeof o2 != "function" && !Rr(o2)) throw new TypeError("'listener' should be a function or an object.");
+  const f2 = Ot(this), l = Rr(a), h = (l ? !!a.capture : !!a) ? Ii : Fi, S = { listener: o2, listenerType: h, passive: l && !!a.passive, once: l && !!a.once, next: null };
+  let v = f2.get(i);
+  if (v === void 0) {
+    f2.set(i, S);
+    return;
+  }
+  let w = null;
+  for (; v != null; ) {
+    if (v.listener === o2 && v.listenerType === h) return;
+    w = v, v = v.next;
+  }
+  w.next = S;
+}, removeEventListener(i, o2, a) {
+  if (o2 == null) return;
+  const f2 = Ot(this), p = (Rr(a) ? !!a.capture : !!a) ? Ii : Fi;
+  let h = null, S = f2.get(i);
+  for (; S != null; ) {
+    if (S.listener === o2 && S.listenerType === p) {
+      h !== null ? h.next = S.next : S.next !== null ? f2.set(i, S.next) : f2.delete(i);
+      return;
+    }
+    h = S, S = S.next;
+  }
+}, dispatchEvent(i) {
+  if (i == null || typeof i.type != "string") throw new TypeError('"event.type" should be a string.');
+  const o2 = Ot(this), a = i.type;
+  let f2 = o2.get(a);
+  if (f2 == null) return true;
+  const l = Pl(this, i);
+  let p = null;
+  for (; f2 != null; ) {
+    if (f2.once ? p !== null ? p.next = f2.next : f2.next !== null ? o2.set(a, f2.next) : o2.delete(a) : p = f2, Oi(l, f2.passive ? f2.listener : null), typeof f2.listener == "function") try {
+      f2.listener.call(this, l);
+    } catch (h) {
+      typeof console < "u" && typeof console.error == "function" && console.error(h);
+    }
+    else f2.listenerType !== wr && typeof f2.listener.handleEvent == "function" && f2.listener.handleEvent(l);
+    if (vl(l)) break;
+    f2 = f2.next;
+  }
+  return Oi(l, null), El(l, 0), Al(l, null), !l.defaultPrevented;
+} }, Object.defineProperty(Pe.prototype, "constructor", { value: Pe, configurable: true, writable: true }), typeof window < "u" && typeof window.EventTarget < "u" && Object.setPrototypeOf(Pe.prototype, window.EventTarget.prototype);
+var Vn = class Vn2 extends Pe {
+  constructor() {
+    throw super(), new TypeError("AbortSignal cannot be constructed directly");
+  }
+  get aborted() {
+    const o2 = Tr.get(this);
+    if (typeof o2 != "boolean") throw new TypeError(`Expected 'this' to be an 'AbortSignal' object, but got ${this === null ? "null" : typeof this}`);
+    return o2;
+  }
+};
+n2(Vn, "AbortSignal");
+var pt = Vn;
+ji(pt.prototype, "abort");
+function kl() {
+  const i = Object.create(pt.prototype);
+  return Pe.call(i), Tr.set(i, false), i;
+}
+n2(kl, "createAbortSignal");
+function Wl(i) {
+  Tr.get(i) === false && (Tr.set(i, true), i.dispatchEvent({ type: "abort" }));
+}
+n2(Wl, "abortSignal");
+var Tr = /* @__PURE__ */ new WeakMap();
+Object.defineProperties(pt.prototype, { aborted: { enumerable: true } }), typeof Symbol == "function" && typeof Symbol.toStringTag == "symbol" && Object.defineProperty(pt.prototype, Symbol.toStringTag, { configurable: true, value: "AbortSignal" });
+var Mn = (gt = class {
+  constructor() {
+    $i.set(this, kl());
+  }
+  get signal() {
+    return Di(this);
+  }
+  abort() {
+    Wl(Di(this));
+  }
+}, n2(gt, "AbortController"), gt);
+var $i = /* @__PURE__ */ new WeakMap();
+function Di(i) {
+  const o2 = $i.get(i);
+  if (o2 == null) throw new TypeError(`Expected 'this' to be an 'AbortController' object, but got ${i === null ? "null" : typeof i}`);
+  return o2;
+}
+n2(Di, "getSignal"), Object.defineProperties(Mn.prototype, { signal: { enumerable: true }, abort: { enumerable: true } }), typeof Symbol == "function" && typeof Symbol.toStringTag == "symbol" && Object.defineProperty(Mn.prototype, Symbol.toStringTag, { configurable: true, value: "AbortController" });
+var ql = Object.defineProperty;
+var Ol = n2((i, o2) => ql(i, "name", { value: o2, configurable: true }), "e");
+var Mi = Ai;
+Ui();
+function Ui() {
+  !globalThis.process?.versions?.node && !globalThis.process?.env?.DISABLE_NODE_FETCH_NATIVE_WARN && console.warn("[node-fetch-native] Node.js compatible build of `node-fetch-native` is being used in a non-Node.js environment. Please make sure you are using proper export conditions or report this issue to https://github.com/unjs/node-fetch-native. You can set `process.env.DISABLE_NODE_FETCH_NATIVE_WARN` to disable this warning.");
+}
+n2(Ui, "s"), Ol(Ui, "checkNodeEnvironment");
+
+export {
+  ut,
+  qn,
+  br,
+  ye,
+  le,
+  dt,
+  Mn,
+  Mi
+};
+/*! Bundled license information:
+
+node-fetch-native/dist/node.mjs:
+  (**
+  * @license
+  * web-streams-polyfill v3.3.3
+  * Copyright 2024 Mattias Buelens, Diwank Singh Tomer and other contributors.
+  * This code is released under the MIT license.
+  * SPDX-License-Identifier: MIT
+  *)
+  (*! fetch-blob. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> *)
+  (*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> *)
+  (*! node-domexception. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> *)
+*/
+//# sourceMappingURL=chunk-VMSWFJV3.js.map