@feedmepos/mf-common 1.6.4 → 1.6.6-rc.1

package/dist/vite-preset-1fc4fac1.js

@@ -0,0 +1,3963 @@
+var _o = (i, n, a) => {
+  if (!n.has(i))
+    throw TypeError("Cannot " + a);
+};
+var F = (i, n, a) => (_o(i, n, "read from private field"), a ? a.call(i) : n.get(i)), Ae = (i, n, a) => {
+  if (n.has(i))
+    throw TypeError("Cannot add the same private member more than once");
+  n instanceof WeakSet ? n.add(i) : n.set(i, a);
+}, ae = (i, n, a, u) => (_o(i, n, "write to private field"), u ? u.call(i, a) : n.set(i, a), a);
+import { resolve as So } from "path";
+import { readFileSync as Ti } from "fs";
+import ht from "node:http";
+import Pi from "node:https";
+import Je from "node:zlib";
+import se, { PassThrough as Kt, pipeline as Ze } from "node:stream";
+import { Buffer as $ } from "node:buffer";
+import { types as Xt, promisify as vi, deprecate as or } from "node:util";
+import { format as Ei } from "node:url";
+import { isIP as Ai } from "node:net";
+import "node:fs";
+import "node:path";
+const Bi = (i) => {
+  const n = i.join("|");
+  return new RegExp(`^(${n})(\\/.*)?$`);
+}, Wi = ({
+  externals: i
+}) => {
+  const n = Bi(i);
+  return {
+    name: "externalize",
+    setup(a) {
+      a.onResolve({ filter: n }, (u) => ({
+        path: u.path,
+        namespace: "externalize"
+      })), a.onLoad({ filter: n }, () => ({
+        contents: ""
+      }));
+    }
+  };
+}, ki = (i) => {
+  const n = "/@id/", a = new RegExp(
+    `${n}(${i.join("|")})`,
+    "g"
+  );
+  return {
+    name: "vite-plugin-remove-prefix",
+    transform: (u) => a.test(u) ? u.replace(
+      a,
+      (l, h) => h
+    ) : u
+  };
+}, qi = (i) => {
+  const { externals: n } = i;
+  return {
+    name: "vite-plugin-externalize",
+    enforce: "pre",
+    apply: "serve",
+    config: (a) => {
+      var u;
+      const l = { ...a };
+      return l.optimizeDeps && l.optimizeDeps.esbuildOptions && ((u = l.optimizeDeps.esbuildOptions).plugins ?? (u.plugins = []), l.optimizeDeps.esbuildOptions.plugins.push(
+        Wi({ externals: n })
+      )), l;
+    },
+    configResolved: (a) => {
+      if (a.optimizeDeps && a.optimizeDeps.include) {
+        const l = a.optimizeDeps.include.filter(
+          (h) => !n.includes(h)
+        );
+        a.optimizeDeps.include = l;
+      }
+      a.optimizeDeps && (a.optimizeDeps.exclude = a.optimizeDeps.exclude || [], a.optimizeDeps.exclude.push(...n));
+      const u = ki(n);
+      a.plugins.push(u);
+    },
+    // Supresses the following warning:
+    // Failed to resolve import [dependency] from [sourceFile]. Does the file exist?
+    resolveId: (a) => n.includes(a) ? { id: a, external: !0 } : null,
+    // Supresses the following warning:
+    // The following dependencies are imported but could not be resolved:
+    // [dependency] (imported by [sourceFile])
+    load: (a) => n.includes(a) ? "export default {};" : null
+  };
+};
+function Oi(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 n = i.indexOf(",");
+  if (n === -1 || n <= 4)
+    throw new TypeError("malformed data: URI");
+  const a = i.substring(5, n).split(";");
+  let u = "", l = !1;
+  const h = a[0] || "text/plain";
+  let c = h;
+  for (let E = 1; E < a.length; E++)
+    a[E] === "base64" ? l = !0 : a[E] && (c += `;${a[E]}`, a[E].indexOf("charset=") === 0 && (u = a[E].substring(8)));
+  !a[0] && !u.length && (c += ";charset=US-ASCII", u = "US-ASCII");
+  const T = l ? "base64" : "ascii", v = unescape(i.substring(n + 1)), _ = Buffer.from(v, T);
+  return _.type = h, _.typeFull = c, _.charset = u, _;
+}
+var Vr = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}, Jt = { exports: {} };
+/**
+ * @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
+ */
+var wo;
+function zi() {
+  return wo || (wo = 1, function(i, n) {
+    (function(a, u) {
+      u(n);
+    })(Vr, function(a) {
+      function u() {
+      }
+      function l(e) {
+        return typeof e == "object" && e !== null || typeof e == "function";
+      }
+      const h = u;
+      function c(e, t) {
+        try {
+          Object.defineProperty(e, "name", {
+            value: t,
+            configurable: !0
+          });
+        } catch {
+        }
+      }
+      const T = Promise, v = Promise.prototype.then, _ = Promise.reject.bind(T);
+      function E(e) {
+        return new T(e);
+      }
+      function w(e) {
+        return E((t) => t(e));
+      }
+      function m(e) {
+        return _(e);
+      }
+      function W(e, t, r) {
+        return v.call(e, t, r);
+      }
+      function p(e, t, r) {
+        W(W(e, t, r), void 0, h);
+      }
+      function j(e, t) {
+        p(e, t);
+      }
+      function R(e, t) {
+        p(e, void 0, t);
+      }
+      function B(e, t, r) {
+        return W(e, t, r);
+      }
+      function L(e) {
+        W(e, void 0, h);
+      }
+      let Y = (e) => {
+        if (typeof queueMicrotask == "function")
+          Y = queueMicrotask;
+        else {
+          const t = w(void 0);
+          Y = (r) => W(t, r);
+        }
+        return Y(e);
+      };
+      function O(e, t, r) {
+        if (typeof e != "function")
+          throw new TypeError("Argument is not a function");
+        return Function.prototype.apply.call(e, t, r);
+      }
+      function z(e, t, r) {
+        try {
+          return w(O(e, t, r));
+        } catch (o) {
+          return m(o);
+        }
+      }
+      const M = 16384;
+      class U {
+        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;
+        }
+        // For exception safety, this method is structured in order:
+        // 1. Read state
+        // 2. Calculate required state mutations
+        // 3. Perform state mutations
+        push(t) {
+          const r = this._back;
+          let o = r;
+          r._elements.length === M - 1 && (o = {
+            _elements: [],
+            _next: void 0
+          }), r._elements.push(t), o !== r && (this._back = o, r._next = o), ++this._size;
+        }
+        // Like push(), shift() follows the read -> calculate -> mutate pattern for
+        // exception safety.
+        shift() {
+          const t = this._front;
+          let r = t;
+          const o = this._cursor;
+          let s = o + 1;
+          const f = t._elements, d = f[o];
+          return s === M && (r = t._next, s = 0), --this._size, this._cursor = s, t !== r && (this._front = r), f[o] = void 0, d;
+        }
+        // The tricky thing about forEach() is that it can be called
+        // re-entrantly. The queue may be mutated inside the callback. It is easy to
+        // see that push() within the callback has no negative effects since the end
+        // of the queue is checked for on every iteration. If shift() is called
+        // repeatedly within the callback then the next iteration may return an
+        // element that has been removed. In this case the callback will be called
+        // with undefined values until we either "catch up" with elements that still
+        // exist or reach the back of the queue.
+        forEach(t) {
+          let r = this._cursor, o = this._front, s = o._elements;
+          for (; (r !== s.length || o._next !== void 0) && !(r === s.length && (o = o._next, s = o._elements, r = 0, s.length === 0)); )
+            t(s[r]), ++r;
+        }
+        // Return the element that would be returned if shift() was called now,
+        // without modifying the queue.
+        peek() {
+          const t = this._front, r = this._cursor;
+          return t._elements[r];
+        }
+      }
+      const _t = Symbol("[[AbortSteps]]"), en = Symbol("[[ErrorSteps]]"), ir = Symbol("[[CancelSteps]]"), sr = Symbol("[[PullSteps]]"), lr = Symbol("[[ReleaseSteps]]");
+      function tn(e, t) {
+        e._ownerReadableStream = t, t._reader = e, t._state === "readable" ? fr(e) : t._state === "closed" ? zo(e) : rn(e, t._storedError);
+      }
+      function ur(e, t) {
+        const r = e._ownerReadableStream;
+        return ee(r, t);
+      }
+      function le(e) {
+        const t = e._ownerReadableStream;
+        t._state === "readable" ? dr(e, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")) : Fo(e, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")), t._readableStreamController[lr](), t._reader = void 0, e._ownerReadableStream = void 0;
+      }
+      function St(e) {
+        return new TypeError("Cannot " + e + " a stream using a released reader");
+      }
+      function fr(e) {
+        e._closedPromise = E((t, r) => {
+          e._closedPromise_resolve = t, e._closedPromise_reject = r;
+        });
+      }
+      function rn(e, t) {
+        fr(e), dr(e, t);
+      }
+      function zo(e) {
+        fr(e), nn(e);
+      }
+      function dr(e, t) {
+        e._closedPromise_reject !== void 0 && (L(e._closedPromise), e._closedPromise_reject(t), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0);
+      }
+      function Fo(e, t) {
+        rn(e, t);
+      }
+      function nn(e) {
+        e._closedPromise_resolve !== void 0 && (e._closedPromise_resolve(void 0), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0);
+      }
+      const on = Number.isFinite || function(e) {
+        return typeof e == "number" && isFinite(e);
+      }, Io = Math.trunc || function(e) {
+        return e < 0 ? Math.ceil(e) : Math.floor(e);
+      };
+      function jo(e) {
+        return typeof e == "object" || typeof e == "function";
+      }
+      function ne(e, t) {
+        if (e !== void 0 && !jo(e))
+          throw new TypeError(`${t} is not an object.`);
+      }
+      function G(e, t) {
+        if (typeof e != "function")
+          throw new TypeError(`${t} is not a function.`);
+      }
+      function Lo(e) {
+        return typeof e == "object" && e !== null || typeof e == "function";
+      }
+      function an(e, t) {
+        if (!Lo(e))
+          throw new TypeError(`${t} is not an object.`);
+      }
+      function ue(e, t, r) {
+        if (e === void 0)
+          throw new TypeError(`Parameter ${t} is required in '${r}'.`);
+      }
+      function cr(e, t, r) {
+        if (e === void 0)
+          throw new TypeError(`${t} is required in '${r}'.`);
+      }
+      function hr(e) {
+        return Number(e);
+      }
+      function sn(e) {
+        return e === 0 ? 0 : e;
+      }
+      function Do(e) {
+        return sn(Io(e));
+      }
+      function mr(e, t) {
+        const o = Number.MAX_SAFE_INTEGER;
+        let s = Number(e);
+        if (s = sn(s), !on(s))
+          throw new TypeError(`${t} is not a finite number`);
+        if (s = Do(s), s < 0 || s > o)
+          throw new TypeError(`${t} is outside the accepted range of 0 to ${o}, inclusive`);
+        return !on(s) || s === 0 ? 0 : s;
+      }
+      function br(e, t) {
+        if (!Te(e))
+          throw new TypeError(`${t} is not a ReadableStream.`);
+      }
+      function Le(e) {
+        return new ge(e);
+      }
+      function ln(e, t) {
+        e._reader._readRequests.push(t);
+      }
+      function pr(e, t, r) {
+        const s = e._reader._readRequests.shift();
+        r ? s._closeSteps() : s._chunkSteps(t);
+      }
+      function wt(e) {
+        return e._reader._readRequests.length;
+      }
+      function un(e) {
+        const t = e._reader;
+        return !(t === void 0 || !_e(t));
+      }
+      class ge {
+        constructor(t) {
+          if (ue(t, 1, "ReadableStreamDefaultReader"), br(t, "First parameter"), Pe(t))
+            throw new TypeError("This stream has already been locked for exclusive reading by another reader");
+          tn(this, t), this._readRequests = new U();
+        }
+        /**
+         * Returns a promise that will be fulfilled when the stream becomes closed,
+         * or rejected if the stream ever errors or the reader's lock is released before the stream finishes closing.
+         */
+        get closed() {
+          return _e(this) ? this._closedPromise : m(Rt("closed"));
+        }
+        /**
+         * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.
+         */
+        cancel(t = void 0) {
+          return _e(this) ? this._ownerReadableStream === void 0 ? m(St("cancel")) : ur(this, t) : m(Rt("cancel"));
+        }
+        /**
+         * Returns a promise that allows access to the next chunk from the stream's internal queue, if available.
+         *
+         * If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.
+         */
+        read() {
+          if (!_e(this))
+            return m(Rt("read"));
+          if (this._ownerReadableStream === void 0)
+            return m(St("read from"));
+          let t, r;
+          const o = E((f, d) => {
+            t = f, r = d;
+          });
+          return tt(this, {
+            _chunkSteps: (f) => t({ value: f, done: !1 }),
+            _closeSteps: () => t({ value: void 0, done: !0 }),
+            _errorSteps: (f) => r(f)
+          }), o;
+        }
+        /**
+         * Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.
+         * If the associated stream is errored when the lock is released, the reader will appear errored in the same way
+         * from now on; otherwise, the reader will appear closed.
+         *
+         * A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by
+         * the reader's {@link ReadableStreamDefaultReader.read | read()} method has not yet been settled. Attempting to
+         * do so will throw a `TypeError` and leave the reader locked to the stream.
+         */
+        releaseLock() {
+          if (!_e(this))
+            throw Rt("releaseLock");
+          this._ownerReadableStream !== void 0 && $o(this);
+        }
+      }
+      Object.defineProperties(ge.prototype, {
+        cancel: { enumerable: !0 },
+        read: { enumerable: !0 },
+        releaseLock: { enumerable: !0 },
+        closed: { enumerable: !0 }
+      }), c(ge.prototype.cancel, "cancel"), c(ge.prototype.read, "read"), c(ge.prototype.releaseLock, "releaseLock"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(ge.prototype, Symbol.toStringTag, {
+        value: "ReadableStreamDefaultReader",
+        configurable: !0
+      });
+      function _e(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_readRequests") ? !1 : e instanceof ge;
+      }
+      function tt(e, t) {
+        const r = e._ownerReadableStream;
+        r._disturbed = !0, r._state === "closed" ? t._closeSteps() : r._state === "errored" ? t._errorSteps(r._storedError) : r._readableStreamController[sr](t);
+      }
+      function $o(e) {
+        le(e);
+        const t = new TypeError("Reader was released");
+        fn(e, t);
+      }
+      function fn(e, t) {
+        const r = e._readRequests;
+        e._readRequests = new U(), r.forEach((o) => {
+          o._errorSteps(t);
+        });
+      }
+      function Rt(e) {
+        return new TypeError(`ReadableStreamDefaultReader.prototype.${e} can only be used on a ReadableStreamDefaultReader`);
+      }
+      const Mo = Object.getPrototypeOf(Object.getPrototypeOf(async function* () {
+      }).prototype);
+      class dn {
+        constructor(t, r) {
+          this._ongoingPromise = void 0, this._isFinished = !1, this._reader = t, this._preventCancel = r;
+        }
+        next() {
+          const t = () => this._nextSteps();
+          return this._ongoingPromise = this._ongoingPromise ? B(this._ongoingPromise, t, t) : t(), this._ongoingPromise;
+        }
+        return(t) {
+          const r = () => this._returnSteps(t);
+          return this._ongoingPromise ? B(this._ongoingPromise, r, r) : r();
+        }
+        _nextSteps() {
+          if (this._isFinished)
+            return Promise.resolve({ value: void 0, done: !0 });
+          const t = this._reader;
+          let r, o;
+          const s = E((d, b) => {
+            r = d, o = b;
+          });
+          return tt(t, {
+            _chunkSteps: (d) => {
+              this._ongoingPromise = void 0, Y(() => r({ value: d, done: !1 }));
+            },
+            _closeSteps: () => {
+              this._ongoingPromise = void 0, this._isFinished = !0, le(t), r({ value: void 0, done: !0 });
+            },
+            _errorSteps: (d) => {
+              this._ongoingPromise = void 0, this._isFinished = !0, le(t), o(d);
+            }
+          }), s;
+        }
+        _returnSteps(t) {
+          if (this._isFinished)
+            return Promise.resolve({ value: t, done: !0 });
+          this._isFinished = !0;
+          const r = this._reader;
+          if (!this._preventCancel) {
+            const o = ur(r, t);
+            return le(r), B(o, () => ({ value: t, done: !0 }));
+          }
+          return le(r), w({ value: t, done: !0 });
+        }
+      }
+      const cn = {
+        next() {
+          return hn(this) ? this._asyncIteratorImpl.next() : m(mn("next"));
+        },
+        return(e) {
+          return hn(this) ? this._asyncIteratorImpl.return(e) : m(mn("return"));
+        }
+      };
+      Object.setPrototypeOf(cn, Mo);
+      function Uo(e, t) {
+        const r = Le(e), o = new dn(r, t), s = Object.create(cn);
+        return s._asyncIteratorImpl = o, s;
+      }
+      function hn(e) {
+        if (!l(e) || !Object.prototype.hasOwnProperty.call(e, "_asyncIteratorImpl"))
+          return !1;
+        try {
+          return e._asyncIteratorImpl instanceof dn;
+        } catch {
+          return !1;
+        }
+      }
+      function mn(e) {
+        return new TypeError(`ReadableStreamAsyncIterator.${e} can only be used on a ReadableSteamAsyncIterator`);
+      }
+      const bn = Number.isNaN || function(e) {
+        return e !== e;
+      };
+      var yr, gr, _r;
+      function rt(e) {
+        return e.slice();
+      }
+      function pn(e, t, r, o, s) {
+        new Uint8Array(e).set(new Uint8Array(r, o, s), t);
+      }
+      let fe = (e) => (typeof e.transfer == "function" ? fe = (t) => t.transfer() : typeof structuredClone == "function" ? fe = (t) => structuredClone(t, { transfer: [t] }) : fe = (t) => t, fe(e)), Se = (e) => (typeof e.detached == "boolean" ? Se = (t) => t.detached : Se = (t) => t.byteLength === 0, Se(e));
+      function yn(e, t, r) {
+        if (e.slice)
+          return e.slice(t, r);
+        const o = r - t, s = new ArrayBuffer(o);
+        return pn(s, 0, e, t, o), s;
+      }
+      function Ct(e, t) {
+        const r = e[t];
+        if (r != null) {
+          if (typeof r != "function")
+            throw new TypeError(`${String(t)} is not a function`);
+          return r;
+        }
+      }
+      function xo(e) {
+        const t = {
+          [Symbol.iterator]: () => e.iterator
+        }, r = async function* () {
+          return yield* t;
+        }(), o = r.next;
+        return { iterator: r, nextMethod: o, done: !1 };
+      }
+      const Sr = (_r = (yr = Symbol.asyncIterator) !== null && yr !== void 0 ? yr : (gr = Symbol.for) === null || gr === void 0 ? void 0 : gr.call(Symbol, "Symbol.asyncIterator")) !== null && _r !== void 0 ? _r : "@@asyncIterator";
+      function gn(e, t = "sync", r) {
+        if (r === void 0)
+          if (t === "async") {
+            if (r = Ct(e, Sr), r === void 0) {
+              const f = Ct(e, Symbol.iterator), d = gn(e, "sync", f);
+              return xo(d);
+            }
+          } else
+            r = Ct(e, Symbol.iterator);
+        if (r === void 0)
+          throw new TypeError("The object is not iterable");
+        const o = O(r, e, []);
+        if (!l(o))
+          throw new TypeError("The iterator method must return an object");
+        const s = o.next;
+        return { iterator: o, nextMethod: s, done: !1 };
+      }
+      function No(e) {
+        const t = O(e.nextMethod, e.iterator, []);
+        if (!l(t))
+          throw new TypeError("The iterator.next() method must return an object");
+        return t;
+      }
+      function Ho(e) {
+        return !!e.done;
+      }
+      function Qo(e) {
+        return e.value;
+      }
+      function Vo(e) {
+        return !(typeof e != "number" || bn(e) || e < 0);
+      }
+      function _n(e) {
+        const t = yn(e.buffer, e.byteOffset, e.byteOffset + e.byteLength);
+        return new Uint8Array(t);
+      }
+      function wr(e) {
+        const t = e._queue.shift();
+        return e._queueTotalSize -= t.size, e._queueTotalSize < 0 && (e._queueTotalSize = 0), t.value;
+      }
+      function Rr(e, t, r) {
+        if (!Vo(r) || r === 1 / 0)
+          throw new RangeError("Size must be a finite, non-NaN, non-negative number.");
+        e._queue.push({ value: t, size: r }), e._queueTotalSize += r;
+      }
+      function Yo(e) {
+        return e._queue.peek().value;
+      }
+      function we(e) {
+        e._queue = new U(), e._queueTotalSize = 0;
+      }
+      function Sn(e) {
+        return e === DataView;
+      }
+      function Go(e) {
+        return Sn(e.constructor);
+      }
+      function Jo(e) {
+        return Sn(e) ? 1 : e.BYTES_PER_ELEMENT;
+      }
+      class Be {
+        constructor() {
+          throw new TypeError("Illegal constructor");
+        }
+        /**
+         * Returns the view for writing in to, or `null` if the BYOB request has already been responded to.
+         */
+        get view() {
+          if (!Cr(this))
+            throw Ar("view");
+          return this._view;
+        }
+        respond(t) {
+          if (!Cr(this))
+            throw Ar("respond");
+          if (ue(t, 1, "respond"), t = mr(t, "First parameter"), this._associatedReadableByteStreamController === void 0)
+            throw new TypeError("This BYOB request has been invalidated");
+          if (Se(this._view.buffer))
+            throw new TypeError("The BYOB request's buffer has been detached and so cannot be used as a response");
+          Et(this._associatedReadableByteStreamController, t);
+        }
+        respondWithNewView(t) {
+          if (!Cr(this))
+            throw Ar("respondWithNewView");
+          if (ue(t, 1, "respondWithNewView"), !ArrayBuffer.isView(t))
+            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 (Se(t.buffer))
+            throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");
+          At(this._associatedReadableByteStreamController, t);
+        }
+      }
+      Object.defineProperties(Be.prototype, {
+        respond: { enumerable: !0 },
+        respondWithNewView: { enumerable: !0 },
+        view: { enumerable: !0 }
+      }), c(Be.prototype.respond, "respond"), c(Be.prototype.respondWithNewView, "respondWithNewView"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(Be.prototype, Symbol.toStringTag, {
+        value: "ReadableStreamBYOBRequest",
+        configurable: !0
+      });
+      class de {
+        constructor() {
+          throw new TypeError("Illegal constructor");
+        }
+        /**
+         * Returns the current BYOB pull request, or `null` if there isn't one.
+         */
+        get byobRequest() {
+          if (!We(this))
+            throw ot("byobRequest");
+          return Er(this);
+        }
+        /**
+         * Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is
+         * over-full. An underlying byte source ought to use this information to determine when and how to apply backpressure.
+         */
+        get desiredSize() {
+          if (!We(this))
+            throw ot("desiredSize");
+          return Wn(this);
+        }
+        /**
+         * Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from
+         * the stream, but once those are read, the stream will become closed.
+         */
+        close() {
+          if (!We(this))
+            throw ot("close");
+          if (this._closeRequested)
+            throw new TypeError("The stream has already been closed; do not close it again!");
+          const t = this._controlledReadableByteStream._state;
+          if (t !== "readable")
+            throw new TypeError(`The stream (in ${t} state) is not in the readable state and cannot be closed`);
+          nt(this);
+        }
+        enqueue(t) {
+          if (!We(this))
+            throw ot("enqueue");
+          if (ue(t, 1, "enqueue"), !ArrayBuffer.isView(t))
+            throw new TypeError("chunk must be an array buffer view");
+          if (t.byteLength === 0)
+            throw new TypeError("chunk must have non-zero byteLength");
+          if (t.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`);
+          vt(this, t);
+        }
+        /**
+         * Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.
+         */
+        error(t = void 0) {
+          if (!We(this))
+            throw ot("error");
+          J(this, t);
+        }
+        /** @internal */
+        [ir](t) {
+          wn(this), we(this);
+          const r = this._cancelAlgorithm(t);
+          return Pt(this), r;
+        }
+        /** @internal */
+        [sr](t) {
+          const r = this._controlledReadableByteStream;
+          if (this._queueTotalSize > 0) {
+            Bn(this, t);
+            return;
+          }
+          const o = this._autoAllocateChunkSize;
+          if (o !== void 0) {
+            let s;
+            try {
+              s = new ArrayBuffer(o);
+            } catch (d) {
+              t._errorSteps(d);
+              return;
+            }
+            const f = {
+              buffer: s,
+              bufferByteLength: o,
+              byteOffset: 0,
+              byteLength: o,
+              bytesFilled: 0,
+              minimumFill: 1,
+              elementSize: 1,
+              viewConstructor: Uint8Array,
+              readerType: "default"
+            };
+            this._pendingPullIntos.push(f);
+          }
+          ln(r, t), ke(this);
+        }
+        /** @internal */
+        [lr]() {
+          if (this._pendingPullIntos.length > 0) {
+            const t = this._pendingPullIntos.peek();
+            t.readerType = "none", this._pendingPullIntos = new U(), this._pendingPullIntos.push(t);
+          }
+        }
+      }
+      Object.defineProperties(de.prototype, {
+        close: { enumerable: !0 },
+        enqueue: { enumerable: !0 },
+        error: { enumerable: !0 },
+        byobRequest: { enumerable: !0 },
+        desiredSize: { enumerable: !0 }
+      }), c(de.prototype.close, "close"), c(de.prototype.enqueue, "enqueue"), c(de.prototype.error, "error"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(de.prototype, Symbol.toStringTag, {
+        value: "ReadableByteStreamController",
+        configurable: !0
+      });
+      function We(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_controlledReadableByteStream") ? !1 : e instanceof de;
+      }
+      function Cr(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_associatedReadableByteStreamController") ? !1 : e instanceof Be;
+      }
+      function ke(e) {
+        if (!ta(e))
+          return;
+        if (e._pulling) {
+          e._pullAgain = !0;
+          return;
+        }
+        e._pulling = !0;
+        const r = e._pullAlgorithm();
+        p(r, () => (e._pulling = !1, e._pullAgain && (e._pullAgain = !1, ke(e)), null), (o) => (J(e, o), null));
+      }
+      function wn(e) {
+        Pr(e), e._pendingPullIntos = new U();
+      }
+      function Tr(e, t) {
+        let r = !1;
+        e._state === "closed" && (r = !0);
+        const o = Rn(t);
+        t.readerType === "default" ? pr(e, o, r) : sa(e, o, r);
+      }
+      function Rn(e) {
+        const t = e.bytesFilled, r = e.elementSize;
+        return new e.viewConstructor(e.buffer, e.byteOffset, t / r);
+      }
+      function Tt(e, t, r, o) {
+        e._queue.push({ buffer: t, byteOffset: r, byteLength: o }), e._queueTotalSize += o;
+      }
+      function Cn(e, t, r, o) {
+        let s;
+        try {
+          s = yn(t, r, r + o);
+        } catch (f) {
+          throw J(e, f), f;
+        }
+        Tt(e, s, 0, o);
+      }
+      function Tn(e, t) {
+        t.bytesFilled > 0 && Cn(e, t.buffer, t.byteOffset, t.bytesFilled), De(e);
+      }
+      function Pn(e, t) {
+        const r = Math.min(e._queueTotalSize, t.byteLength - t.bytesFilled), o = t.bytesFilled + r;
+        let s = r, f = !1;
+        const d = o % t.elementSize, b = o - d;
+        b >= t.minimumFill && (s = b - t.bytesFilled, f = !0);
+        const S = e._queue;
+        for (; s > 0; ) {
+          const y = S.peek(), C = Math.min(s, y.byteLength), P = t.byteOffset + t.bytesFilled;
+          pn(t.buffer, P, y.buffer, y.byteOffset, C), y.byteLength === C ? S.shift() : (y.byteOffset += C, y.byteLength -= C), e._queueTotalSize -= C, vn(e, C, t), s -= C;
+        }
+        return f;
+      }
+      function vn(e, t, r) {
+        r.bytesFilled += t;
+      }
+      function En(e) {
+        e._queueTotalSize === 0 && e._closeRequested ? (Pt(e), ft(e._controlledReadableByteStream)) : ke(e);
+      }
+      function Pr(e) {
+        e._byobRequest !== null && (e._byobRequest._associatedReadableByteStreamController = void 0, e._byobRequest._view = null, e._byobRequest = null);
+      }
+      function vr(e) {
+        for (; e._pendingPullIntos.length > 0; ) {
+          if (e._queueTotalSize === 0)
+            return;
+          const t = e._pendingPullIntos.peek();
+          Pn(e, t) && (De(e), Tr(e._controlledReadableByteStream, t));
+        }
+      }
+      function Zo(e) {
+        const t = e._controlledReadableByteStream._reader;
+        for (; t._readRequests.length > 0; ) {
+          if (e._queueTotalSize === 0)
+            return;
+          const r = t._readRequests.shift();
+          Bn(e, r);
+        }
+      }
+      function Ko(e, t, r, o) {
+        const s = e._controlledReadableByteStream, f = t.constructor, d = Jo(f), { byteOffset: b, byteLength: S } = t, y = r * d;
+        let C;
+        try {
+          C = fe(t.buffer);
+        } catch (k) {
+          o._errorSteps(k);
+          return;
+        }
+        const P = {
+          buffer: C,
+          bufferByteLength: C.byteLength,
+          byteOffset: b,
+          byteLength: S,
+          bytesFilled: 0,
+          minimumFill: y,
+          elementSize: d,
+          viewConstructor: f,
+          readerType: "byob"
+        };
+        if (e._pendingPullIntos.length > 0) {
+          e._pendingPullIntos.push(P), On(s, o);
+          return;
+        }
+        if (s._state === "closed") {
+          const k = new f(P.buffer, P.byteOffset, 0);
+          o._closeSteps(k);
+          return;
+        }
+        if (e._queueTotalSize > 0) {
+          if (Pn(e, P)) {
+            const k = Rn(P);
+            En(e), o._chunkSteps(k);
+            return;
+          }
+          if (e._closeRequested) {
+            const k = new TypeError("Insufficient bytes to fill elements in the given buffer");
+            J(e, k), o._errorSteps(k);
+            return;
+          }
+        }
+        e._pendingPullIntos.push(P), On(s, o), ke(e);
+      }
+      function Xo(e, t) {
+        t.readerType === "none" && De(e);
+        const r = e._controlledReadableByteStream;
+        if (Br(r))
+          for (; zn(r) > 0; ) {
+            const o = De(e);
+            Tr(r, o);
+          }
+      }
+      function ea(e, t, r) {
+        if (vn(e, t, r), r.readerType === "none") {
+          Tn(e, r), vr(e);
+          return;
+        }
+        if (r.bytesFilled < r.minimumFill)
+          return;
+        De(e);
+        const o = r.bytesFilled % r.elementSize;
+        if (o > 0) {
+          const s = r.byteOffset + r.bytesFilled;
+          Cn(e, r.buffer, s - o, o);
+        }
+        r.bytesFilled -= o, Tr(e._controlledReadableByteStream, r), vr(e);
+      }
+      function An(e, t) {
+        const r = e._pendingPullIntos.peek();
+        Pr(e), e._controlledReadableByteStream._state === "closed" ? Xo(e, r) : ea(e, t, r), ke(e);
+      }
+      function De(e) {
+        return e._pendingPullIntos.shift();
+      }
+      function ta(e) {
+        const t = e._controlledReadableByteStream;
+        return t._state !== "readable" || e._closeRequested || !e._started ? !1 : !!(un(t) && wt(t) > 0 || Br(t) && zn(t) > 0 || Wn(e) > 0);
+      }
+      function Pt(e) {
+        e._pullAlgorithm = void 0, e._cancelAlgorithm = void 0;
+      }
+      function nt(e) {
+        const t = e._controlledReadableByteStream;
+        if (!(e._closeRequested || t._state !== "readable")) {
+          if (e._queueTotalSize > 0) {
+            e._closeRequested = !0;
+            return;
+          }
+          if (e._pendingPullIntos.length > 0) {
+            const r = e._pendingPullIntos.peek();
+            if (r.bytesFilled % r.elementSize !== 0) {
+              const o = new TypeError("Insufficient bytes to fill elements in the given buffer");
+              throw J(e, o), o;
+            }
+          }
+          Pt(e), ft(t);
+        }
+      }
+      function vt(e, t) {
+        const r = e._controlledReadableByteStream;
+        if (e._closeRequested || r._state !== "readable")
+          return;
+        const { buffer: o, byteOffset: s, byteLength: f } = t;
+        if (Se(o))
+          throw new TypeError("chunk's buffer is detached and so cannot be enqueued");
+        const d = fe(o);
+        if (e._pendingPullIntos.length > 0) {
+          const b = e._pendingPullIntos.peek();
+          if (Se(b.buffer))
+            throw new TypeError("The BYOB request's buffer has been detached and so cannot be filled with an enqueued chunk");
+          Pr(e), b.buffer = fe(b.buffer), b.readerType === "none" && Tn(e, b);
+        }
+        if (un(r))
+          if (Zo(e), wt(r) === 0)
+            Tt(e, d, s, f);
+          else {
+            e._pendingPullIntos.length > 0 && De(e);
+            const b = new Uint8Array(d, s, f);
+            pr(r, b, !1);
+          }
+        else
+          Br(r) ? (Tt(e, d, s, f), vr(e)) : Tt(e, d, s, f);
+        ke(e);
+      }
+      function J(e, t) {
+        const r = e._controlledReadableByteStream;
+        r._state === "readable" && (wn(e), we(e), Pt(e), oo(r, t));
+      }
+      function Bn(e, t) {
+        const r = e._queue.shift();
+        e._queueTotalSize -= r.byteLength, En(e);
+        const o = new Uint8Array(r.buffer, r.byteOffset, r.byteLength);
+        t._chunkSteps(o);
+      }
+      function Er(e) {
+        if (e._byobRequest === null && e._pendingPullIntos.length > 0) {
+          const t = e._pendingPullIntos.peek(), r = new Uint8Array(t.buffer, t.byteOffset + t.bytesFilled, t.byteLength - t.bytesFilled), o = Object.create(Be.prototype);
+          na(o, e, r), e._byobRequest = o;
+        }
+        return e._byobRequest;
+      }
+      function Wn(e) {
+        const t = e._controlledReadableByteStream._state;
+        return t === "errored" ? null : t === "closed" ? 0 : e._strategyHWM - e._queueTotalSize;
+      }
+      function Et(e, t) {
+        const r = e._pendingPullIntos.peek();
+        if (e._controlledReadableByteStream._state === "closed") {
+          if (t !== 0)
+            throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream");
+        } else {
+          if (t === 0)
+            throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");
+          if (r.bytesFilled + t > r.byteLength)
+            throw new RangeError("bytesWritten out of range");
+        }
+        r.buffer = fe(r.buffer), An(e, t);
+      }
+      function At(e, t) {
+        const r = e._pendingPullIntos.peek();
+        if (e._controlledReadableByteStream._state === "closed") {
+          if (t.byteLength !== 0)
+            throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream");
+        } else if (t.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 !== t.byteOffset)
+          throw new RangeError("The region specified by view does not match byobRequest");
+        if (r.bufferByteLength !== t.buffer.byteLength)
+          throw new RangeError("The buffer of view has different capacity than byobRequest");
+        if (r.bytesFilled + t.byteLength > r.byteLength)
+          throw new RangeError("The region specified by view is larger than byobRequest");
+        const s = t.byteLength;
+        r.buffer = fe(t.buffer), An(e, s);
+      }
+      function kn(e, t, r, o, s, f, d) {
+        t._controlledReadableByteStream = e, t._pullAgain = !1, t._pulling = !1, t._byobRequest = null, t._queue = t._queueTotalSize = void 0, we(t), t._closeRequested = !1, t._started = !1, t._strategyHWM = f, t._pullAlgorithm = o, t._cancelAlgorithm = s, t._autoAllocateChunkSize = d, t._pendingPullIntos = new U(), e._readableStreamController = t;
+        const b = r();
+        p(w(b), () => (t._started = !0, ke(t), null), (S) => (J(t, S), null));
+      }
+      function ra(e, t, r) {
+        const o = Object.create(de.prototype);
+        let s, f, d;
+        t.start !== void 0 ? s = () => t.start(o) : s = () => {
+        }, t.pull !== void 0 ? f = () => t.pull(o) : f = () => w(void 0), t.cancel !== void 0 ? d = (S) => t.cancel(S) : d = () => w(void 0);
+        const b = t.autoAllocateChunkSize;
+        if (b === 0)
+          throw new TypeError("autoAllocateChunkSize must be greater than 0");
+        kn(e, o, s, f, d, r, b);
+      }
+      function na(e, t, r) {
+        e._associatedReadableByteStreamController = t, e._view = r;
+      }
+      function Ar(e) {
+        return new TypeError(`ReadableStreamBYOBRequest.prototype.${e} can only be used on a ReadableStreamBYOBRequest`);
+      }
+      function ot(e) {
+        return new TypeError(`ReadableByteStreamController.prototype.${e} can only be used on a ReadableByteStreamController`);
+      }
+      function oa(e, t) {
+        ne(e, t);
+        const r = e == null ? void 0 : e.mode;
+        return {
+          mode: r === void 0 ? void 0 : aa(r, `${t} has member 'mode' that`)
+        };
+      }
+      function aa(e, t) {
+        if (e = `${e}`, e !== "byob")
+          throw new TypeError(`${t} '${e}' is not a valid enumeration value for ReadableStreamReaderMode`);
+        return e;
+      }
+      function ia(e, t) {
+        var r;
+        ne(e, t);
+        const o = (r = e == null ? void 0 : e.min) !== null && r !== void 0 ? r : 1;
+        return {
+          min: mr(o, `${t} has member 'min' that`)
+        };
+      }
+      function qn(e) {
+        return new Re(e);
+      }
+      function On(e, t) {
+        e._reader._readIntoRequests.push(t);
+      }
+      function sa(e, t, r) {
+        const s = e._reader._readIntoRequests.shift();
+        r ? s._closeSteps(t) : s._chunkSteps(t);
+      }
+      function zn(e) {
+        return e._reader._readIntoRequests.length;
+      }
+      function Br(e) {
+        const t = e._reader;
+        return !(t === void 0 || !qe(t));
+      }
+      class Re {
+        constructor(t) {
+          if (ue(t, 1, "ReadableStreamBYOBReader"), br(t, "First parameter"), Pe(t))
+            throw new TypeError("This stream has already been locked for exclusive reading by another reader");
+          if (!We(t._readableStreamController))
+            throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");
+          tn(this, t), this._readIntoRequests = new U();
+        }
+        /**
+         * Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or
+         * the reader's lock is released before the stream finishes closing.
+         */
+        get closed() {
+          return qe(this) ? this._closedPromise : m(Bt("closed"));
+        }
+        /**
+         * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.
+         */
+        cancel(t = void 0) {
+          return qe(this) ? this._ownerReadableStream === void 0 ? m(St("cancel")) : ur(this, t) : m(Bt("cancel"));
+        }
+        read(t, r = {}) {
+          if (!qe(this))
+            return m(Bt("read"));
+          if (!ArrayBuffer.isView(t))
+            return m(new TypeError("view must be an array buffer view"));
+          if (t.byteLength === 0)
+            return m(new TypeError("view must have non-zero byteLength"));
+          if (t.buffer.byteLength === 0)
+            return m(new TypeError("view's buffer must have non-zero byteLength"));
+          if (Se(t.buffer))
+            return m(new TypeError("view's buffer has been detached"));
+          let o;
+          try {
+            o = ia(r, "options");
+          } catch (y) {
+            return m(y);
+          }
+          const s = o.min;
+          if (s === 0)
+            return m(new TypeError("options.min must be greater than 0"));
+          if (Go(t)) {
+            if (s > t.byteLength)
+              return m(new RangeError("options.min must be less than or equal to view's byteLength"));
+          } else if (s > t.length)
+            return m(new RangeError("options.min must be less than or equal to view's length"));
+          if (this._ownerReadableStream === void 0)
+            return m(St("read from"));
+          let f, d;
+          const b = E((y, C) => {
+            f = y, d = C;
+          });
+          return Fn(this, t, s, {
+            _chunkSteps: (y) => f({ value: y, done: !1 }),
+            _closeSteps: (y) => f({ value: y, done: !0 }),
+            _errorSteps: (y) => d(y)
+          }), b;
+        }
+        /**
+         * Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.
+         * If the associated stream is errored when the lock is released, the reader will appear errored in the same way
+         * from now on; otherwise, the reader will appear closed.
+         *
+         * A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by
+         * the reader's {@link ReadableStreamBYOBReader.read | read()} method has not yet been settled. Attempting to
+         * do so will throw a `TypeError` and leave the reader locked to the stream.
+         */
+        releaseLock() {
+          if (!qe(this))
+            throw Bt("releaseLock");
+          this._ownerReadableStream !== void 0 && la(this);
+        }
+      }
+      Object.defineProperties(Re.prototype, {
+        cancel: { enumerable: !0 },
+        read: { enumerable: !0 },
+        releaseLock: { enumerable: !0 },
+        closed: { enumerable: !0 }
+      }), c(Re.prototype.cancel, "cancel"), c(Re.prototype.read, "read"), c(Re.prototype.releaseLock, "releaseLock"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(Re.prototype, Symbol.toStringTag, {
+        value: "ReadableStreamBYOBReader",
+        configurable: !0
+      });
+      function qe(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_readIntoRequests") ? !1 : e instanceof Re;
+      }
+      function Fn(e, t, r, o) {
+        const s = e._ownerReadableStream;
+        s._disturbed = !0, s._state === "errored" ? o._errorSteps(s._storedError) : Ko(s._readableStreamController, t, r, o);
+      }
+      function la(e) {
+        le(e);
+        const t = new TypeError("Reader was released");
+        In(e, t);
+      }
+      function In(e, t) {
+        const r = e._readIntoRequests;
+        e._readIntoRequests = new U(), r.forEach((o) => {
+          o._errorSteps(t);
+        });
+      }
+      function Bt(e) {
+        return new TypeError(`ReadableStreamBYOBReader.prototype.${e} can only be used on a ReadableStreamBYOBReader`);
+      }
+      function at(e, t) {
+        const { highWaterMark: r } = e;
+        if (r === void 0)
+          return t;
+        if (bn(r) || r < 0)
+          throw new RangeError("Invalid highWaterMark");
+        return r;
+      }
+      function Wt(e) {
+        const { size: t } = e;
+        return t || (() => 1);
+      }
+      function kt(e, t) {
+        ne(e, t);
+        const r = e == null ? void 0 : e.highWaterMark, o = e == null ? void 0 : e.size;
+        return {
+          highWaterMark: r === void 0 ? void 0 : hr(r),
+          size: o === void 0 ? void 0 : ua(o, `${t} has member 'size' that`)
+        };
+      }
+      function ua(e, t) {
+        return G(e, t), (r) => hr(e(r));
+      }
+      function fa(e, t) {
+        ne(e, t);
+        const r = e == null ? void 0 : e.abort, o = e == null ? void 0 : e.close, s = e == null ? void 0 : e.start, f = e == null ? void 0 : e.type, d = e == null ? void 0 : e.write;
+        return {
+          abort: r === void 0 ? void 0 : da(r, e, `${t} has member 'abort' that`),
+          close: o === void 0 ? void 0 : ca(o, e, `${t} has member 'close' that`),
+          start: s === void 0 ? void 0 : ha(s, e, `${t} has member 'start' that`),
+          write: d === void 0 ? void 0 : ma(d, e, `${t} has member 'write' that`),
+          type: f
+        };
+      }
+      function da(e, t, r) {
+        return G(e, r), (o) => z(e, t, [o]);
+      }
+      function ca(e, t, r) {
+        return G(e, r), () => z(e, t, []);
+      }
+      function ha(e, t, r) {
+        return G(e, r), (o) => O(e, t, [o]);
+      }
+      function ma(e, t, r) {
+        return G(e, r), (o, s) => z(e, t, [o, s]);
+      }
+      function jn(e, t) {
+        if (!$e(e))
+          throw new TypeError(`${t} is not a WritableStream.`);
+      }
+      function ba(e) {
+        if (typeof e != "object" || e === null)
+          return !1;
+        try {
+          return typeof e.aborted == "boolean";
+        } catch {
+          return !1;
+        }
+      }
+      const pa = typeof AbortController == "function";
+      function ya() {
+        if (pa)
+          return new AbortController();
+      }
+      class Ce {
+        constructor(t = {}, r = {}) {
+          t === void 0 ? t = null : an(t, "First parameter");
+          const o = kt(r, "Second parameter"), s = fa(t, "First parameter");
+          if (Dn(this), s.type !== void 0)
+            throw new RangeError("Invalid type is specified");
+          const d = Wt(o), b = at(o, 1);
+          ka(this, s, b, d);
+        }
+        /**
+         * Returns whether or not the writable stream is locked to a writer.
+         */
+        get locked() {
+          if (!$e(this))
+            throw It("locked");
+          return Me(this);
+        }
+        /**
+         * Aborts the stream, signaling that the producer can no longer successfully write to the stream and it is to be
+         * immediately moved to an errored state, with any queued-up writes discarded. This will also execute any abort
+         * mechanism of the underlying sink.
+         *
+         * The returned promise will fulfill if the stream shuts down successfully, or reject if the underlying sink signaled
+         * that there was an error doing so. Additionally, it will reject with a `TypeError` (without attempting to cancel
+         * the stream) if the stream is currently locked.
+         */
+        abort(t = void 0) {
+          return $e(this) ? Me(this) ? m(new TypeError("Cannot abort a stream that already has a writer")) : qt(this, t) : m(It("abort"));
+        }
+        /**
+         * Closes the stream. The underlying sink will finish processing any previously-written chunks, before invoking its
+         * close behavior. During this time any further attempts to write will fail (without erroring the stream).
+         *
+         * The method returns a promise that will fulfill if all remaining chunks are successfully written and the stream
+         * successfully closes, or rejects if an error is encountered during this process. Additionally, it will reject with
+         * a `TypeError` (without attempting to cancel the stream) if the stream is currently locked.
+         */
+        close() {
+          return $e(this) ? Me(this) ? m(new TypeError("Cannot close a stream that already has a writer")) : oe(this) ? m(new TypeError("Cannot close an already-closing stream")) : $n(this) : m(It("close"));
+        }
+        /**
+         * Creates a {@link WritableStreamDefaultWriter | writer} and locks the stream to the new writer. While the stream
+         * is locked, no other writer can be acquired until this one is released.
+         *
+         * This functionality is especially useful for creating abstractions that desire the ability to write to a stream
+         * without interruption or interleaving. By getting a writer for the stream, you can ensure nobody else can write at
+         * the same time, which would cause the resulting written data to be unpredictable and probably useless.
+         */
+        getWriter() {
+          if (!$e(this))
+            throw It("getWriter");
+          return Ln(this);
+        }
+      }
+      Object.defineProperties(Ce.prototype, {
+        abort: { enumerable: !0 },
+        close: { enumerable: !0 },
+        getWriter: { enumerable: !0 },
+        locked: { enumerable: !0 }
+      }), c(Ce.prototype.abort, "abort"), c(Ce.prototype.close, "close"), c(Ce.prototype.getWriter, "getWriter"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(Ce.prototype, Symbol.toStringTag, {
+        value: "WritableStream",
+        configurable: !0
+      });
+      function Ln(e) {
+        return new ce(e);
+      }
+      function ga(e, t, r, o, s = 1, f = () => 1) {
+        const d = Object.create(Ce.prototype);
+        Dn(d);
+        const b = Object.create(Ue.prototype);
+        return Qn(d, b, e, t, r, o, s, f), d;
+      }
+      function Dn(e) {
+        e._state = "writable", e._storedError = void 0, e._writer = void 0, e._writableStreamController = void 0, e._writeRequests = new U(), e._inFlightWriteRequest = void 0, e._closeRequest = void 0, e._inFlightCloseRequest = void 0, e._pendingAbortRequest = void 0, e._backpressure = !1;
+      }
+      function $e(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_writableStreamController") ? !1 : e instanceof Ce;
+      }
+      function Me(e) {
+        return e._writer !== void 0;
+      }
+      function qt(e, t) {
+        var r;
+        if (e._state === "closed" || e._state === "errored")
+          return w(void 0);
+        e._writableStreamController._abortReason = t, (r = e._writableStreamController._abortController) === null || r === void 0 || r.abort(t);
+        const o = e._state;
+        if (o === "closed" || o === "errored")
+          return w(void 0);
+        if (e._pendingAbortRequest !== void 0)
+          return e._pendingAbortRequest._promise;
+        let s = !1;
+        o === "erroring" && (s = !0, t = void 0);
+        const f = E((d, b) => {
+          e._pendingAbortRequest = {
+            _promise: void 0,
+            _resolve: d,
+            _reject: b,
+            _reason: t,
+            _wasAlreadyErroring: s
+          };
+        });
+        return e._pendingAbortRequest._promise = f, s || kr(e, t), f;
+      }
+      function $n(e) {
+        const t = e._state;
+        if (t === "closed" || t === "errored")
+          return m(new TypeError(`The stream (in ${t} state) is not in the writable state and cannot be closed`));
+        const r = E((s, f) => {
+          const d = {
+            _resolve: s,
+            _reject: f
+          };
+          e._closeRequest = d;
+        }), o = e._writer;
+        return o !== void 0 && e._backpressure && t === "writable" && Dr(o), qa(e._writableStreamController), r;
+      }
+      function _a(e) {
+        return E((r, o) => {
+          const s = {
+            _resolve: r,
+            _reject: o
+          };
+          e._writeRequests.push(s);
+        });
+      }
+      function Wr(e, t) {
+        if (e._state === "writable") {
+          kr(e, t);
+          return;
+        }
+        qr(e);
+      }
+      function kr(e, t) {
+        const r = e._writableStreamController;
+        e._state = "erroring", e._storedError = t;
+        const o = e._writer;
+        o !== void 0 && Un(o, t), !Ta(e) && r._started && qr(e);
+      }
+      function qr(e) {
+        e._state = "errored", e._writableStreamController[en]();
+        const t = e._storedError;
+        if (e._writeRequests.forEach((s) => {
+          s._reject(t);
+        }), e._writeRequests = new U(), e._pendingAbortRequest === void 0) {
+          Ot(e);
+          return;
+        }
+        const r = e._pendingAbortRequest;
+        if (e._pendingAbortRequest = void 0, r._wasAlreadyErroring) {
+          r._reject(t), Ot(e);
+          return;
+        }
+        const o = e._writableStreamController[_t](r._reason);
+        p(o, () => (r._resolve(), Ot(e), null), (s) => (r._reject(s), Ot(e), null));
+      }
+      function Sa(e) {
+        e._inFlightWriteRequest._resolve(void 0), e._inFlightWriteRequest = void 0;
+      }
+      function wa(e, t) {
+        e._inFlightWriteRequest._reject(t), e._inFlightWriteRequest = void 0, Wr(e, t);
+      }
+      function Ra(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 && Jn(r);
+      }
+      function Ca(e, t) {
+        e._inFlightCloseRequest._reject(t), e._inFlightCloseRequest = void 0, e._pendingAbortRequest !== void 0 && (e._pendingAbortRequest._reject(t), e._pendingAbortRequest = void 0), Wr(e, t);
+      }
+      function oe(e) {
+        return !(e._closeRequest === void 0 && e._inFlightCloseRequest === void 0);
+      }
+      function Ta(e) {
+        return !(e._inFlightWriteRequest === void 0 && e._inFlightCloseRequest === void 0);
+      }
+      function Pa(e) {
+        e._inFlightCloseRequest = e._closeRequest, e._closeRequest = void 0;
+      }
+      function va(e) {
+        e._inFlightWriteRequest = e._writeRequests.shift();
+      }
+      function Ot(e) {
+        e._closeRequest !== void 0 && (e._closeRequest._reject(e._storedError), e._closeRequest = void 0);
+        const t = e._writer;
+        t !== void 0 && jr(t, e._storedError);
+      }
+      function Or(e, t) {
+        const r = e._writer;
+        r !== void 0 && t !== e._backpressure && (t ? Da(r) : Dr(r)), e._backpressure = t;
+      }
+      class ce {
+        constructor(t) {
+          if (ue(t, 1, "WritableStreamDefaultWriter"), jn(t, "First parameter"), Me(t))
+            throw new TypeError("This stream has already been locked for exclusive writing by another writer");
+          this._ownerWritableStream = t, t._writer = this;
+          const r = t._state;
+          if (r === "writable")
+            !oe(t) && t._backpressure ? Lt(this) : Zn(this), jt(this);
+          else if (r === "erroring")
+            Lr(this, t._storedError), jt(this);
+          else if (r === "closed")
+            Zn(this), ja(this);
+          else {
+            const o = t._storedError;
+            Lr(this, o), Gn(this, o);
+          }
+        }
+        /**
+         * Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or
+         * the writer’s lock is released before the stream finishes closing.
+         */
+        get closed() {
+          return Oe(this) ? this._closedPromise : m(ze("closed"));
+        }
+        /**
+         * Returns the desired size to fill the stream’s internal queue. It can be negative, if the queue is over-full.
+         * A producer can use this information to determine the right amount of data to write.
+         *
+         * It will be `null` if the stream cannot be successfully written to (due to either being errored, or having an abort
+         * queued up). It will return zero if the stream is closed. And the getter will throw an exception if invoked when
+         * the writer’s lock is released.
+         */
+        get desiredSize() {
+          if (!Oe(this))
+            throw ze("desiredSize");
+          if (this._ownerWritableStream === void 0)
+            throw st("desiredSize");
+          return Wa(this);
+        }
+        /**
+         * Returns a promise that will be fulfilled when the desired size to fill the stream’s internal queue transitions
+         * from non-positive to positive, signaling that it is no longer applying backpressure. Once the desired size dips
+         * back to zero or below, the getter will return a new promise that stays pending until the next transition.
+         *
+         * If the stream becomes errored or aborted, or the writer’s lock is released, the returned promise will become
+         * rejected.
+         */
+        get ready() {
+          return Oe(this) ? this._readyPromise : m(ze("ready"));
+        }
+        /**
+         * If the reader is active, behaves the same as {@link WritableStream.abort | stream.abort(reason)}.
+         */
+        abort(t = void 0) {
+          return Oe(this) ? this._ownerWritableStream === void 0 ? m(st("abort")) : Ea(this, t) : m(ze("abort"));
+        }
+        /**
+         * If the reader is active, behaves the same as {@link WritableStream.close | stream.close()}.
+         */
+        close() {
+          if (!Oe(this))
+            return m(ze("close"));
+          const t = this._ownerWritableStream;
+          return t === void 0 ? m(st("close")) : oe(t) ? m(new TypeError("Cannot close an already-closing stream")) : Mn(this);
+        }
+        /**
+         * Releases the writer’s lock on the corresponding stream. After the lock is released, the writer is no longer active.
+         * If the associated stream is errored when the lock is released, the writer will appear errored in the same way from
+         * now on; otherwise, the writer will appear closed.
+         *
+         * Note that the lock can still be released even if some ongoing writes have not yet finished (i.e. even if the
+         * promises returned from previous calls to {@link WritableStreamDefaultWriter.write | write()} have not yet settled).
+         * It’s not necessary to hold the lock on the writer for the duration of the write; the lock instead simply prevents
+         * other producers from writing in an interleaved manner.
+         */
+        releaseLock() {
+          if (!Oe(this))
+            throw ze("releaseLock");
+          this._ownerWritableStream !== void 0 && xn(this);
+        }
+        write(t = void 0) {
+          return Oe(this) ? this._ownerWritableStream === void 0 ? m(st("write to")) : Nn(this, t) : m(ze("write"));
+        }
+      }
+      Object.defineProperties(ce.prototype, {
+        abort: { enumerable: !0 },
+        close: { enumerable: !0 },
+        releaseLock: { enumerable: !0 },
+        write: { enumerable: !0 },
+        closed: { enumerable: !0 },
+        desiredSize: { enumerable: !0 },
+        ready: { enumerable: !0 }
+      }), c(ce.prototype.abort, "abort"), c(ce.prototype.close, "close"), c(ce.prototype.releaseLock, "releaseLock"), c(ce.prototype.write, "write"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(ce.prototype, Symbol.toStringTag, {
+        value: "WritableStreamDefaultWriter",
+        configurable: !0
+      });
+      function Oe(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_ownerWritableStream") ? !1 : e instanceof ce;
+      }
+      function Ea(e, t) {
+        const r = e._ownerWritableStream;
+        return qt(r, t);
+      }
+      function Mn(e) {
+        const t = e._ownerWritableStream;
+        return $n(t);
+      }
+      function Aa(e) {
+        const t = e._ownerWritableStream, r = t._state;
+        return oe(t) || r === "closed" ? w(void 0) : r === "errored" ? m(t._storedError) : Mn(e);
+      }
+      function Ba(e, t) {
+        e._closedPromiseState === "pending" ? jr(e, t) : La(e, t);
+      }
+      function Un(e, t) {
+        e._readyPromiseState === "pending" ? Kn(e, t) : $a(e, t);
+      }
+      function Wa(e) {
+        const t = e._ownerWritableStream, r = t._state;
+        return r === "errored" || r === "erroring" ? null : r === "closed" ? 0 : Vn(t._writableStreamController);
+      }
+      function xn(e) {
+        const t = e._ownerWritableStream, r = new TypeError("Writer was released and can no longer be used to monitor the stream's closedness");
+        Un(e, r), Ba(e, r), t._writer = void 0, e._ownerWritableStream = void 0;
+      }
+      function Nn(e, t) {
+        const r = e._ownerWritableStream, o = r._writableStreamController, s = Oa(o, t);
+        if (r !== e._ownerWritableStream)
+          return m(st("write to"));
+        const f = r._state;
+        if (f === "errored")
+          return m(r._storedError);
+        if (oe(r) || f === "closed")
+          return m(new TypeError("The stream is closing or closed and cannot be written to"));
+        if (f === "erroring")
+          return m(r._storedError);
+        const d = _a(r);
+        return za(o, t, s), d;
+      }
+      const Hn = {};
+      class Ue {
+        constructor() {
+          throw new TypeError("Illegal constructor");
+        }
+        /**
+         * The reason which was passed to `WritableStream.abort(reason)` when the stream was aborted.
+         *
+         * @deprecated
+         *  This property has been removed from the specification, see https://github.com/whatwg/streams/pull/1177.
+         *  Use {@link WritableStreamDefaultController.signal}'s `reason` instead.
+         */
+        get abortReason() {
+          if (!zr(this))
+            throw Ir("abortReason");
+          return this._abortReason;
+        }
+        /**
+         * An `AbortSignal` that can be used to abort the pending write or close operation when the stream is aborted.
+         */
+        get signal() {
+          if (!zr(this))
+            throw Ir("signal");
+          if (this._abortController === void 0)
+            throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported");
+          return this._abortController.signal;
+        }
+        /**
+         * Closes the controlled writable stream, making all future interactions with it fail with the given error `e`.
+         *
+         * This method is rarely used, since usually it suffices to return a rejected promise from one of the underlying
+         * sink's methods. However, it can be useful for suddenly shutting down a stream in response to an event outside the
+         * normal lifecycle of interactions with the underlying sink.
+         */
+        error(t = void 0) {
+          if (!zr(this))
+            throw Ir("error");
+          this._controlledWritableStream._state === "writable" && Yn(this, t);
+        }
+        /** @internal */
+        [_t](t) {
+          const r = this._abortAlgorithm(t);
+          return zt(this), r;
+        }
+        /** @internal */
+        [en]() {
+          we(this);
+        }
+      }
+      Object.defineProperties(Ue.prototype, {
+        abortReason: { enumerable: !0 },
+        signal: { enumerable: !0 },
+        error: { enumerable: !0 }
+      }), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(Ue.prototype, Symbol.toStringTag, {
+        value: "WritableStreamDefaultController",
+        configurable: !0
+      });
+      function zr(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_controlledWritableStream") ? !1 : e instanceof Ue;
+      }
+      function Qn(e, t, r, o, s, f, d, b) {
+        t._controlledWritableStream = e, e._writableStreamController = t, t._queue = void 0, t._queueTotalSize = void 0, we(t), t._abortReason = void 0, t._abortController = ya(), t._started = !1, t._strategySizeAlgorithm = b, t._strategyHWM = d, t._writeAlgorithm = o, t._closeAlgorithm = s, t._abortAlgorithm = f;
+        const S = Fr(t);
+        Or(e, S);
+        const y = r(), C = w(y);
+        p(C, () => (t._started = !0, Ft(t), null), (P) => (t._started = !0, Wr(e, P), null));
+      }
+      function ka(e, t, r, o) {
+        const s = Object.create(Ue.prototype);
+        let f, d, b, S;
+        t.start !== void 0 ? f = () => t.start(s) : f = () => {
+        }, t.write !== void 0 ? d = (y) => t.write(y, s) : d = () => w(void 0), t.close !== void 0 ? b = () => t.close() : b = () => w(void 0), t.abort !== void 0 ? S = (y) => t.abort(y) : S = () => w(void 0), Qn(e, s, f, d, b, S, r, o);
+      }
+      function zt(e) {
+        e._writeAlgorithm = void 0, e._closeAlgorithm = void 0, e._abortAlgorithm = void 0, e._strategySizeAlgorithm = void 0;
+      }
+      function qa(e) {
+        Rr(e, Hn, 0), Ft(e);
+      }
+      function Oa(e, t) {
+        try {
+          return e._strategySizeAlgorithm(t);
+        } catch (r) {
+          return it(e, r), 1;
+        }
+      }
+      function Vn(e) {
+        return e._strategyHWM - e._queueTotalSize;
+      }
+      function za(e, t, r) {
+        try {
+          Rr(e, t, r);
+        } catch (s) {
+          it(e, s);
+          return;
+        }
+        const o = e._controlledWritableStream;
+        if (!oe(o) && o._state === "writable") {
+          const s = Fr(e);
+          Or(o, s);
+        }
+        Ft(e);
+      }
+      function Ft(e) {
+        const t = e._controlledWritableStream;
+        if (!e._started || t._inFlightWriteRequest !== void 0)
+          return;
+        if (t._state === "erroring") {
+          qr(t);
+          return;
+        }
+        if (e._queue.length === 0)
+          return;
+        const o = Yo(e);
+        o === Hn ? Fa(e) : Ia(e, o);
+      }
+      function it(e, t) {
+        e._controlledWritableStream._state === "writable" && Yn(e, t);
+      }
+      function Fa(e) {
+        const t = e._controlledWritableStream;
+        Pa(t), wr(e);
+        const r = e._closeAlgorithm();
+        zt(e), p(r, () => (Ra(t), null), (o) => (Ca(t, o), null));
+      }
+      function Ia(e, t) {
+        const r = e._controlledWritableStream;
+        va(r);
+        const o = e._writeAlgorithm(t);
+        p(o, () => {
+          Sa(r);
+          const s = r._state;
+          if (wr(e), !oe(r) && s === "writable") {
+            const f = Fr(e);
+            Or(r, f);
+          }
+          return Ft(e), null;
+        }, (s) => (r._state === "writable" && zt(e), wa(r, s), null));
+      }
+      function Fr(e) {
+        return Vn(e) <= 0;
+      }
+      function Yn(e, t) {
+        const r = e._controlledWritableStream;
+        zt(e), kr(r, t);
+      }
+      function It(e) {
+        return new TypeError(`WritableStream.prototype.${e} can only be used on a WritableStream`);
+      }
+      function Ir(e) {
+        return new TypeError(`WritableStreamDefaultController.prototype.${e} can only be used on a WritableStreamDefaultController`);
+      }
+      function ze(e) {
+        return new TypeError(`WritableStreamDefaultWriter.prototype.${e} can only be used on a WritableStreamDefaultWriter`);
+      }
+      function st(e) {
+        return new TypeError("Cannot " + e + " a stream using a released writer");
+      }
+      function jt(e) {
+        e._closedPromise = E((t, r) => {
+          e._closedPromise_resolve = t, e._closedPromise_reject = r, e._closedPromiseState = "pending";
+        });
+      }
+      function Gn(e, t) {
+        jt(e), jr(e, t);
+      }
+      function ja(e) {
+        jt(e), Jn(e);
+      }
+      function jr(e, t) {
+        e._closedPromise_reject !== void 0 && (L(e._closedPromise), e._closedPromise_reject(t), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0, e._closedPromiseState = "rejected");
+      }
+      function La(e, t) {
+        Gn(e, t);
+      }
+      function Jn(e) {
+        e._closedPromise_resolve !== void 0 && (e._closedPromise_resolve(void 0), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0, e._closedPromiseState = "resolved");
+      }
+      function Lt(e) {
+        e._readyPromise = E((t, r) => {
+          e._readyPromise_resolve = t, e._readyPromise_reject = r;
+        }), e._readyPromiseState = "pending";
+      }
+      function Lr(e, t) {
+        Lt(e), Kn(e, t);
+      }
+      function Zn(e) {
+        Lt(e), Dr(e);
+      }
+      function Kn(e, t) {
+        e._readyPromise_reject !== void 0 && (L(e._readyPromise), e._readyPromise_reject(t), e._readyPromise_resolve = void 0, e._readyPromise_reject = void 0, e._readyPromiseState = "rejected");
+      }
+      function Da(e) {
+        Lt(e);
+      }
+      function $a(e, t) {
+        Lr(e, t);
+      }
+      function Dr(e) {
+        e._readyPromise_resolve !== void 0 && (e._readyPromise_resolve(void 0), e._readyPromise_resolve = void 0, e._readyPromise_reject = void 0, e._readyPromiseState = "fulfilled");
+      }
+      function Ma() {
+        if (typeof globalThis < "u")
+          return globalThis;
+        if (typeof self < "u")
+          return self;
+        if (typeof Vr < "u")
+          return Vr;
+      }
+      const $r = Ma();
+      function Ua(e) {
+        if (!(typeof e == "function" || typeof e == "object") || e.name !== "DOMException")
+          return !1;
+        try {
+          return new e(), !0;
+        } catch {
+          return !1;
+        }
+      }
+      function xa() {
+        const e = $r == null ? void 0 : $r.DOMException;
+        return Ua(e) ? e : void 0;
+      }
+      function Na() {
+        const e = function(r, o) {
+          this.message = r || "", this.name = o || "Error", Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
+        };
+        return c(e, "DOMException"), e.prototype = Object.create(Error.prototype), Object.defineProperty(e.prototype, "constructor", { value: e, writable: !0, configurable: !0 }), e;
+      }
+      const Ha = xa() || Na();
+      function Xn(e, t, r, o, s, f) {
+        const d = Le(e), b = Ln(t);
+        e._disturbed = !0;
+        let S = !1, y = w(void 0);
+        return E((C, P) => {
+          let k;
+          if (f !== void 0) {
+            if (k = () => {
+              const g = f.reason !== void 0 ? f.reason : new Ha("Aborted", "AbortError"), A = [];
+              o || A.push(() => t._state === "writable" ? qt(t, g) : w(void 0)), s || A.push(() => e._state === "readable" ? ee(e, g) : w(void 0)), N(() => Promise.all(A.map((q) => q())), !0, g);
+            }, f.aborted) {
+              k();
+              return;
+            }
+            f.addEventListener("abort", k);
+          }
+          function te() {
+            return E((g, A) => {
+              function q(Q) {
+                Q ? g() : W(Qe(), q, A);
+              }
+              q(!1);
+            });
+          }
+          function Qe() {
+            return S ? w(!0) : W(b._readyPromise, () => E((g, A) => {
+              tt(d, {
+                _chunkSteps: (q) => {
+                  y = W(Nn(b, q), void 0, u), g(!1);
+                },
+                _closeSteps: () => g(!0),
+                _errorSteps: A
+              });
+            }));
+          }
+          if (me(e, d._closedPromise, (g) => (o ? Z(!0, g) : N(() => qt(t, g), !0, g), null)), me(t, b._closedPromise, (g) => (s ? Z(!0, g) : N(() => ee(e, g), !0, g), null)), x(e, d._closedPromise, () => (r ? Z() : N(() => Aa(b)), null)), oe(t) || t._state === "closed") {
+            const g = new TypeError("the destination writable stream closed before all data could be piped to it");
+            s ? Z(!0, g) : N(() => ee(e, g), !0, g);
+          }
+          L(te());
+          function Ee() {
+            const g = y;
+            return W(y, () => g !== y ? Ee() : void 0);
+          }
+          function me(g, A, q) {
+            g._state === "errored" ? q(g._storedError) : R(A, q);
+          }
+          function x(g, A, q) {
+            g._state === "closed" ? q() : j(A, q);
+          }
+          function N(g, A, q) {
+            if (S)
+              return;
+            S = !0, t._state === "writable" && !oe(t) ? j(Ee(), Q) : Q();
+            function Q() {
+              return p(g(), () => be(A, q), (Ve) => be(!0, Ve)), null;
+            }
+          }
+          function Z(g, A) {
+            S || (S = !0, t._state === "writable" && !oe(t) ? j(Ee(), () => be(g, A)) : be(g, A));
+          }
+          function be(g, A) {
+            return xn(b), le(d), f !== void 0 && f.removeEventListener("abort", k), g ? P(A) : C(void 0), null;
+          }
+        });
+      }
+      class he {
+        constructor() {
+          throw new TypeError("Illegal constructor");
+        }
+        /**
+         * Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is
+         * over-full. An underlying source ought to use this information to determine when and how to apply backpressure.
+         */
+        get desiredSize() {
+          if (!Dt(this))
+            throw Mt("desiredSize");
+          return Mr(this);
+        }
+        /**
+         * Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from
+         * the stream, but once those are read, the stream will become closed.
+         */
+        close() {
+          if (!Dt(this))
+            throw Mt("close");
+          if (!Ne(this))
+            throw new TypeError("The stream is not in a state that permits close");
+          Fe(this);
+        }
+        enqueue(t = void 0) {
+          if (!Dt(this))
+            throw Mt("enqueue");
+          if (!Ne(this))
+            throw new TypeError("The stream is not in a state that permits enqueue");
+          return xe(this, t);
+        }
+        /**
+         * Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.
+         */
+        error(t = void 0) {
+          if (!Dt(this))
+            throw Mt("error");
+          X(this, t);
+        }
+        /** @internal */
+        [ir](t) {
+          we(this);
+          const r = this._cancelAlgorithm(t);
+          return $t(this), r;
+        }
+        /** @internal */
+        [sr](t) {
+          const r = this._controlledReadableStream;
+          if (this._queue.length > 0) {
+            const o = wr(this);
+            this._closeRequested && this._queue.length === 0 ? ($t(this), ft(r)) : lt(this), t._chunkSteps(o);
+          } else
+            ln(r, t), lt(this);
+        }
+        /** @internal */
+        [lr]() {
+        }
+      }
+      Object.defineProperties(he.prototype, {
+        close: { enumerable: !0 },
+        enqueue: { enumerable: !0 },
+        error: { enumerable: !0 },
+        desiredSize: { enumerable: !0 }
+      }), c(he.prototype.close, "close"), c(he.prototype.enqueue, "enqueue"), c(he.prototype.error, "error"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(he.prototype, Symbol.toStringTag, {
+        value: "ReadableStreamDefaultController",
+        configurable: !0
+      });
+      function Dt(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_controlledReadableStream") ? !1 : e instanceof he;
+      }
+      function lt(e) {
+        if (!eo(e))
+          return;
+        if (e._pulling) {
+          e._pullAgain = !0;
+          return;
+        }
+        e._pulling = !0;
+        const r = e._pullAlgorithm();
+        p(r, () => (e._pulling = !1, e._pullAgain && (e._pullAgain = !1, lt(e)), null), (o) => (X(e, o), null));
+      }
+      function eo(e) {
+        const t = e._controlledReadableStream;
+        return !Ne(e) || !e._started ? !1 : !!(Pe(t) && wt(t) > 0 || Mr(e) > 0);
+      }
+      function $t(e) {
+        e._pullAlgorithm = void 0, e._cancelAlgorithm = void 0, e._strategySizeAlgorithm = void 0;
+      }
+      function Fe(e) {
+        if (!Ne(e))
+          return;
+        const t = e._controlledReadableStream;
+        e._closeRequested = !0, e._queue.length === 0 && ($t(e), ft(t));
+      }
+      function xe(e, t) {
+        if (!Ne(e))
+          return;
+        const r = e._controlledReadableStream;
+        if (Pe(r) && wt(r) > 0)
+          pr(r, t, !1);
+        else {
+          let o;
+          try {
+            o = e._strategySizeAlgorithm(t);
+          } catch (s) {
+            throw X(e, s), s;
+          }
+          try {
+            Rr(e, t, o);
+          } catch (s) {
+            throw X(e, s), s;
+          }
+        }
+        lt(e);
+      }
+      function X(e, t) {
+        const r = e._controlledReadableStream;
+        r._state === "readable" && (we(e), $t(e), oo(r, t));
+      }
+      function Mr(e) {
+        const t = e._controlledReadableStream._state;
+        return t === "errored" ? null : t === "closed" ? 0 : e._strategyHWM - e._queueTotalSize;
+      }
+      function Qa(e) {
+        return !eo(e);
+      }
+      function Ne(e) {
+        const t = e._controlledReadableStream._state;
+        return !e._closeRequested && t === "readable";
+      }
+      function to(e, t, r, o, s, f, d) {
+        t._controlledReadableStream = e, t._queue = void 0, t._queueTotalSize = void 0, we(t), t._started = !1, t._closeRequested = !1, t._pullAgain = !1, t._pulling = !1, t._strategySizeAlgorithm = d, t._strategyHWM = f, t._pullAlgorithm = o, t._cancelAlgorithm = s, e._readableStreamController = t;
+        const b = r();
+        p(w(b), () => (t._started = !0, lt(t), null), (S) => (X(t, S), null));
+      }
+      function Va(e, t, r, o) {
+        const s = Object.create(he.prototype);
+        let f, d, b;
+        t.start !== void 0 ? f = () => t.start(s) : f = () => {
+        }, t.pull !== void 0 ? d = () => t.pull(s) : d = () => w(void 0), t.cancel !== void 0 ? b = (S) => t.cancel(S) : b = () => w(void 0), to(e, s, f, d, b, r, o);
+      }
+      function Mt(e) {
+        return new TypeError(`ReadableStreamDefaultController.prototype.${e} can only be used on a ReadableStreamDefaultController`);
+      }
+      function Ya(e, t) {
+        return We(e._readableStreamController) ? Ja(e) : Ga(e);
+      }
+      function Ga(e, t) {
+        const r = Le(e);
+        let o = !1, s = !1, f = !1, d = !1, b, S, y, C, P;
+        const k = E((x) => {
+          P = x;
+        });
+        function te() {
+          return o ? (s = !0, w(void 0)) : (o = !0, tt(r, {
+            _chunkSteps: (N) => {
+              Y(() => {
+                s = !1;
+                const Z = N, be = N;
+                f || xe(y._readableStreamController, Z), d || xe(C._readableStreamController, be), o = !1, s && te();
+              });
+            },
+            _closeSteps: () => {
+              o = !1, f || Fe(y._readableStreamController), d || Fe(C._readableStreamController), (!f || !d) && P(void 0);
+            },
+            _errorSteps: () => {
+              o = !1;
+            }
+          }), w(void 0));
+        }
+        function Qe(x) {
+          if (f = !0, b = x, d) {
+            const N = rt([b, S]), Z = ee(e, N);
+            P(Z);
+          }
+          return k;
+        }
+        function Ee(x) {
+          if (d = !0, S = x, f) {
+            const N = rt([b, S]), Z = ee(e, N);
+            P(Z);
+          }
+          return k;
+        }
+        function me() {
+        }
+        return y = ut(me, te, Qe), C = ut(me, te, Ee), R(r._closedPromise, (x) => (X(y._readableStreamController, x), X(C._readableStreamController, x), (!f || !d) && P(void 0), null)), [y, C];
+      }
+      function Ja(e) {
+        let t = Le(e), r = !1, o = !1, s = !1, f = !1, d = !1, b, S, y, C, P;
+        const k = E((g) => {
+          P = g;
+        });
+        function te(g) {
+          R(g._closedPromise, (A) => (g !== t || (J(y._readableStreamController, A), J(C._readableStreamController, A), (!f || !d) && P(void 0)), null));
+        }
+        function Qe() {
+          qe(t) && (le(t), t = Le(e), te(t)), tt(t, {
+            _chunkSteps: (A) => {
+              Y(() => {
+                o = !1, s = !1;
+                const q = A;
+                let Q = A;
+                if (!f && !d)
+                  try {
+                    Q = _n(A);
+                  } catch (Ve) {
+                    J(y._readableStreamController, Ve), J(C._readableStreamController, Ve), P(ee(e, Ve));
+                    return;
+                  }
+                f || vt(y._readableStreamController, q), d || vt(C._readableStreamController, Q), r = !1, o ? me() : s && x();
+              });
+            },
+            _closeSteps: () => {
+              r = !1, f || nt(y._readableStreamController), d || nt(C._readableStreamController), y._readableStreamController._pendingPullIntos.length > 0 && Et(y._readableStreamController, 0), C._readableStreamController._pendingPullIntos.length > 0 && Et(C._readableStreamController, 0), (!f || !d) && P(void 0);
+            },
+            _errorSteps: () => {
+              r = !1;
+            }
+          });
+        }
+        function Ee(g, A) {
+          _e(t) && (le(t), t = qn(e), te(t));
+          const q = A ? C : y, Q = A ? y : C;
+          Fn(t, g, 1, {
+            _chunkSteps: (Ye) => {
+              Y(() => {
+                o = !1, s = !1;
+                const Ge = A ? d : f;
+                if (A ? f : d)
+                  Ge || At(q._readableStreamController, Ye);
+                else {
+                  let go;
+                  try {
+                    go = _n(Ye);
+                  } catch (Qr) {
+                    J(q._readableStreamController, Qr), J(Q._readableStreamController, Qr), P(ee(e, Qr));
+                    return;
+                  }
+                  Ge || At(q._readableStreamController, Ye), vt(Q._readableStreamController, go);
+                }
+                r = !1, o ? me() : s && x();
+              });
+            },
+            _closeSteps: (Ye) => {
+              r = !1;
+              const Ge = A ? d : f, Gt = A ? f : d;
+              Ge || nt(q._readableStreamController), Gt || nt(Q._readableStreamController), Ye !== void 0 && (Ge || At(q._readableStreamController, Ye), !Gt && Q._readableStreamController._pendingPullIntos.length > 0 && Et(Q._readableStreamController, 0)), (!Ge || !Gt) && P(void 0);
+            },
+            _errorSteps: () => {
+              r = !1;
+            }
+          });
+        }
+        function me() {
+          if (r)
+            return o = !0, w(void 0);
+          r = !0;
+          const g = Er(y._readableStreamController);
+          return g === null ? Qe() : Ee(g._view, !1), w(void 0);
+        }
+        function x() {
+          if (r)
+            return s = !0, w(void 0);
+          r = !0;
+          const g = Er(C._readableStreamController);
+          return g === null ? Qe() : Ee(g._view, !0), w(void 0);
+        }
+        function N(g) {
+          if (f = !0, b = g, d) {
+            const A = rt([b, S]), q = ee(e, A);
+            P(q);
+          }
+          return k;
+        }
+        function Z(g) {
+          if (d = !0, S = g, f) {
+            const A = rt([b, S]), q = ee(e, A);
+            P(q);
+          }
+          return k;
+        }
+        function be() {
+        }
+        return y = no(be, me, N), C = no(be, x, Z), te(t), [y, C];
+      }
+      function Za(e) {
+        return l(e) && typeof e.getReader < "u";
+      }
+      function Ka(e) {
+        return Za(e) ? ei(e.getReader()) : Xa(e);
+      }
+      function Xa(e) {
+        let t;
+        const r = gn(e, "async"), o = u;
+        function s() {
+          let d;
+          try {
+            d = No(r);
+          } catch (S) {
+            return m(S);
+          }
+          const b = w(d);
+          return B(b, (S) => {
+            if (!l(S))
+              throw new TypeError("The promise returned by the iterator.next() method must fulfill with an object");
+            if (Ho(S))
+              Fe(t._readableStreamController);
+            else {
+              const C = Qo(S);
+              xe(t._readableStreamController, C);
+            }
+          });
+        }
+        function f(d) {
+          const b = r.iterator;
+          let S;
+          try {
+            S = Ct(b, "return");
+          } catch (P) {
+            return m(P);
+          }
+          if (S === void 0)
+            return w(void 0);
+          let y;
+          try {
+            y = O(S, b, [d]);
+          } catch (P) {
+            return m(P);
+          }
+          const C = w(y);
+          return B(C, (P) => {
+            if (!l(P))
+              throw new TypeError("The promise returned by the iterator.return() method must fulfill with an object");
+          });
+        }
+        return t = ut(o, s, f, 0), t;
+      }
+      function ei(e) {
+        let t;
+        const r = u;
+        function o() {
+          let f;
+          try {
+            f = e.read();
+          } catch (d) {
+            return m(d);
+          }
+          return B(f, (d) => {
+            if (!l(d))
+              throw new TypeError("The promise returned by the reader.read() method must fulfill with an object");
+            if (d.done)
+              Fe(t._readableStreamController);
+            else {
+              const b = d.value;
+              xe(t._readableStreamController, b);
+            }
+          });
+        }
+        function s(f) {
+          try {
+            return w(e.cancel(f));
+          } catch (d) {
+            return m(d);
+          }
+        }
+        return t = ut(r, o, s, 0), t;
+      }
+      function ti(e, t) {
+        ne(e, t);
+        const r = e, o = r == null ? void 0 : r.autoAllocateChunkSize, s = r == null ? void 0 : r.cancel, f = r == null ? void 0 : r.pull, d = r == null ? void 0 : r.start, b = r == null ? void 0 : r.type;
+        return {
+          autoAllocateChunkSize: o === void 0 ? void 0 : mr(o, `${t} has member 'autoAllocateChunkSize' that`),
+          cancel: s === void 0 ? void 0 : ri(s, r, `${t} has member 'cancel' that`),
+          pull: f === void 0 ? void 0 : ni(f, r, `${t} has member 'pull' that`),
+          start: d === void 0 ? void 0 : oi(d, r, `${t} has member 'start' that`),
+          type: b === void 0 ? void 0 : ai(b, `${t} has member 'type' that`)
+        };
+      }
+      function ri(e, t, r) {
+        return G(e, r), (o) => z(e, t, [o]);
+      }
+      function ni(e, t, r) {
+        return G(e, r), (o) => z(e, t, [o]);
+      }
+      function oi(e, t, r) {
+        return G(e, r), (o) => O(e, t, [o]);
+      }
+      function ai(e, t) {
+        if (e = `${e}`, e !== "bytes")
+          throw new TypeError(`${t} '${e}' is not a valid enumeration value for ReadableStreamType`);
+        return e;
+      }
+      function ii(e, t) {
+        return ne(e, t), { preventCancel: !!(e == null ? void 0 : e.preventCancel) };
+      }
+      function ro(e, t) {
+        ne(e, t);
+        const r = e == null ? void 0 : e.preventAbort, o = e == null ? void 0 : e.preventCancel, s = e == null ? void 0 : e.preventClose, f = e == null ? void 0 : e.signal;
+        return f !== void 0 && si(f, `${t} has member 'signal' that`), {
+          preventAbort: !!r,
+          preventCancel: !!o,
+          preventClose: !!s,
+          signal: f
+        };
+      }
+      function si(e, t) {
+        if (!ba(e))
+          throw new TypeError(`${t} is not an AbortSignal.`);
+      }
+      function li(e, t) {
+        ne(e, t);
+        const r = e == null ? void 0 : e.readable;
+        cr(r, "readable", "ReadableWritablePair"), br(r, `${t} has member 'readable' that`);
+        const o = e == null ? void 0 : e.writable;
+        return cr(o, "writable", "ReadableWritablePair"), jn(o, `${t} has member 'writable' that`), { readable: r, writable: o };
+      }
+      class D {
+        constructor(t = {}, r = {}) {
+          t === void 0 ? t = null : an(t, "First parameter");
+          const o = kt(r, "Second parameter"), s = ti(t, "First parameter");
+          if (Ur(this), s.type === "bytes") {
+            if (o.size !== void 0)
+              throw new RangeError("The strategy for a byte stream cannot have a size function");
+            const f = at(o, 0);
+            ra(this, s, f);
+          } else {
+            const f = Wt(o), d = at(o, 1);
+            Va(this, s, d, f);
+          }
+        }
+        /**
+         * Whether or not the readable stream is locked to a {@link ReadableStreamDefaultReader | reader}.
+         */
+        get locked() {
+          if (!Te(this))
+            throw Ie("locked");
+          return Pe(this);
+        }
+        /**
+         * Cancels the stream, signaling a loss of interest in the stream by a consumer.
+         *
+         * The supplied `reason` argument will be given to the underlying source's {@link UnderlyingSource.cancel | cancel()}
+         * method, which might or might not use it.
+         */
+        cancel(t = void 0) {
+          return Te(this) ? Pe(this) ? m(new TypeError("Cannot cancel a stream that already has a reader")) : ee(this, t) : m(Ie("cancel"));
+        }
+        getReader(t = void 0) {
+          if (!Te(this))
+            throw Ie("getReader");
+          return oa(t, "First parameter").mode === void 0 ? Le(this) : qn(this);
+        }
+        pipeThrough(t, r = {}) {
+          if (!Te(this))
+            throw Ie("pipeThrough");
+          ue(t, 1, "pipeThrough");
+          const o = li(t, "First parameter"), s = ro(r, "Second parameter");
+          if (Pe(this))
+            throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");
+          if (Me(o.writable))
+            throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");
+          const f = Xn(this, o.writable, s.preventClose, s.preventAbort, s.preventCancel, s.signal);
+          return L(f), o.readable;
+        }
+        pipeTo(t, r = {}) {
+          if (!Te(this))
+            return m(Ie("pipeTo"));
+          if (t === void 0)
+            return m("Parameter 1 is required in 'pipeTo'.");
+          if (!$e(t))
+            return m(new TypeError("ReadableStream.prototype.pipeTo's first argument must be a WritableStream"));
+          let o;
+          try {
+            o = ro(r, "Second parameter");
+          } catch (s) {
+            return m(s);
+          }
+          return Pe(this) ? m(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream")) : Me(t) ? m(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream")) : Xn(this, t, o.preventClose, o.preventAbort, o.preventCancel, o.signal);
+        }
+        /**
+         * Tees this readable stream, returning a two-element array containing the two resulting branches as
+         * new {@link ReadableStream} instances.
+         *
+         * Teeing a stream will lock it, preventing any other consumer from acquiring a reader.
+         * To cancel the stream, cancel both of the resulting branches; a composite cancellation reason will then be
+         * propagated to the stream's underlying source.
+         *
+         * Note that the chunks seen in each branch will be the same object. If the chunks are not immutable,
+         * this could allow interference between the two branches.
+         */
+        tee() {
+          if (!Te(this))
+            throw Ie("tee");
+          const t = Ya(this);
+          return rt(t);
+        }
+        values(t = void 0) {
+          if (!Te(this))
+            throw Ie("values");
+          const r = ii(t, "First parameter");
+          return Uo(this, r.preventCancel);
+        }
+        [Sr](t) {
+          return this.values(t);
+        }
+        /**
+         * Creates a new ReadableStream wrapping the provided iterable or async iterable.
+         *
+         * This can be used to adapt various kinds of objects into a readable stream,
+         * such as an array, an async generator, or a Node.js readable stream.
+         */
+        static from(t) {
+          return Ka(t);
+        }
+      }
+      Object.defineProperties(D, {
+        from: { enumerable: !0 }
+      }), Object.defineProperties(D.prototype, {
+        cancel: { enumerable: !0 },
+        getReader: { enumerable: !0 },
+        pipeThrough: { enumerable: !0 },
+        pipeTo: { enumerable: !0 },
+        tee: { enumerable: !0 },
+        values: { enumerable: !0 },
+        locked: { enumerable: !0 }
+      }), c(D.from, "from"), c(D.prototype.cancel, "cancel"), c(D.prototype.getReader, "getReader"), c(D.prototype.pipeThrough, "pipeThrough"), c(D.prototype.pipeTo, "pipeTo"), c(D.prototype.tee, "tee"), c(D.prototype.values, "values"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(D.prototype, Symbol.toStringTag, {
+        value: "ReadableStream",
+        configurable: !0
+      }), Object.defineProperty(D.prototype, Sr, {
+        value: D.prototype.values,
+        writable: !0,
+        configurable: !0
+      });
+      function ut(e, t, r, o = 1, s = () => 1) {
+        const f = Object.create(D.prototype);
+        Ur(f);
+        const d = Object.create(he.prototype);
+        return to(f, d, e, t, r, o, s), f;
+      }
+      function no(e, t, r) {
+        const o = Object.create(D.prototype);
+        Ur(o);
+        const s = Object.create(de.prototype);
+        return kn(o, s, e, t, r, 0, void 0), o;
+      }
+      function Ur(e) {
+        e._state = "readable", e._reader = void 0, e._storedError = void 0, e._disturbed = !1;
+      }
+      function Te(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_readableStreamController") ? !1 : e instanceof D;
+      }
+      function Pe(e) {
+        return e._reader !== void 0;
+      }
+      function ee(e, t) {
+        if (e._disturbed = !0, e._state === "closed")
+          return w(void 0);
+        if (e._state === "errored")
+          return m(e._storedError);
+        ft(e);
+        const r = e._reader;
+        if (r !== void 0 && qe(r)) {
+          const s = r._readIntoRequests;
+          r._readIntoRequests = new U(), s.forEach((f) => {
+            f._closeSteps(void 0);
+          });
+        }
+        const o = e._readableStreamController[ir](t);
+        return B(o, u);
+      }
+      function ft(e) {
+        e._state = "closed";
+        const t = e._reader;
+        if (t !== void 0 && (nn(t), _e(t))) {
+          const r = t._readRequests;
+          t._readRequests = new U(), r.forEach((o) => {
+            o._closeSteps();
+          });
+        }
+      }
+      function oo(e, t) {
+        e._state = "errored", e._storedError = t;
+        const r = e._reader;
+        r !== void 0 && (dr(r, t), _e(r) ? fn(r, t) : In(r, t));
+      }
+      function Ie(e) {
+        return new TypeError(`ReadableStream.prototype.${e} can only be used on a ReadableStream`);
+      }
+      function ao(e, t) {
+        ne(e, t);
+        const r = e == null ? void 0 : e.highWaterMark;
+        return cr(r, "highWaterMark", "QueuingStrategyInit"), {
+          highWaterMark: hr(r)
+        };
+      }
+      const io = (e) => e.byteLength;
+      c(io, "size");
+      class Ut {
+        constructor(t) {
+          ue(t, 1, "ByteLengthQueuingStrategy"), t = ao(t, "First parameter"), this._byteLengthQueuingStrategyHighWaterMark = t.highWaterMark;
+        }
+        /**
+         * Returns the high water mark provided to the constructor.
+         */
+        get highWaterMark() {
+          if (!lo(this))
+            throw so("highWaterMark");
+          return this._byteLengthQueuingStrategyHighWaterMark;
+        }
+        /**
+         * Measures the size of `chunk` by returning the value of its `byteLength` property.
+         */
+        get size() {
+          if (!lo(this))
+            throw so("size");
+          return io;
+        }
+      }
+      Object.defineProperties(Ut.prototype, {
+        highWaterMark: { enumerable: !0 },
+        size: { enumerable: !0 }
+      }), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(Ut.prototype, Symbol.toStringTag, {
+        value: "ByteLengthQueuingStrategy",
+        configurable: !0
+      });
+      function so(e) {
+        return new TypeError(`ByteLengthQueuingStrategy.prototype.${e} can only be used on a ByteLengthQueuingStrategy`);
+      }
+      function lo(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_byteLengthQueuingStrategyHighWaterMark") ? !1 : e instanceof Ut;
+      }
+      const uo = () => 1;
+      c(uo, "size");
+      class xt {
+        constructor(t) {
+          ue(t, 1, "CountQueuingStrategy"), t = ao(t, "First parameter"), this._countQueuingStrategyHighWaterMark = t.highWaterMark;
+        }
+        /**
+         * Returns the high water mark provided to the constructor.
+         */
+        get highWaterMark() {
+          if (!co(this))
+            throw fo("highWaterMark");
+          return this._countQueuingStrategyHighWaterMark;
+        }
+        /**
+         * Measures the size of `chunk` by always returning 1.
+         * This ensures that the total queue size is a count of the number of chunks in the queue.
+         */
+        get size() {
+          if (!co(this))
+            throw fo("size");
+          return uo;
+        }
+      }
+      Object.defineProperties(xt.prototype, {
+        highWaterMark: { enumerable: !0 },
+        size: { enumerable: !0 }
+      }), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(xt.prototype, Symbol.toStringTag, {
+        value: "CountQueuingStrategy",
+        configurable: !0
+      });
+      function fo(e) {
+        return new TypeError(`CountQueuingStrategy.prototype.${e} can only be used on a CountQueuingStrategy`);
+      }
+      function co(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_countQueuingStrategyHighWaterMark") ? !1 : e instanceof xt;
+      }
+      function ui(e, t) {
+        ne(e, t);
+        const r = e == null ? void 0 : e.cancel, o = e == null ? void 0 : e.flush, s = e == null ? void 0 : e.readableType, f = e == null ? void 0 : e.start, d = e == null ? void 0 : e.transform, b = e == null ? void 0 : e.writableType;
+        return {
+          cancel: r === void 0 ? void 0 : hi(r, e, `${t} has member 'cancel' that`),
+          flush: o === void 0 ? void 0 : fi(o, e, `${t} has member 'flush' that`),
+          readableType: s,
+          start: f === void 0 ? void 0 : di(f, e, `${t} has member 'start' that`),
+          transform: d === void 0 ? void 0 : ci(d, e, `${t} has member 'transform' that`),
+          writableType: b
+        };
+      }
+      function fi(e, t, r) {
+        return G(e, r), (o) => z(e, t, [o]);
+      }
+      function di(e, t, r) {
+        return G(e, r), (o) => O(e, t, [o]);
+      }
+      function ci(e, t, r) {
+        return G(e, r), (o, s) => z(e, t, [o, s]);
+      }
+      function hi(e, t, r) {
+        return G(e, r), (o) => z(e, t, [o]);
+      }
+      class Nt {
+        constructor(t = {}, r = {}, o = {}) {
+          t === void 0 && (t = null);
+          const s = kt(r, "Second parameter"), f = kt(o, "Third parameter"), d = ui(t, "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 b = at(f, 0), S = Wt(f), y = at(s, 1), C = Wt(s);
+          let P;
+          const k = E((te) => {
+            P = te;
+          });
+          mi(this, k, y, C, b, S), pi(this, d), d.start !== void 0 ? P(d.start(this._transformStreamController)) : P(void 0);
+        }
+        /**
+         * The readable side of the transform stream.
+         */
+        get readable() {
+          if (!ho(this))
+            throw yo("readable");
+          return this._readable;
+        }
+        /**
+         * The writable side of the transform stream.
+         */
+        get writable() {
+          if (!ho(this))
+            throw yo("writable");
+          return this._writable;
+        }
+      }
+      Object.defineProperties(Nt.prototype, {
+        readable: { enumerable: !0 },
+        writable: { enumerable: !0 }
+      }), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(Nt.prototype, Symbol.toStringTag, {
+        value: "TransformStream",
+        configurable: !0
+      });
+      function mi(e, t, r, o, s, f) {
+        function d() {
+          return t;
+        }
+        function b(k) {
+          return _i(e, k);
+        }
+        function S(k) {
+          return Si(e, k);
+        }
+        function y() {
+          return wi(e);
+        }
+        e._writable = ga(d, b, y, S, r, o);
+        function C() {
+          return Ri(e);
+        }
+        function P(k) {
+          return Ci(e, k);
+        }
+        e._readable = ut(d, C, P, s, f), e._backpressure = void 0, e._backpressureChangePromise = void 0, e._backpressureChangePromise_resolve = void 0, Ht(e, !0), e._transformStreamController = void 0;
+      }
+      function ho(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_transformStreamController") ? !1 : e instanceof Nt;
+      }
+      function mo(e, t) {
+        X(e._readable._readableStreamController, t), xr(e, t);
+      }
+      function xr(e, t) {
+        Vt(e._transformStreamController), it(e._writable._writableStreamController, t), Nr(e);
+      }
+      function Nr(e) {
+        e._backpressure && Ht(e, !1);
+      }
+      function Ht(e, t) {
+        e._backpressureChangePromise !== void 0 && e._backpressureChangePromise_resolve(), e._backpressureChangePromise = E((r) => {
+          e._backpressureChangePromise_resolve = r;
+        }), e._backpressure = t;
+      }
+      class ve {
+        constructor() {
+          throw new TypeError("Illegal constructor");
+        }
+        /**
+         * Returns the desired size to fill the readable side’s internal queue. It can be negative, if the queue is over-full.
+         */
+        get desiredSize() {
+          if (!Qt(this))
+            throw Yt("desiredSize");
+          const t = this._controlledTransformStream._readable._readableStreamController;
+          return Mr(t);
+        }
+        enqueue(t = void 0) {
+          if (!Qt(this))
+            throw Yt("enqueue");
+          bo(this, t);
+        }
+        /**
+         * Errors both the readable side and the writable side of the controlled transform stream, making all future
+         * interactions with it fail with the given error `e`. Any chunks queued for transformation will be discarded.
+         */
+        error(t = void 0) {
+          if (!Qt(this))
+            throw Yt("error");
+          yi(this, t);
+        }
+        /**
+         * Closes the readable side and errors the writable side of the controlled transform stream. This is useful when the
+         * transformer only needs to consume a portion of the chunks written to the writable side.
+         */
+        terminate() {
+          if (!Qt(this))
+            throw Yt("terminate");
+          gi(this);
+        }
+      }
+      Object.defineProperties(ve.prototype, {
+        enqueue: { enumerable: !0 },
+        error: { enumerable: !0 },
+        terminate: { enumerable: !0 },
+        desiredSize: { enumerable: !0 }
+      }), c(ve.prototype.enqueue, "enqueue"), c(ve.prototype.error, "error"), c(ve.prototype.terminate, "terminate"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(ve.prototype, Symbol.toStringTag, {
+        value: "TransformStreamDefaultController",
+        configurable: !0
+      });
+      function Qt(e) {
+        return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_controlledTransformStream") ? !1 : e instanceof ve;
+      }
+      function bi(e, t, r, o, s) {
+        t._controlledTransformStream = e, e._transformStreamController = t, t._transformAlgorithm = r, t._flushAlgorithm = o, t._cancelAlgorithm = s, t._finishPromise = void 0, t._finishPromise_resolve = void 0, t._finishPromise_reject = void 0;
+      }
+      function pi(e, t) {
+        const r = Object.create(ve.prototype);
+        let o, s, f;
+        t.transform !== void 0 ? o = (d) => t.transform(d, r) : o = (d) => {
+          try {
+            return bo(r, d), w(void 0);
+          } catch (b) {
+            return m(b);
+          }
+        }, t.flush !== void 0 ? s = () => t.flush(r) : s = () => w(void 0), t.cancel !== void 0 ? f = (d) => t.cancel(d) : f = () => w(void 0), bi(e, r, o, s, f);
+      }
+      function Vt(e) {
+        e._transformAlgorithm = void 0, e._flushAlgorithm = void 0, e._cancelAlgorithm = void 0;
+      }
+      function bo(e, t) {
+        const r = e._controlledTransformStream, o = r._readable._readableStreamController;
+        if (!Ne(o))
+          throw new TypeError("Readable side is not in a state that permits enqueue");
+        try {
+          xe(o, t);
+        } catch (f) {
+          throw xr(r, f), r._readable._storedError;
+        }
+        Qa(o) !== r._backpressure && Ht(r, !0);
+      }
+      function yi(e, t) {
+        mo(e._controlledTransformStream, t);
+      }
+      function po(e, t) {
+        const r = e._transformAlgorithm(t);
+        return B(r, void 0, (o) => {
+          throw mo(e._controlledTransformStream, o), o;
+        });
+      }
+      function gi(e) {
+        const t = e._controlledTransformStream, r = t._readable._readableStreamController;
+        Fe(r);
+        const o = new TypeError("TransformStream terminated");
+        xr(t, o);
+      }
+      function _i(e, t) {
+        const r = e._transformStreamController;
+        if (e._backpressure) {
+          const o = e._backpressureChangePromise;
+          return B(o, () => {
+            const s = e._writable;
+            if (s._state === "erroring")
+              throw s._storedError;
+            return po(r, t);
+          });
+        }
+        return po(r, t);
+      }
+      function Si(e, t) {
+        const r = e._transformStreamController;
+        if (r._finishPromise !== void 0)
+          return r._finishPromise;
+        const o = e._readable;
+        r._finishPromise = E((f, d) => {
+          r._finishPromise_resolve = f, r._finishPromise_reject = d;
+        });
+        const s = r._cancelAlgorithm(t);
+        return Vt(r), p(s, () => (o._state === "errored" ? He(r, o._storedError) : (X(o._readableStreamController, t), Hr(r)), null), (f) => (X(o._readableStreamController, f), He(r, f), null)), r._finishPromise;
+      }
+      function wi(e) {
+        const t = e._transformStreamController;
+        if (t._finishPromise !== void 0)
+          return t._finishPromise;
+        const r = e._readable;
+        t._finishPromise = E((s, f) => {
+          t._finishPromise_resolve = s, t._finishPromise_reject = f;
+        });
+        const o = t._flushAlgorithm();
+        return Vt(t), p(o, () => (r._state === "errored" ? He(t, r._storedError) : (Fe(r._readableStreamController), Hr(t)), null), (s) => (X(r._readableStreamController, s), He(t, s), null)), t._finishPromise;
+      }
+      function Ri(e) {
+        return Ht(e, !1), e._backpressureChangePromise;
+      }
+      function Ci(e, t) {
+        const r = e._transformStreamController;
+        if (r._finishPromise !== void 0)
+          return r._finishPromise;
+        const o = e._writable;
+        r._finishPromise = E((f, d) => {
+          r._finishPromise_resolve = f, r._finishPromise_reject = d;
+        });
+        const s = r._cancelAlgorithm(t);
+        return Vt(r), p(s, () => (o._state === "errored" ? He(r, o._storedError) : (it(o._writableStreamController, t), Nr(e), Hr(r)), null), (f) => (it(o._writableStreamController, f), Nr(e), He(r, f), null)), r._finishPromise;
+      }
+      function Yt(e) {
+        return new TypeError(`TransformStreamDefaultController.prototype.${e} can only be used on a TransformStreamDefaultController`);
+      }
+      function Hr(e) {
+        e._finishPromise_resolve !== void 0 && (e._finishPromise_resolve(), e._finishPromise_resolve = void 0, e._finishPromise_reject = void 0);
+      }
+      function He(e, t) {
+        e._finishPromise_reject !== void 0 && (L(e._finishPromise), e._finishPromise_reject(t), e._finishPromise_resolve = void 0, e._finishPromise_reject = void 0);
+      }
+      function yo(e) {
+        return new TypeError(`TransformStream.prototype.${e} can only be used on a TransformStream`);
+      }
+      a.ByteLengthQueuingStrategy = Ut, a.CountQueuingStrategy = xt, a.ReadableByteStreamController = de, a.ReadableStream = D, a.ReadableStreamBYOBReader = Re, a.ReadableStreamBYOBRequest = Be, a.ReadableStreamDefaultController = he, a.ReadableStreamDefaultReader = ge, a.TransformStream = Nt, a.TransformStreamDefaultController = ve, a.WritableStream = Ce, a.WritableStreamDefaultController = Ue, a.WritableStreamDefaultWriter = ce;
+    });
+  }(Jt, Jt.exports)), Jt.exports;
+}
+const Fi = 65536;
+if (!globalThis.ReadableStream)
+  try {
+    const i = require("node:process"), { emitWarning: n } = i;
+    try {
+      i.emitWarning = () => {
+      }, Object.assign(globalThis, require("node:stream/web")), i.emitWarning = n;
+    } catch (a) {
+      throw i.emitWarning = n, a;
+    }
+  } catch {
+    Object.assign(globalThis, zi());
+  }
+try {
+  const { Blob: i } = require("buffer");
+  i && !i.prototype.stream && (i.prototype.stream = function(a) {
+    let u = 0;
+    const l = this;
+    return new ReadableStream({
+      type: "bytes",
+      async pull(h) {
+        const T = await l.slice(u, Math.min(l.size, u + Fi)).arrayBuffer();
+        u += T.byteLength, h.enqueue(new Uint8Array(T)), u === l.size && h.close();
+      }
+    });
+  });
+} catch {
+}
+/*! fetch-blob. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
+const Ro = 65536;
+async function* Yr(i, n = !0) {
+  for (const a of i)
+    if ("stream" in a)
+      yield* (
+        /** @type {AsyncIterableIterator<Uint8Array>} */
+        a.stream()
+      );
+    else if (ArrayBuffer.isView(a))
+      if (n) {
+        let u = a.byteOffset;
+        const l = a.byteOffset + a.byteLength;
+        for (; u !== l; ) {
+          const h = Math.min(l - u, Ro), c = a.buffer.slice(u, u + h);
+          u += c.byteLength, yield new Uint8Array(c);
+        }
+      } else
+        yield a;
+    else {
+      let u = 0, l = (
+        /** @type {Blob} */
+        a
+      );
+      for (; u !== l.size; ) {
+        const c = await l.slice(u, Math.min(l.size, u + Ro)).arrayBuffer();
+        u += c.byteLength, yield new Uint8Array(c);
+      }
+    }
+}
+var pe, pt, Xe, nr, et;
+const Ao = (et = class {
+  /**
+   * The Blob() constructor returns a new Blob object. The content
+   * of the blob consists of the concatenation of the values given
+   * in the parameter array.
+   *
+   * @param {*} blobParts
+   * @param {{ type?: string, endings?: string }} [options]
+   */
+  constructor(n = [], a = {}) {
+    /** @type {Array.<(Blob|Uint8Array)>} */
+    Ae(this, pe, []);
+    Ae(this, pt, "");
+    Ae(this, Xe, 0);
+    Ae(this, nr, "transparent");
+    if (typeof n != "object" || n === null)
+      throw new TypeError("Failed to construct 'Blob': The provided value cannot be converted to a sequence.");
+    if (typeof n[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 u = new TextEncoder();
+    for (const h of n) {
+      let c;
+      ArrayBuffer.isView(h) ? c = new Uint8Array(h.buffer.slice(h.byteOffset, h.byteOffset + h.byteLength)) : h instanceof ArrayBuffer ? c = new Uint8Array(h.slice(0)) : h instanceof et ? c = h : c = u.encode(`${h}`), ae(this, Xe, F(this, Xe) + (ArrayBuffer.isView(c) ? c.byteLength : c.size)), F(this, pe).push(c);
+    }
+    ae(this, nr, `${a.endings === void 0 ? "transparent" : a.endings}`);
+    const l = a.type === void 0 ? "" : String(a.type);
+    ae(this, pt, /^[\x20-\x7E]*$/.test(l) ? l : "");
+  }
+  /**
+   * The Blob interface's size property returns the
+   * size of the Blob in bytes.
+   */
+  get size() {
+    return F(this, Xe);
+  }
+  /**
+   * The type property of a Blob object returns the MIME type of the file.
+   */
+  get type() {
+    return F(this, pt);
+  }
+  /**
+   * The text() method in the Blob interface returns a Promise
+   * that resolves with a string containing the contents of
+   * the blob, interpreted as UTF-8.
+   *
+   * @return {Promise<string>}
+   */
+  async text() {
+    const n = new TextDecoder();
+    let a = "";
+    for await (const u of Yr(F(this, pe), !1))
+      a += n.decode(u, { stream: !0 });
+    return a += n.decode(), a;
+  }
+  /**
+   * The arrayBuffer() method in the Blob interface returns a
+   * Promise that resolves with the contents of the blob as
+   * binary data contained in an ArrayBuffer.
+   *
+   * @return {Promise<ArrayBuffer>}
+   */
+  async arrayBuffer() {
+    const n = new Uint8Array(this.size);
+    let a = 0;
+    for await (const u of Yr(F(this, pe), !1))
+      n.set(u, a), a += u.length;
+    return n.buffer;
+  }
+  stream() {
+    const n = Yr(F(this, pe), !0);
+    return new globalThis.ReadableStream({
+      // @ts-ignore
+      type: "bytes",
+      async pull(a) {
+        const u = await n.next();
+        u.done ? a.close() : a.enqueue(u.value);
+      },
+      async cancel() {
+        await n.return();
+      }
+    });
+  }
+  /**
+   * The Blob interface's slice() method creates and returns a
+   * new Blob object which contains data from a subset of the
+   * blob on which it's called.
+   *
+   * @param {number} [start]
+   * @param {number} [end]
+   * @param {string} [type]
+   */
+  slice(n = 0, a = this.size, u = "") {
+    const { size: l } = this;
+    let h = n < 0 ? Math.max(l + n, 0) : Math.min(n, l), c = a < 0 ? Math.max(l + a, 0) : Math.min(a, l);
+    const T = Math.max(c - h, 0), v = F(this, pe), _ = [];
+    let E = 0;
+    for (const m of v) {
+      if (E >= T)
+        break;
+      const W = ArrayBuffer.isView(m) ? m.byteLength : m.size;
+      if (h && W <= h)
+        h -= W, c -= W;
+      else {
+        let p;
+        ArrayBuffer.isView(m) ? (p = m.subarray(h, Math.min(W, c)), E += p.byteLength) : (p = m.slice(h, Math.min(W, c)), E += p.size), c -= W, _.push(p), h = 0;
+      }
+    }
+    const w = new et([], { type: String(u).toLowerCase() });
+    return ae(w, Xe, T), ae(w, pe, _), w;
+  }
+  get [Symbol.toStringTag]() {
+    return "Blob";
+  }
+  static [Symbol.hasInstance](n) {
+    return n && typeof n == "object" && typeof n.constructor == "function" && (typeof n.stream == "function" || typeof n.arrayBuffer == "function") && /^(Blob|File)$/.test(n[Symbol.toStringTag]);
+  }
+}, pe = new WeakMap(), pt = new WeakMap(), Xe = new WeakMap(), nr = new WeakMap(), et);
+Object.defineProperties(Ao.prototype, {
+  size: { enumerable: !0 },
+  type: { enumerable: !0 },
+  slice: { enumerable: !0 }
+});
+const Ii = Ao, er = Ii;
+var yt, gt, vo;
+const ji = (vo = class extends er {
+  /**
+   * @param {*[]} fileBits
+   * @param {string} fileName
+   * @param {{lastModified?: number, type?: string}} options
+   */
+  // @ts-ignore
+  constructor(a, u, l = {}) {
+    if (arguments.length < 2)
+      throw new TypeError(`Failed to construct 'File': 2 arguments required, but only ${arguments.length} present.`);
+    super(a, l);
+    Ae(this, yt, 0);
+    Ae(this, gt, "");
+    l === null && (l = {});
+    const h = l.lastModified === void 0 ? Date.now() : Number(l.lastModified);
+    Number.isNaN(h) || ae(this, yt, h), ae(this, gt, String(u));
+  }
+  get name() {
+    return F(this, gt);
+  }
+  get lastModified() {
+    return F(this, yt);
+  }
+  get [Symbol.toStringTag]() {
+    return "File";
+  }
+  static [Symbol.hasInstance](a) {
+    return !!a && a instanceof er && /^(File)$/.test(a[Symbol.toStringTag]);
+  }
+}, yt = new WeakMap(), gt = new WeakMap(), vo), Li = ji;
+/*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
+var { toStringTag: ct, iterator: Di, hasInstance: $i } = Symbol, Co = Math.random, Mi = "append,set,get,getAll,delete,keys,values,entries,forEach,constructor".split(","), To = (i, n, a) => (i += "", /^(Blob|File)$/.test(n && n[ct]) ? [(a = a !== void 0 ? a + "" : n[ct] == "File" ? n.name : "blob", i), n.name !== a || n[ct] == "blob" ? new Li([n], a, n) : n] : [i, n + ""]), Gr = (i, n) => (n ? i : i.replace(/\r?\n|\r/g, `\r
+`)).replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22"), je = (i, n, a) => {
+  if (n.length < a)
+    throw new TypeError(`Failed to execute '${i}' on 'FormData': ${a} arguments required, but only ${n.length} present.`);
+}, K, Eo;
+const Zr = (Eo = class {
+  constructor(...n) {
+    Ae(this, K, []);
+    if (n.length)
+      throw new TypeError("Failed to construct 'FormData': parameter 1 is not of type 'HTMLFormElement'.");
+  }
+  get [ct]() {
+    return "FormData";
+  }
+  [Di]() {
+    return this.entries();
+  }
+  static [$i](n) {
+    return n && typeof n == "object" && n[ct] === "FormData" && !Mi.some((a) => typeof n[a] != "function");
+  }
+  append(...n) {
+    je("append", arguments, 2), F(this, K).push(To(...n));
+  }
+  delete(n) {
+    je("delete", arguments, 1), n += "", ae(this, K, F(this, K).filter(([a]) => a !== n));
+  }
+  get(n) {
+    je("get", arguments, 1), n += "";
+    for (var a = F(this, K), u = a.length, l = 0; l < u; l++)
+      if (a[l][0] === n)
+        return a[l][1];
+    return null;
+  }
+  getAll(n, a) {
+    return je("getAll", arguments, 1), a = [], n += "", F(this, K).forEach((u) => u[0] === n && a.push(u[1])), a;
+  }
+  has(n) {
+    return je("has", arguments, 1), n += "", F(this, K).some((a) => a[0] === n);
+  }
+  forEach(n, a) {
+    je("forEach", arguments, 1);
+    for (var [u, l] of this)
+      n.call(a, l, u, this);
+  }
+  set(...n) {
+    je("set", arguments, 2);
+    var a = [], u = !0;
+    n = To(...n), F(this, K).forEach((l) => {
+      l[0] === n[0] ? u && (u = !a.push(n)) : a.push(l);
+    }), u && a.push(n), ae(this, K, a);
+  }
+  *entries() {
+    yield* F(this, K);
+  }
+  *keys() {
+    for (var [n] of this)
+      yield n;
+  }
+  *values() {
+    for (var [, n] of this)
+      yield n;
+  }
+}, K = new WeakMap(), Eo);
+function Ui(i, n = er) {
+  var a = `${Co()}${Co()}`.replace(/\./g, "").slice(-28).padStart(32, "-"), u = [], l = `--${a}\r
+Content-Disposition: form-data; name="`;
+  return i.forEach((h, c) => typeof h == "string" ? u.push(l + Gr(c) + `"\r
+\r
+${h.replace(new RegExp("\\r(?!\\n)|(?<!\\r)\\n", "g"), `\r
+`)}\r
+`) : u.push(l + Gr(c) + `"; filename="${Gr(h.name, 1)}"\r
+Content-Type: ${h.type || "application/octet-stream"}\r
+\r
+`, h, `\r
+`)), u.push(`--${a}--`), new n(u, { type: "multipart/form-data; boundary=" + a });
+}
+class ar extends Error {
+  constructor(n, a) {
+    super(n), Error.captureStackTrace(this, this.constructor), this.type = a;
+  }
+  get name() {
+    return this.constructor.name;
+  }
+  get [Symbol.toStringTag]() {
+    return this.constructor.name;
+  }
+}
+class ie extends ar {
+  /**
+   * @param  {string} message -      Error message for human
+   * @param  {string} [type] -        Error type for machine
+   * @param  {SystemError} [systemError] - For Node.js system error
+   */
+  constructor(n, a, u) {
+    super(n, a), u && (this.code = this.errno = u.code, this.erroredSysCall = u.syscall);
+  }
+}
+const tr = Symbol.toStringTag, Bo = (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[tr] === "URLSearchParams", rr = (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[tr]), xi = (i) => typeof i == "object" && (i[tr] === "AbortSignal" || i[tr] === "EventTarget"), Ni = (i, n) => {
+  const a = new URL(n).hostname, u = new URL(i).hostname;
+  return a === u || a.endsWith(`.${u}`);
+}, Hi = (i, n) => {
+  const a = new URL(n).protocol, u = new URL(i).protocol;
+  return a === u;
+}, Qi = vi(se.pipeline), H = Symbol("Body internals");
+class mt {
+  constructor(n, {
+    size: a = 0
+  } = {}) {
+    let u = null;
+    n === null ? n = null : Bo(n) ? n = $.from(n.toString()) : rr(n) || $.isBuffer(n) || (Xt.isAnyArrayBuffer(n) ? n = $.from(n) : ArrayBuffer.isView(n) ? n = $.from(n.buffer, n.byteOffset, n.byteLength) : n instanceof se || (n instanceof Zr ? (n = Ui(n), u = n.type.split("=")[1]) : n = $.from(String(n))));
+    let l = n;
+    $.isBuffer(n) ? l = se.Readable.from(n) : rr(n) && (l = se.Readable.from(n.stream())), this[H] = {
+      body: n,
+      stream: l,
+      boundary: u,
+      disturbed: !1,
+      error: null
+    }, this.size = a, n instanceof se && n.on("error", (h) => {
+      const c = h instanceof ar ? h : new ie(`Invalid response body while trying to fetch ${this.url}: ${h.message}`, "system", h);
+      this[H].error = c;
+    });
+  }
+  get body() {
+    return this[H].stream;
+  }
+  get bodyUsed() {
+    return this[H].disturbed;
+  }
+  /**
+   * Decode response as ArrayBuffer
+   *
+   * @return  Promise
+   */
+  async arrayBuffer() {
+    const { buffer: n, byteOffset: a, byteLength: u } = await Jr(this);
+    return n.slice(a, a + u);
+  }
+  async formData() {
+    const n = this.headers.get("content-type");
+    if (n.startsWith("application/x-www-form-urlencoded")) {
+      const u = new Zr(), l = new URLSearchParams(await this.text());
+      for (const [h, c] of l)
+        u.append(h, c);
+      return u;
+    }
+    const { toFormData: a } = await import("./multipart-parser-513ff2e8.js");
+    return a(this.body, n);
+  }
+  /**
+   * Return raw response as Blob
+   *
+   * @return Promise
+   */
+  async blob() {
+    const n = this.headers && this.headers.get("content-type") || this[H].body && this[H].body.type || "", a = await this.arrayBuffer();
+    return new er([a], {
+      type: n
+    });
+  }
+  /**
+   * Decode response as json
+   *
+   * @return  Promise
+   */
+  async json() {
+    const n = await this.text();
+    return JSON.parse(n);
+  }
+  /**
+   * Decode response as text
+   *
+   * @return  Promise
+   */
+  async text() {
+    const n = await Jr(this);
+    return new TextDecoder().decode(n);
+  }
+  /**
+   * Decode response as buffer (non-spec api)
+   *
+   * @return  Promise
+   */
+  buffer() {
+    return Jr(this);
+  }
+}
+mt.prototype.buffer = or(mt.prototype.buffer, "Please use 'response.arrayBuffer()' instead of 'response.buffer()'", "node-fetch#buffer");
+Object.defineProperties(mt.prototype, {
+  body: { enumerable: !0 },
+  bodyUsed: { enumerable: !0 },
+  arrayBuffer: { enumerable: !0 },
+  blob: { enumerable: !0 },
+  json: { enumerable: !0 },
+  text: { enumerable: !0 },
+  data: { get: or(
+    () => {
+    },
+    "data doesn't exist, use json(), text(), arrayBuffer(), or body instead",
+    "https://github.com/node-fetch/node-fetch/issues/1000 (response)"
+  ) }
+});
+async function Jr(i) {
+  if (i[H].disturbed)
+    throw new TypeError(`body used already for: ${i.url}`);
+  if (i[H].disturbed = !0, i[H].error)
+    throw i[H].error;
+  const { body: n } = i;
+  if (n === null)
+    return $.alloc(0);
+  if (!(n instanceof se))
+    return $.alloc(0);
+  const a = [];
+  let u = 0;
+  try {
+    for await (const l of n) {
+      if (i.size > 0 && u + l.length > i.size) {
+        const h = new ie(`content size at ${i.url} over limit: ${i.size}`, "max-size");
+        throw n.destroy(h), h;
+      }
+      u += l.length, a.push(l);
+    }
+  } catch (l) {
+    throw l instanceof ar ? l : new ie(`Invalid response body while trying to fetch ${i.url}: ${l.message}`, "system", l);
+  }
+  if (n.readableEnded === !0 || n._readableState.ended === !0)
+    try {
+      return a.every((l) => typeof l == "string") ? $.from(a.join("")) : $.concat(a, u);
+    } catch (l) {
+      throw new ie(`Could not create Buffer from response body for ${i.url}: ${l.message}`, "system", l);
+    }
+  else
+    throw new ie(`Premature close of server response while trying to fetch ${i.url}`);
+}
+const Xr = (i, n) => {
+  let a, u, { body: l } = i[H];
+  if (i.bodyUsed)
+    throw new Error("cannot clone body after it is used");
+  return l instanceof se && typeof l.getBoundary != "function" && (a = new Kt({ highWaterMark: n }), u = new Kt({ highWaterMark: n }), l.pipe(a), l.pipe(u), i[H].stream = a, l = u), l;
+}, Vi = or(
+  (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"
+), Wo = (i, n) => i === null ? null : typeof i == "string" ? "text/plain;charset=UTF-8" : Bo(i) ? "application/x-www-form-urlencoded;charset=UTF-8" : rr(i) ? i.type || null : $.isBuffer(i) || Xt.isAnyArrayBuffer(i) || ArrayBuffer.isView(i) ? null : i instanceof Zr ? `multipart/form-data; boundary=${n[H].boundary}` : i && typeof i.getBoundary == "function" ? `multipart/form-data;boundary=${Vi(i)}` : i instanceof se ? null : "text/plain;charset=UTF-8", Yi = (i) => {
+  const { body: n } = i[H];
+  return n === null ? 0 : rr(n) ? n.size : $.isBuffer(n) ? n.length : n && typeof n.getLengthSync == "function" && n.hasKnownLength && n.hasKnownLength() ? n.getLengthSync() : null;
+}, Gi = async (i, { body: n }) => {
+  n === null ? i.end() : await Qi(n, i);
+}, Zt = typeof ht.validateHeaderName == "function" ? ht.validateHeaderName : (i) => {
+  if (!/^[\^`\-\w!#$%&'*+.|~]+$/.test(i)) {
+    const n = new TypeError(`Header name must be a valid HTTP token [${i}]`);
+    throw Object.defineProperty(n, "code", { value: "ERR_INVALID_HTTP_TOKEN" }), n;
+  }
+}, Kr = typeof ht.validateHeaderValue == "function" ? ht.validateHeaderValue : (i, n) => {
+  if (/[^\t\u0020-\u007E\u0080-\u00FF]/.test(n)) {
+    const a = new TypeError(`Invalid character in header content ["${i}"]`);
+    throw Object.defineProperty(a, "code", { value: "ERR_INVALID_CHAR" }), a;
+  }
+};
+class ye extends URLSearchParams {
+  /**
+   * Headers class
+   *
+   * @constructor
+   * @param {HeadersInit} [init] - Response headers
+   */
+  constructor(n) {
+    let a = [];
+    if (n instanceof ye) {
+      const u = n.raw();
+      for (const [l, h] of Object.entries(u))
+        a.push(...h.map((c) => [l, c]));
+    } else if (n != null)
+      if (typeof n == "object" && !Xt.isBoxedPrimitive(n)) {
+        const u = n[Symbol.iterator];
+        if (u == null)
+          a.push(...Object.entries(n));
+        else {
+          if (typeof u != "function")
+            throw new TypeError("Header pairs must be iterable");
+          a = [...n].map((l) => {
+            if (typeof l != "object" || Xt.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(([u, l]) => (Zt(u), Kr(u, String(l)), [String(u).toLowerCase(), String(l)])) : void 0, super(a), new Proxy(this, {
+      get(u, l, h) {
+        switch (l) {
+          case "append":
+          case "set":
+            return (c, T) => (Zt(c), Kr(c, String(T)), URLSearchParams.prototype[l].call(
+              u,
+              String(c).toLowerCase(),
+              String(T)
+            ));
+          case "delete":
+          case "has":
+          case "getAll":
+            return (c) => (Zt(c), URLSearchParams.prototype[l].call(
+              u,
+              String(c).toLowerCase()
+            ));
+          case "keys":
+            return () => (u.sort(), new Set(URLSearchParams.prototype.keys.call(u)).keys());
+          default:
+            return Reflect.get(u, l, h);
+        }
+      }
+    });
+  }
+  get [Symbol.toStringTag]() {
+    return this.constructor.name;
+  }
+  toString() {
+    return Object.prototype.toString.call(this);
+  }
+  get(n) {
+    const a = this.getAll(n);
+    if (a.length === 0)
+      return null;
+    let u = a.join(", ");
+    return /^content-encoding$/i.test(n) && (u = u.toLowerCase()), u;
+  }
+  forEach(n, a = void 0) {
+    for (const u of this.keys())
+      Reflect.apply(n, a, [this.get(u), u, this]);
+  }
+  *values() {
+    for (const n of this.keys())
+      yield this.get(n);
+  }
+  /**
+   * @type {() => IterableIterator<[string, string]>}
+   */
+  *entries() {
+    for (const n of this.keys())
+      yield [n, this.get(n)];
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  /**
+   * Node-fetch non-spec method
+   * returning all headers and their values as array
+   * @returns {Record<string, string[]>}
+   */
+  raw() {
+    return [...this.keys()].reduce((n, a) => (n[a] = this.getAll(a), n), {});
+  }
+  /**
+   * For better console.log(headers) and also to convert Headers into Node.js Request compatible format
+   */
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return [...this.keys()].reduce((n, a) => {
+      const u = this.getAll(a);
+      return a === "host" ? n[a] = u[0] : n[a] = u.length > 1 ? u : u[0], n;
+    }, {});
+  }
+}
+Object.defineProperties(
+  ye.prototype,
+  ["get", "entries", "forEach", "values"].reduce((i, n) => (i[n] = { enumerable: !0 }, i), {})
+);
+function Ji(i = []) {
+  return new ye(
+    i.reduce((n, a, u, l) => (u % 2 === 0 && n.push(l.slice(u, u + 2)), n), []).filter(([n, a]) => {
+      try {
+        return Zt(n), Kr(n, String(a)), !0;
+      } catch {
+        return !1;
+      }
+    })
+  );
+}
+const Zi = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]), ko = (i) => Zi.has(i), re = Symbol("Response internals");
+class V extends mt {
+  constructor(n = null, a = {}) {
+    super(n, a);
+    const u = a.status != null ? a.status : 200, l = new ye(a.headers);
+    if (n !== null && !l.has("Content-Type")) {
+      const h = Wo(n, this);
+      h && l.append("Content-Type", h);
+    }
+    this[re] = {
+      type: "default",
+      url: a.url,
+      status: u,
+      statusText: a.statusText || "",
+      headers: l,
+      counter: a.counter,
+      highWaterMark: a.highWaterMark
+    };
+  }
+  get type() {
+    return this[re].type;
+  }
+  get url() {
+    return this[re].url || "";
+  }
+  get status() {
+    return this[re].status;
+  }
+  /**
+   * Convenience property representing if the request ended normally
+   */
+  get ok() {
+    return this[re].status >= 200 && this[re].status < 300;
+  }
+  get redirected() {
+    return this[re].counter > 0;
+  }
+  get statusText() {
+    return this[re].statusText;
+  }
+  get headers() {
+    return this[re].headers;
+  }
+  get highWaterMark() {
+    return this[re].highWaterMark;
+  }
+  /**
+   * Clone this response
+   *
+   * @return  Response
+   */
+  clone() {
+    return new V(Xr(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
+    });
+  }
+  /**
+   * @param {string} url    The URL that the new response is to originate from.
+   * @param {number} status An optional status code for the response (e.g., 302.)
+   * @returns {Response}    A Response object.
+   */
+  static redirect(n, a = 302) {
+    if (!ko(a))
+      throw new RangeError('Failed to execute "redirect" on "response": Invalid status code');
+    return new V(null, {
+      headers: {
+        location: new URL(n).toString()
+      },
+      status: a
+    });
+  }
+  static error() {
+    const n = new V(null, { status: 0, statusText: "" });
+    return n[re].type = "error", n;
+  }
+  static json(n = void 0, a = {}) {
+    const u = JSON.stringify(n);
+    if (u === 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 V(u, {
+      ...a,
+      headers: l
+    });
+  }
+  get [Symbol.toStringTag]() {
+    return "Response";
+  }
+}
+Object.defineProperties(V.prototype, {
+  type: { enumerable: !0 },
+  url: { enumerable: !0 },
+  status: { enumerable: !0 },
+  ok: { enumerable: !0 },
+  redirected: { enumerable: !0 },
+  statusText: { enumerable: !0 },
+  headers: { enumerable: !0 },
+  clone: { enumerable: !0 }
+});
+const Ki = (i) => {
+  if (i.search)
+    return i.search;
+  const n = i.href.length - 1, a = i.hash || (i.href[n] === "#" ? "#" : "");
+  return i.href[n - a.length] === "?" ? "?" : "";
+};
+function Po(i, n = !1) {
+  return i == null || (i = new URL(i), /^(about|blob|data):$/.test(i.protocol)) ? "no-referrer" : (i.username = "", i.password = "", i.hash = "", n && (i.pathname = "", i.search = ""), i);
+}
+const qo = /* @__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"
+]), Xi = "strict-origin-when-cross-origin";
+function es(i) {
+  if (!qo.has(i))
+    throw new TypeError(`Invalid referrerPolicy: ${i}`);
+  return i;
+}
+function ts(i) {
+  if (/^(http|ws)s:$/.test(i.protocol))
+    return !0;
+  const n = i.host.replace(/(^\[)|(]$)/g, ""), a = Ai(n);
+  return a === 4 && /^127\./.test(n) || a === 6 && /^(((0+:){7})|(::(0+:){0,6}))0*1$/.test(n) ? !0 : i.host === "localhost" || i.host.endsWith(".localhost") ? !1 : i.protocol === "file:";
+}
+function Ke(i) {
+  return /^about:(blank|srcdoc)$/.test(i) || i.protocol === "data:" || /^(blob|filesystem):$/.test(i.protocol) ? !0 : ts(i);
+}
+function rs(i, { referrerURLCallback: n, referrerOriginCallback: a } = {}) {
+  if (i.referrer === "no-referrer" || i.referrerPolicy === "")
+    return null;
+  const u = i.referrerPolicy;
+  if (i.referrer === "about:client")
+    return "no-referrer";
+  const l = i.referrer;
+  let h = Po(l), c = Po(l, !0);
+  h.toString().length > 4096 && (h = c), n && (h = n(h)), a && (c = a(c));
+  const T = new URL(i.url);
+  switch (u) {
+    case "no-referrer":
+      return "no-referrer";
+    case "origin":
+      return c;
+    case "unsafe-url":
+      return h;
+    case "strict-origin":
+      return Ke(h) && !Ke(T) ? "no-referrer" : c.toString();
+    case "strict-origin-when-cross-origin":
+      return h.origin === T.origin ? h : Ke(h) && !Ke(T) ? "no-referrer" : c;
+    case "same-origin":
+      return h.origin === T.origin ? h : "no-referrer";
+    case "origin-when-cross-origin":
+      return h.origin === T.origin ? h : c;
+    case "no-referrer-when-downgrade":
+      return Ke(h) && !Ke(T) ? "no-referrer" : h;
+    default:
+      throw new TypeError(`Invalid referrerPolicy: ${u}`);
+  }
+}
+function ns(i) {
+  const n = (i.get("referrer-policy") || "").split(/[,\s]+/);
+  let a = "";
+  for (const u of n)
+    u && qo.has(u) && (a = u);
+  return a;
+}
+const I = Symbol("Request internals"), dt = (i) => typeof i == "object" && typeof i[I] == "object", os = or(
+  () => {
+  },
+  ".data is not a valid RequestInit property, use .body instead",
+  "https://github.com/node-fetch/node-fetch/issues/1000 (request)"
+);
+class bt extends mt {
+  constructor(n, a = {}) {
+    let u;
+    if (dt(n) ? u = new URL(n.url) : (u = new URL(n), n = {}), u.username !== "" || u.password !== "")
+      throw new TypeError(`${u} is an url with embedded credentials.`);
+    let l = a.method || n.method || "GET";
+    if (/^(delete|get|head|options|post|put)$/i.test(l) && (l = l.toUpperCase()), !dt(a) && "data" in a && os(), (a.body != null || dt(n) && n.body !== null) && (l === "GET" || l === "HEAD"))
+      throw new TypeError("Request with GET/HEAD method cannot have body");
+    const h = a.body ? a.body : dt(n) && n.body !== null ? Xr(n) : null;
+    super(h, {
+      size: a.size || n.size || 0
+    });
+    const c = new ye(a.headers || n.headers || {});
+    if (h !== null && !c.has("Content-Type")) {
+      const _ = Wo(h, this);
+      _ && c.set("Content-Type", _);
+    }
+    let T = dt(n) ? n.signal : null;
+    if ("signal" in a && (T = a.signal), T != null && !xi(T))
+      throw new TypeError("Expected signal to be an instanceof AbortSignal or EventTarget");
+    let v = a.referrer == null ? n.referrer : a.referrer;
+    if (v === "")
+      v = "no-referrer";
+    else if (v) {
+      const _ = new URL(v);
+      v = /^about:(\/\/)?client$/.test(_) ? "client" : _;
+    } else
+      v = void 0;
+    this[I] = {
+      method: l,
+      redirect: a.redirect || n.redirect || "follow",
+      headers: c,
+      parsedURL: u,
+      signal: T,
+      referrer: v
+    }, this.follow = a.follow === void 0 ? n.follow === void 0 ? 20 : n.follow : a.follow, this.compress = a.compress === void 0 ? n.compress === void 0 ? !0 : n.compress : a.compress, this.counter = a.counter || n.counter || 0, this.agent = a.agent || n.agent, this.highWaterMark = a.highWaterMark || n.highWaterMark || 16384, this.insecureHTTPParser = a.insecureHTTPParser || n.insecureHTTPParser || !1, this.referrerPolicy = a.referrerPolicy || n.referrerPolicy || "";
+  }
+  /** @returns {string} */
+  get method() {
+    return this[I].method;
+  }
+  /** @returns {string} */
+  get url() {
+    return Ei(this[I].parsedURL);
+  }
+  /** @returns {Headers} */
+  get headers() {
+    return this[I].headers;
+  }
+  get redirect() {
+    return this[I].redirect;
+  }
+  /** @returns {AbortSignal} */
+  get signal() {
+    return this[I].signal;
+  }
+  // https://fetch.spec.whatwg.org/#dom-request-referrer
+  get referrer() {
+    if (this[I].referrer === "no-referrer")
+      return "";
+    if (this[I].referrer === "client")
+      return "about:client";
+    if (this[I].referrer)
+      return this[I].referrer.toString();
+  }
+  get referrerPolicy() {
+    return this[I].referrerPolicy;
+  }
+  set referrerPolicy(n) {
+    this[I].referrerPolicy = es(n);
+  }
+  /**
+   * Clone this request
+   *
+   * @return  Request
+   */
+  clone() {
+    return new bt(this);
+  }
+  get [Symbol.toStringTag]() {
+    return "Request";
+  }
+}
+Object.defineProperties(bt.prototype, {
+  method: { enumerable: !0 },
+  url: { enumerable: !0 },
+  headers: { enumerable: !0 },
+  redirect: { enumerable: !0 },
+  clone: { enumerable: !0 },
+  signal: { enumerable: !0 },
+  referrer: { enumerable: !0 },
+  referrerPolicy: { enumerable: !0 }
+});
+const as = (i) => {
+  const { parsedURL: n } = i[I], a = new ye(i[I].headers);
+  a.has("Accept") || a.set("Accept", "*/*");
+  let u = null;
+  if (i.body === null && /^(post|put)$/i.test(i.method) && (u = "0"), i.body !== null) {
+    const T = Yi(i);
+    typeof T == "number" && !Number.isNaN(T) && (u = String(T));
+  }
+  u && a.set("Content-Length", u), i.referrerPolicy === "" && (i.referrerPolicy = Xi), i.referrer && i.referrer !== "no-referrer" ? i[I].referrer = rs(i) : i[I].referrer = "no-referrer", i[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(n));
+  const h = Ki(n), c = {
+    // Overwrite search to retain trailing ? (issue #776)
+    path: n.pathname + h,
+    // The following options are not expressed in the URL
+    method: i.method,
+    headers: a[Symbol.for("nodejs.util.inspect.custom")](),
+    insecureHTTPParser: i.insecureHTTPParser,
+    agent: l
+  };
+  return {
+    /** @type {URL} */
+    parsedURL: n,
+    options: c
+  };
+};
+class is extends ar {
+  constructor(n, a = "aborted") {
+    super(n, a);
+  }
+}
+/*! node-domexception. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
+if (!globalThis.DOMException)
+  try {
+    const { MessageChannel: i } = require("worker_threads"), n = new i().port1, a = new ArrayBuffer();
+    n.postMessage(a, [a, a]);
+  } catch (i) {
+    i.constructor.name === "DOMException" && (globalThis.DOMException = i.constructor);
+  }
+const ss = /* @__PURE__ */ new Set(["data:", "http:", "https:"]);
+async function Oo(i, n) {
+  return new Promise((a, u) => {
+    const l = new bt(i, n), { parsedURL: h, options: c } = as(l);
+    if (!ss.has(h.protocol))
+      throw new TypeError(`node-fetch cannot load ${i}. URL scheme "${h.protocol.replace(/:$/, "")}" is not supported.`);
+    if (h.protocol === "data:") {
+      const p = Oi(l.url), j = new V(p, { headers: { "Content-Type": p.typeFull } });
+      a(j);
+      return;
+    }
+    const T = (h.protocol === "https:" ? Pi : ht).request, { signal: v } = l;
+    let _ = null;
+    const E = () => {
+      const p = new is("The operation was aborted.");
+      u(p), l.body && l.body instanceof se.Readable && l.body.destroy(p), !(!_ || !_.body) && _.body.emit("error", p);
+    };
+    if (v && v.aborted) {
+      E();
+      return;
+    }
+    const w = () => {
+      E(), W();
+    }, m = T(h.toString(), c);
+    v && v.addEventListener("abort", w);
+    const W = () => {
+      m.abort(), v && v.removeEventListener("abort", w);
+    };
+    m.on("error", (p) => {
+      u(new ie(`request to ${l.url} failed, reason: ${p.message}`, "system", p)), W();
+    }), ls(m, (p) => {
+      _ && _.body && _.body.destroy(p);
+    }), process.version < "v14" && m.on("socket", (p) => {
+      let j;
+      p.prependListener("end", () => {
+        j = p._eventsCount;
+      }), p.prependListener("close", (R) => {
+        if (_ && j < p._eventsCount && !R) {
+          const B = new Error("Premature close");
+          B.code = "ERR_STREAM_PREMATURE_CLOSE", _.body.emit("error", B);
+        }
+      });
+    }), m.on("response", (p) => {
+      m.setTimeout(0);
+      const j = Ji(p.rawHeaders);
+      if (ko(p.statusCode)) {
+        const O = j.get("Location");
+        let z = null;
+        try {
+          z = O === null ? null : new URL(O, l.url);
+        } catch {
+          if (l.redirect !== "manual") {
+            u(new ie(`uri requested responds with an invalid redirect URL: ${O}`, "invalid-redirect")), W();
+            return;
+          }
+        }
+        switch (l.redirect) {
+          case "error":
+            u(new ie(`uri requested responds with a redirect, redirect mode is set to error: ${l.url}`, "no-redirect")), W();
+            return;
+          case "manual":
+            break;
+          case "follow": {
+            if (z === null)
+              break;
+            if (l.counter >= l.follow) {
+              u(new ie(`maximum redirect reached at: ${l.url}`, "max-redirect")), W();
+              return;
+            }
+            const M = {
+              headers: new ye(l.headers),
+              follow: l.follow,
+              counter: l.counter + 1,
+              agent: l.agent,
+              compress: l.compress,
+              method: l.method,
+              body: Xr(l),
+              signal: l.signal,
+              size: l.size,
+              referrer: l.referrer,
+              referrerPolicy: l.referrerPolicy
+            };
+            if (!Ni(l.url, z) || !Hi(l.url, z))
+              for (const _t of ["authorization", "www-authenticate", "cookie", "cookie2"])
+                M.headers.delete(_t);
+            if (p.statusCode !== 303 && l.body && n.body instanceof se.Readable) {
+              u(new ie("Cannot follow redirect with body being a readable stream", "unsupported-redirect")), W();
+              return;
+            }
+            (p.statusCode === 303 || (p.statusCode === 301 || p.statusCode === 302) && l.method === "POST") && (M.method = "GET", M.body = void 0, M.headers.delete("content-length"));
+            const U = ns(j);
+            U && (M.referrerPolicy = U), a(Oo(new bt(z, M))), W();
+            return;
+          }
+          default:
+            return u(new TypeError(`Redirect option '${l.redirect}' is not a valid value of RequestRedirect`));
+        }
+      }
+      v && p.once("end", () => {
+        v.removeEventListener("abort", w);
+      });
+      let R = Ze(p, new Kt(), (O) => {
+        O && u(O);
+      });
+      process.version < "v12.10" && p.on("aborted", w);
+      const B = {
+        url: l.url,
+        status: p.statusCode,
+        statusText: p.statusMessage,
+        headers: j,
+        size: l.size,
+        counter: l.counter,
+        highWaterMark: l.highWaterMark
+      }, L = j.get("Content-Encoding");
+      if (!l.compress || l.method === "HEAD" || L === null || p.statusCode === 204 || p.statusCode === 304) {
+        _ = new V(R, B), a(_);
+        return;
+      }
+      const Y = {
+        flush: Je.Z_SYNC_FLUSH,
+        finishFlush: Je.Z_SYNC_FLUSH
+      };
+      if (L === "gzip" || L === "x-gzip") {
+        R = Ze(R, Je.createGunzip(Y), (O) => {
+          O && u(O);
+        }), _ = new V(R, B), a(_);
+        return;
+      }
+      if (L === "deflate" || L === "x-deflate") {
+        const O = Ze(p, new Kt(), (z) => {
+          z && u(z);
+        });
+        O.once("data", (z) => {
+          (z[0] & 15) === 8 ? R = Ze(R, Je.createInflate(), (M) => {
+            M && u(M);
+          }) : R = Ze(R, Je.createInflateRaw(), (M) => {
+            M && u(M);
+          }), _ = new V(R, B), a(_);
+        }), O.once("end", () => {
+          _ || (_ = new V(R, B), a(_));
+        });
+        return;
+      }
+      if (L === "br") {
+        R = Ze(R, Je.createBrotliDecompress(), (O) => {
+          O && u(O);
+        }), _ = new V(R, B), a(_);
+        return;
+      }
+      _ = new V(R, B), a(_);
+    }), Gi(m, l).catch(u);
+  });
+}
+function ls(i, n) {
+  const a = $.from(`0\r
+\r
+`);
+  let u = !1, l = !1, h;
+  i.on("response", (c) => {
+    const { headers: T } = c;
+    u = T["transfer-encoding"] === "chunked" && !T["content-length"];
+  }), i.on("socket", (c) => {
+    const T = () => {
+      if (u && !l) {
+        const _ = new Error("Premature close");
+        _.code = "ERR_STREAM_PREMATURE_CLOSE", n(_);
+      }
+    }, v = (_) => {
+      l = $.compare(_.slice(-5), a) === 0, !l && h && (l = $.compare(h.slice(-3), a.slice(0, 3)) === 0 && $.compare(_.slice(-2), a.slice(3)) === 0), h = _;
+    };
+    c.prependListener("close", T), c.on("data", v), i.on("close", () => {
+      c.removeListener("close", T), c.removeListener("data", v);
+    });
+  });
+}
+const us = "@feedmepos/mf-", Ps = async (i, { command: n, mode: a }, u = {}) => {
+  var m, W, p, j;
+  const l = JSON.parse(
+    Ti(So(process.cwd(), "package.json"), "utf-8")
+  ), h = Object.keys(l.dependencies).filter((R) => R.startsWith(us)).reduce((R, B) => (R[B] = l.dependencies[B], R), {});
+  (m = u.includeFmmfPackages) == null || m.forEach((R) => {
+    h[R] = l.dependencies[R] ?? "latest";
+  }), (W = u.excludeFmmfPackages) == null || W.forEach((R) => {
+    delete h[R];
+  });
+  const c = {
+    "@vue/devtools-api": "6.5.0/lib/esm/index.js",
+    vue: "3.4.27/dist/vue.esm-browser.prod.min.js",
+    "vue-router": "4.2.5/dist/vue-router.esm-browser.min.js",
+    pinia: "2.1.7/+esm"
+  };
+  let T = [...Object.keys(c), ...Object.keys(h)];
+  const v = { ...i };
+  n == "build" && a.startsWith("fmmf") && (T = [...Object.keys(h), ...Object.keys(c)], v.build = {
+    emptyOutDir: !0,
+    lib: {
+      entry: {
+        app: So(process.cwd(), "src/app.ts")
+      },
+      formats: ["es"]
+    },
+    rollupOptions: {
+      external: T
+    }
+  }), v.plugins ?? (v.plugins = []), v.plugins.push(qi({ externals: T })), v.build ?? (v.build = {}), (p = v.build).rollupOptions ?? (p.rollupOptions = {}), (j = v.build.rollupOptions).external ?? (j.external = T);
+  const _ = h;
+  await Promise.all(
+    Object.keys(_).map(async (R) => {
+      let B = "latest";
+      const L = u.isDev;
+      if (console.log("Use beta", L), L) {
+        const Y = await Oo(`https://cdn.jsdelivr.net/npm/${R}@beta/dist/app.js`).then((O) => O.ok).catch(() => !1);
+        console.log(`Package ${R} has beta: ${Y}`), Y && (B = "beta");
+      }
+      return _[R] = `https://cdn.jsdelivr.net/npm/${R}@${B}/dist/app.js`;
+    })
+  );
+  const E = {
+    imports: {
+      ..._,
+      ...Object.keys(c).reduce((R, B) => (R[B] = `https://cdn.jsdelivr.net/npm/${B}@${c[B]}`, R), {})
+    },
+    scopes: u.importMapScopes ?? {}
+  };
+  u.replaceFmmfPackages && Object.entries(u.replaceFmmfPackages).forEach(([R, B]) => {
+    if (R.startsWith("@feedmepos/mf-") || R === "@feedmepos/ui-library")
+      E.imports[R] = B;
+    else
+      throw new Error(`Invalid replaceFmmfPackages key: ${R}, must start with @feedmepos/mf-`);
+  });
+  const w = {
+    name: "vite-plugin-feedme-microfrontend",
+    enforce: "pre",
+    config: async () => {
+    },
+    transformIndexHtml: {
+      enforce: "pre",
+      transform(R) {
+        return {
+          html: R,
+          tags: [
+            {
+              tag: "script",
+              attrs: {
+                type: "importmap"
+              },
+              children: JSON.stringify(E, null, 2),
+              injectTo: "head-prepend"
+            },
+            {
+              tag: "script",
+              attrs: {
+                src: "https://cdn.jsdelivr.net/npm/es-module-shims@1.8.0/dist/es-module-shims.min.js"
+              },
+              injectTo: "head-prepend"
+            }
+          ]
+        };
+      }
+    }
+  };
+  return v.plugins.push(w), v;
+};
+export {
+  Zr as F,
+  Li as a,
+  Ps as f
+};