@sheetxl/studio-vanilla 0.4.21 → 0.5.0

package/browser/esm/BFweWj2oKpTGl7m3.mjs

@@ -0,0 +1,1672 @@
+/**
+ * @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.5.0
+ *
+ * (C) 2025-present SheetXL Inc. & Michael T. Ford
+ * License: The license can be found at https://www.sheetxl.com/license.
+ */
+function Pe() {
+}
+function R(e) {
+  return typeof e == "object" && e !== null || typeof e == "function";
+}
+const tr = Pe;
+function m(e, t) {
+  try {
+    Object.defineProperty(e, "name", { value: t, configurable: !0 });
+  } catch {
+  }
+}
+const St = Promise, eo = Promise.resolve.bind(St), to = Promise.prototype.then, ro = Promise.reject.bind(St), oo = eo;
+function P(e) {
+  return new St(e);
+}
+function v(e) {
+  return P((t) => t(e));
+}
+function c(e) {
+  return ro(e);
+}
+function B(e, t, r) {
+  return to.call(e, t, r);
+}
+function W(e, t, r) {
+  B(B(e, t, r), void 0, tr);
+}
+function nt(e, t) {
+  W(e, t);
+}
+function bt(e, t) {
+  W(e, void 0, t);
+}
+function ne(e, t, r) {
+  return B(e, t, r);
+}
+function Ae(e) {
+  B(e, void 0, tr);
+}
+let ie = (e) => {
+  if (typeof queueMicrotask == "function") ie = queueMicrotask;
+  else {
+    const t = v(void 0);
+    ie = (r) => B(t, r);
+  }
+  return ie(e);
+};
+function me(e, t, r) {
+  if (typeof e != "function") throw new TypeError("Argument is not a function");
+  return Function.prototype.apply.call(e, t, r);
+}
+function ge(e, t, r) {
+  try {
+    return v(me(e, t, r));
+  } catch (o) {
+    return c(o);
+  }
+}
+class j {
+  constructor() {
+    this._cursor = 0, this._size = 0, this._front = { _elements: [], _next: void 0 }, this._back = this._front, this._cursor = 0, this._size = 0;
+  }
+  get length() {
+    return this._size;
+  }
+  push(t) {
+    const r = this._back;
+    let o = r;
+    r._elements.length === 16383 && (o = { _elements: [], _next: void 0 }), r._elements.push(t), o !== r && (this._back = o, r._next = o), ++this._size;
+  }
+  shift() {
+    const t = this._front;
+    let r = t;
+    const o = this._cursor;
+    let i = o + 1;
+    const n = t._elements, s = n[o];
+    return i === 16384 && (r = t._next, i = 0), --this._size, this._cursor = i, t !== r && (this._front = r), n[o] = void 0, s;
+  }
+  forEach(t) {
+    let r = this._cursor, o = this._front, i = o._elements;
+    for (; !(r === i.length && o._next === void 0 || r === i.length && (o = o._next, i = o._elements, r = 0, i.length === 0)); ) t(i[r]), ++r;
+  }
+  peek() {
+    const t = this._front, r = this._cursor;
+    return t._elements[r];
+  }
+}
+const rr = Symbol("[[AbortSteps]]"), or = Symbol("[[ErrorSteps]]"), Rt = Symbol("[[CancelSteps]]"), Tt = Symbol("[[PullSteps]]"), qt = Symbol("[[ReleaseSteps]]");
+function nr(e, t) {
+  var r;
+  e._ownerReadableStream = t, t._reader = e, t._state === "readable" ? ht(e) : t._state === "closed" ? (ht(r = e), ar(r)) : ir(e, t._storedError);
+}
+function Et(e, t) {
+  return k(e._ownerReadableStream, t);
+}
+function L(e) {
+  const t = e._ownerReadableStream;
+  t._state === "readable" ? Pt(e, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")) : ir(e, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")), t._readableStreamController[qt](), t._reader = void 0, e._ownerReadableStream = void 0;
+}
+function He(e) {
+  return new TypeError("Cannot " + e + " a stream using a released reader");
+}
+function ht(e) {
+  e._closedPromise = P((t, r) => {
+    e._closedPromise_resolve = t, e._closedPromise_reject = r;
+  });
+}
+function ir(e, t) {
+  ht(e), Pt(e, t);
+}
+function Pt(e, t) {
+  e._closedPromise_reject !== void 0 && (Ae(e._closedPromise), e._closedPromise_reject(t), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0);
+}
+function ar(e) {
+  e._closedPromise_resolve !== void 0 && (e._closedPromise_resolve(void 0), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0);
+}
+const Mt = Number.isFinite || function(e) {
+  return typeof e == "number" && isFinite(e);
+}, no = Math.trunc || function(e) {
+  return e < 0 ? Math.ceil(e) : Math.floor(e);
+};
+function V(e, t) {
+  if (e !== void 0 && typeof (r = e) != "object" && typeof r != "function") throw new TypeError(`${t} is not an object.`);
+  var r;
+}
+function X(e, t) {
+  if (typeof e != "function") throw new TypeError(`${t} is not a function.`);
+}
+function sr(e, t) {
+  if (!/* @__PURE__ */ function(r) {
+    return typeof r == "object" && r !== null || typeof r == "function";
+  }(e)) throw new TypeError(`${t} is not an object.`);
+}
+function ae(e, t, r) {
+  if (e === void 0) throw new TypeError(`Parameter ${t} is required in '${r}'.`);
+}
+function Nt(e, t, r) {
+  if (e === void 0) throw new TypeError(`${t} is required in '${r}'.`);
+}
+function lr(e) {
+  return Number(e);
+}
+function Yt(e) {
+  return e === 0 ? 0 : e;
+}
+function Ct(e, t) {
+  const r = Number.MAX_SAFE_INTEGER;
+  let o = Number(e);
+  if (o = Yt(o), !Mt(o)) throw new TypeError(`${t} is not a finite number`);
+  if (o = Yt(no(o)), o < 0 || o > r) throw new TypeError(`${t} is outside the accepted range of 0 to ${r}, inclusive`);
+  return Mt(o) && o !== 0 ? o : 0;
+}
+function Ot(e, t) {
+  if (!D(e)) throw new TypeError(`${t} is not a ReadableStream.`);
+}
+function ce(e) {
+  return new ee(e);
+}
+function ur(e, t) {
+  e._reader._readRequests.push(t);
+}
+function At(e, t, r) {
+  const o = e._reader._readRequests.shift();
+  r ? o._closeSteps() : o._chunkSteps(t);
+}
+function Ze(e) {
+  return e._reader._readRequests.length;
+}
+function cr(e) {
+  const t = e._reader;
+  return t !== void 0 && !!U(t);
+}
+class ee {
+  constructor(t) {
+    if (ae(t, 1, "ReadableStreamDefaultReader"), Ot(t, "First parameter"), H(t)) throw new TypeError("This stream has already been locked for exclusive reading by another reader");
+    nr(this, t), this._readRequests = new j();
+  }
+  get closed() {
+    return U(this) ? this._closedPromise : c(We("closed"));
+  }
+  cancel(t = void 0) {
+    return U(this) ? this._ownerReadableStream === void 0 ? c(He("cancel")) : Et(this, t) : c(We("cancel"));
+  }
+  read() {
+    if (!U(this)) return c(We("read"));
+    if (this._ownerReadableStream === void 0) return c(He("read from"));
+    let t, r;
+    const o = P((i, n) => {
+      t = i, r = n;
+    });
+    return Ce(this, { _chunkSteps: (i) => t({ value: i, done: !1 }), _closeSteps: () => t({ value: void 0, done: !0 }), _errorSteps: (i) => r(i) }), o;
+  }
+  releaseLock() {
+    if (!U(this)) throw We("releaseLock");
+    var t;
+    this._ownerReadableStream !== void 0 && (L(t = this), dr(t, new TypeError("Reader was released")));
+  }
+}
+function U(e) {
+  return !!R(e) && !!Object.prototype.hasOwnProperty.call(e, "_readRequests") && e instanceof ee;
+}
+function Ce(e, t) {
+  const r = e._ownerReadableStream;
+  r._disturbed = !0, r._state === "closed" ? t._closeSteps() : r._state === "errored" ? t._errorSteps(r._storedError) : r._readableStreamController[Tt](t);
+}
+function dr(e, t) {
+  const r = e._readRequests;
+  e._readRequests = new j(), r.forEach((o) => {
+    o._errorSteps(t);
+  });
+}
+function We(e) {
+  return new TypeError(`ReadableStreamDefaultReader.prototype.${e} can only be used on a ReadableStreamDefaultReader`);
+}
+var it, at, st;
+function Se(e) {
+  return e.slice();
+}
+function fr(e, t, r, o, i) {
+  new Uint8Array(e).set(new Uint8Array(r, o, i), t);
+}
+Object.defineProperties(ee.prototype, { cancel: { enumerable: !0 }, read: { enumerable: !0 }, releaseLock: { enumerable: !0 }, closed: { enumerable: !0 } }), m(ee.prototype.cancel, "cancel"), m(ee.prototype.read, "read"), m(ee.prototype.releaseLock, "releaseLock"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(ee.prototype, Symbol.toStringTag, { value: "ReadableStreamDefaultReader", configurable: !0 });
+let se = (e) => (se = typeof e.transfer == "function" ? (t) => t.transfer() : typeof structuredClone == "function" ? (t) => structuredClone(t, { transfer: [t] }) : (t) => t, se(e)), le = (e) => (le = typeof e.detached == "boolean" ? (t) => t.detached : (t) => t.byteLength === 0, le(e));
+function br(e, t, r) {
+  if (e.slice) return e.slice(t, r);
+  const o = r - t, i = new ArrayBuffer(o);
+  return fr(i, 0, e, t, o), i;
+}
+function Te(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 Vt(e) {
+  try {
+    const t = e.done, r = e.value;
+    return B(oo(r), (o) => ({ done: t, value: o }));
+  } catch (t) {
+    return c(t);
+  }
+}
+const je = (st = (it = Symbol.asyncIterator) !== null && it !== void 0 ? it : (at = Symbol.for) === null || at === void 0 ? void 0 : at.call(Symbol, "Symbol.asyncIterator")) !== null && st !== void 0 ? st : "@@asyncIterator";
+function hr(e, t = "sync", r) {
+  if (r === void 0) if (t === "async") {
+    if ((r = Te(e, je)) === void 0) return function(i) {
+      const n = { next() {
+        let s;
+        try {
+          s = _r(i);
+        } catch (a) {
+          return c(a);
+        }
+        return Vt(s);
+      }, return(s) {
+        let a;
+        try {
+          const l = Te(i.iterator, "return");
+          if (l === void 0) return v({ done: !0, value: s });
+          a = me(l, i.iterator, [s]);
+        } catch (l) {
+          return c(l);
+        }
+        return R(a) ? Vt(a) : c(new TypeError("The iterator.return() method must return an object"));
+      } };
+      return { iterator: n, nextMethod: n.next, done: !1 };
+    }(hr(e, "sync", Te(e, Symbol.iterator)));
+  } else r = Te(e, Symbol.iterator);
+  if (r === void 0) throw new TypeError("The object is not iterable");
+  const o = me(r, e, []);
+  if (!R(o)) throw new TypeError("The iterator method must return an object");
+  return { iterator: o, nextMethod: o.next, done: !1 };
+}
+function _r(e) {
+  const t = me(e.nextMethod, e.iterator, []);
+  if (!R(t)) throw new TypeError("The iterator.next() method must return an object");
+  return t;
+}
+class pr {
+  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 ? ne(this._ongoingPromise, t, t) : t(), this._ongoingPromise;
+  }
+  return(t) {
+    const r = () => this._returnSteps(t);
+    return this._ongoingPromise = this._ongoingPromise ? ne(this._ongoingPromise, r, r) : r(), this._ongoingPromise;
+  }
+  _nextSteps() {
+    if (this._isFinished) return Promise.resolve({ value: void 0, done: !0 });
+    const t = this._reader;
+    let r, o;
+    const i = P((n, s) => {
+      r = n, o = s;
+    });
+    return Ce(t, { _chunkSteps: (n) => {
+      this._ongoingPromise = void 0, ie(() => r({ value: n, done: !1 }));
+    }, _closeSteps: () => {
+      this._ongoingPromise = void 0, this._isFinished = !0, L(t), r({ value: void 0, done: !0 });
+    }, _errorSteps: (n) => {
+      this._ongoingPromise = void 0, this._isFinished = !0, L(t), o(n);
+    } }), i;
+  }
+  _returnSteps(t) {
+    if (this._isFinished) return Promise.resolve({ value: t, done: !0 });
+    this._isFinished = !0;
+    const r = this._reader;
+    if (!this._preventCancel) {
+      const o = Et(r, t);
+      return L(r), ne(o, () => ({ value: t, done: !0 }));
+    }
+    return L(r), v({ value: t, done: !0 });
+  }
+}
+const mr = { next() {
+  return Ut(this) ? this._asyncIteratorImpl.next() : c(Ht("next"));
+}, return(e) {
+  return Ut(this) ? this._asyncIteratorImpl.return(e) : c(Ht("return"));
+}, [je]() {
+  return this;
+} };
+function Ut(e) {
+  if (!R(e) || !Object.prototype.hasOwnProperty.call(e, "_asyncIteratorImpl")) return !1;
+  try {
+    return e._asyncIteratorImpl instanceof pr;
+  } catch {
+    return !1;
+  }
+}
+function Ht(e) {
+  return new TypeError(`ReadableStreamAsyncIterator.${e} can only be used on a ReadableSteamAsyncIterator`);
+}
+Object.defineProperty(mr, je, { enumerable: !1 });
+const yr = Number.isNaN || function(e) {
+  return e != e;
+};
+function Gt(e) {
+  const t = br(e.buffer, e.byteOffset, e.byteOffset + e.byteLength);
+  return new Uint8Array(t);
+}
+function _t(e) {
+  const t = e._queue.shift();
+  return e._queueTotalSize -= t.size, e._queueTotalSize < 0 && (e._queueTotalSize = 0), t.value;
+}
+function jt(e, t, r) {
+  if (typeof (o = r) != "number" || yr(o) || o < 0 || r === 1 / 0) throw new RangeError("Size must be a finite, non-NaN, non-negative number.");
+  var o;
+  e._queue.push({ value: t, size: r }), e._queueTotalSize += r;
+}
+function J(e) {
+  e._queue = new j(), e._queueTotalSize = 0;
+}
+function vr(e) {
+  return e === DataView;
+}
+class be {
+  constructor() {
+    throw new TypeError("Illegal constructor");
+  }
+  get view() {
+    if (!lt(this)) throw ut("view");
+    return this._view;
+  }
+  respond(t) {
+    if (!lt(this)) throw ut("respond");
+    if (ae(t, 1, "respond"), t = Ct(t, "First parameter"), this._associatedReadableByteStreamController === void 0) throw new TypeError("This BYOB request has been invalidated");
+    if (le(this._view.buffer)) throw new TypeError("The BYOB request's buffer has been detached and so cannot be used as a response");
+    Ye(this._associatedReadableByteStreamController, t);
+  }
+  respondWithNewView(t) {
+    if (!lt(this)) throw ut("respondWithNewView");
+    if (ae(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 (le(t.buffer)) throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");
+    Ve(this._associatedReadableByteStreamController, t);
+  }
+}
+Object.defineProperties(be.prototype, { respond: { enumerable: !0 }, respondWithNewView: { enumerable: !0 }, view: { enumerable: !0 } }), m(be.prototype.respond, "respond"), m(be.prototype.respondWithNewView, "respondWithNewView"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(be.prototype, Symbol.toStringTag, { value: "ReadableStreamBYOBRequest", configurable: !0 });
+class N {
+  constructor() {
+    throw new TypeError("Illegal constructor");
+  }
+  get byobRequest() {
+    if (!te(this)) throw Re("byobRequest");
+    return mt(this);
+  }
+  get desiredSize() {
+    if (!te(this)) throw Re("desiredSize");
+    return Ar(this);
+  }
+  close() {
+    if (!te(this)) throw Re("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`);
+    qe(this);
+  }
+  enqueue(t) {
+    if (!te(this)) throw Re("enqueue");
+    if (ae(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`);
+    Ne(this, t);
+  }
+  error(t = void 0) {
+    if (!te(this)) throw Re("error");
+    A(this, t);
+  }
+  [Rt](t) {
+    wr(this), J(this);
+    const r = this._cancelAlgorithm(t);
+    return et(this), r;
+  }
+  [Tt](t) {
+    const r = this._controlledReadableByteStream;
+    if (this._queueTotalSize > 0) return void Or(this, t);
+    const o = this._autoAllocateChunkSize;
+    if (o !== void 0) {
+      let i;
+      try {
+        i = new ArrayBuffer(o);
+      } catch (s) {
+        return void t._errorSteps(s);
+      }
+      const n = { buffer: i, bufferByteLength: o, byteOffset: 0, byteLength: o, bytesFilled: 0, minimumFill: 1, elementSize: 1, viewConstructor: Uint8Array, readerType: "default" };
+      this._pendingPullIntos.push(n);
+    }
+    ur(r, t), ue(this);
+  }
+  [qt]() {
+    if (this._pendingPullIntos.length > 0) {
+      const t = this._pendingPullIntos.peek();
+      t.readerType = "none", this._pendingPullIntos = new j(), this._pendingPullIntos.push(t);
+    }
+  }
+}
+function te(e) {
+  return !!R(e) && !!Object.prototype.hasOwnProperty.call(e, "_controlledReadableByteStream") && e instanceof N;
+}
+function lt(e) {
+  return !!R(e) && !!Object.prototype.hasOwnProperty.call(e, "_associatedReadableByteStreamController") && e instanceof be;
+}
+function ue(e) {
+  (function(t) {
+    const r = t._controlledReadableByteStream;
+    return !(r._state !== "readable" || t._closeRequested || !t._started) && (!!(cr(r) && Ze(r) > 0 || Wt(r) && kr(r) > 0) || Ar(t) > 0);
+  })(e) && (e._pulling ? e._pullAgain = !0 : (e._pulling = !0, W(e._pullAlgorithm(), () => (e._pulling = !1, e._pullAgain && (e._pullAgain = !1, ue(e)), null), (t) => (A(e, t), null))));
+}
+function wr(e) {
+  kt(e), e._pendingPullIntos = new j();
+}
+function gr(e, t) {
+  let r = !1;
+  e._state === "closed" && (r = !0);
+  const o = Sr(t);
+  t.readerType === "default" ? At(e, o, r) : function(i, n, s) {
+    const a = i._reader._readIntoRequests.shift();
+    s ? a._closeSteps(n) : a._chunkSteps(n);
+  }(e, o, r);
+}
+function De(e, t) {
+  for (let r = 0; r < t.length; ++r) gr(e, t[r]);
+}
+function Sr(e) {
+  const t = e.bytesFilled, r = e.elementSize;
+  return new e.viewConstructor(e.buffer, e.byteOffset, t / r);
+}
+function Me(e, t, r, o) {
+  e._queue.push({ buffer: t, byteOffset: r, byteLength: o }), e._queueTotalSize += o;
+}
+function Rr(e, t, r, o) {
+  let i;
+  try {
+    i = br(t, r, r + o);
+  } catch (n) {
+    throw A(e, n), n;
+  }
+  Me(e, i, 0, o);
+}
+function Tr(e, t) {
+  t.bytesFilled > 0 && Rr(e, t.buffer, t.byteOffset, t.bytesFilled), _e(e);
+}
+function qr(e, t) {
+  const r = Math.min(e._queueTotalSize, t.byteLength - t.bytesFilled), o = t.bytesFilled + r;
+  let i = r, n = !1;
+  const s = o - o % t.elementSize;
+  s >= t.minimumFill && (i = s - t.bytesFilled, n = !0);
+  const a = e._queue;
+  for (; i > 0; ) {
+    const l = a.peek(), u = Math.min(i, l.byteLength), h = t.byteOffset + t.bytesFilled;
+    fr(t.buffer, h, l.buffer, l.byteOffset, u), l.byteLength === u ? a.shift() : (l.byteOffset += u, l.byteLength -= u), e._queueTotalSize -= u, Er(e, u, t), i -= u;
+  }
+  return n;
+}
+function Er(e, t, r) {
+  r.bytesFilled += t;
+}
+function Pr(e) {
+  e._queueTotalSize === 0 && e._closeRequested ? (et(e), ke(e._controlledReadableByteStream)) : ue(e);
+}
+function kt(e) {
+  e._byobRequest !== null && (e._byobRequest._associatedReadableByteStreamController = void 0, e._byobRequest._view = null, e._byobRequest = null);
+}
+function pt(e) {
+  const t = [];
+  for (; e._pendingPullIntos.length > 0 && e._queueTotalSize !== 0; ) {
+    const r = e._pendingPullIntos.peek();
+    qr(e, r) && (_e(e), t.push(r));
+  }
+  return t;
+}
+function Cr(e, t) {
+  const r = e._pendingPullIntos.peek();
+  kt(e), e._controlledReadableByteStream._state === "closed" ? function(o, i) {
+    i.readerType === "none" && _e(o);
+    const n = o._controlledReadableByteStream;
+    if (Wt(n)) {
+      const s = [];
+      for (let a = 0; a < kr(n); ++a) s.push(_e(o));
+      De(n, s);
+    }
+  }(e, r) : function(o, i, n) {
+    if (Er(0, i, n), n.readerType === "none") {
+      Tr(o, n);
+      const l = pt(o);
+      return void De(o._controlledReadableByteStream, l);
+    }
+    if (n.bytesFilled < n.minimumFill) return;
+    _e(o);
+    const s = n.bytesFilled % n.elementSize;
+    if (s > 0) {
+      const l = n.byteOffset + n.bytesFilled;
+      Rr(o, n.buffer, l - s, s);
+    }
+    n.bytesFilled -= s;
+    const a = pt(o);
+    gr(o._controlledReadableByteStream, n), De(o._controlledReadableByteStream, a);
+  }(e, t, r), ue(e);
+}
+function _e(e) {
+  return e._pendingPullIntos.shift();
+}
+function et(e) {
+  e._pullAlgorithm = void 0, e._cancelAlgorithm = void 0;
+}
+function qe(e) {
+  const t = e._controlledReadableByteStream;
+  if (!e._closeRequested && t._state === "readable") if (e._queueTotalSize > 0) e._closeRequested = !0;
+  else {
+    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 A(e, o), o;
+      }
+    }
+    et(e), ke(t);
+  }
+}
+function Ne(e, t) {
+  const r = e._controlledReadableByteStream;
+  if (e._closeRequested || r._state !== "readable") return;
+  const { buffer: o, byteOffset: i, byteLength: n } = t;
+  if (le(o)) throw new TypeError("chunk's buffer is detached and so cannot be enqueued");
+  const s = se(o);
+  if (e._pendingPullIntos.length > 0) {
+    const a = e._pendingPullIntos.peek();
+    if (le(a.buffer)) throw new TypeError("The BYOB request's buffer has been detached and so cannot be filled with an enqueued chunk");
+    kt(e), a.buffer = se(a.buffer), a.readerType === "none" && Tr(e, a);
+  }
+  if (cr(r)) (function(a) {
+    const l = a._controlledReadableByteStream._reader;
+    for (; l._readRequests.length > 0; ) {
+      if (a._queueTotalSize === 0) return;
+      Or(a, l._readRequests.shift());
+    }
+  })(e), Ze(r) === 0 ? Me(e, s, i, n) : (e._pendingPullIntos.length > 0 && _e(e), At(r, new Uint8Array(s, i, n), !1));
+  else if (Wt(r)) {
+    Me(e, s, i, n);
+    const a = pt(e);
+    De(e._controlledReadableByteStream, a);
+  } else Me(e, s, i, n);
+  ue(e);
+}
+function A(e, t) {
+  const r = e._controlledReadableByteStream;
+  r._state === "readable" && (wr(e), J(e), et(e), Qr(r, t));
+}
+function Or(e, t) {
+  const r = e._queue.shift();
+  e._queueTotalSize -= r.byteLength, Pr(e);
+  const o = new Uint8Array(r.buffer, r.byteOffset, r.byteLength);
+  t._chunkSteps(o);
+}
+function mt(e) {
+  if (e._byobRequest === null && e._pendingPullIntos.length > 0) {
+    const i = e._pendingPullIntos.peek(), n = new Uint8Array(i.buffer, i.byteOffset + i.bytesFilled, i.byteLength - i.bytesFilled), s = Object.create(be.prototype);
+    r = e, o = n, (t = s)._associatedReadableByteStreamController = r, t._view = o, e._byobRequest = s;
+  }
+  var t, r, o;
+  return e._byobRequest;
+}
+function Ar(e) {
+  const t = e._controlledReadableByteStream._state;
+  return t === "errored" ? null : t === "closed" ? 0 : e._strategyHWM - e._queueTotalSize;
+}
+function Ye(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 = se(r.buffer), Cr(e, t);
+}
+function Ve(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 o = t.byteLength;
+  r.buffer = se(t.buffer), Cr(e, o);
+}
+function jr(e, t, r, o, i, n, s) {
+  t._controlledReadableByteStream = e, t._pullAgain = !1, t._pulling = !1, t._byobRequest = null, t._queue = t._queueTotalSize = void 0, J(t), t._closeRequested = !1, t._started = !1, t._strategyHWM = n, t._pullAlgorithm = o, t._cancelAlgorithm = i, t._autoAllocateChunkSize = s, t._pendingPullIntos = new j(), e._readableStreamController = t, W(v(r()), () => (t._started = !0, ue(t), null), (a) => (A(t, a), null));
+}
+function ut(e) {
+  return new TypeError(`ReadableStreamBYOBRequest.prototype.${e} can only be used on a ReadableStreamBYOBRequest`);
+}
+function Re(e) {
+  return new TypeError(`ReadableByteStreamController.prototype.${e} can only be used on a ReadableByteStreamController`);
+}
+function io(e, t) {
+  if ((e = `${e}`) != "byob") throw new TypeError(`${t} '${e}' is not a valid enumeration value for ReadableStreamReaderMode`);
+  return e;
+}
+function Xt(e) {
+  return new re(e);
+}
+function Jt(e, t) {
+  e._reader._readIntoRequests.push(t);
+}
+function kr(e) {
+  return e._reader._readIntoRequests.length;
+}
+function Wt(e) {
+  const t = e._reader;
+  return t !== void 0 && !!oe(t);
+}
+Object.defineProperties(N.prototype, { close: { enumerable: !0 }, enqueue: { enumerable: !0 }, error: { enumerable: !0 }, byobRequest: { enumerable: !0 }, desiredSize: { enumerable: !0 } }), m(N.prototype.close, "close"), m(N.prototype.enqueue, "enqueue"), m(N.prototype.error, "error"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(N.prototype, Symbol.toStringTag, { value: "ReadableByteStreamController", configurable: !0 });
+class re {
+  constructor(t) {
+    if (ae(t, 1, "ReadableStreamBYOBReader"), Ot(t, "First parameter"), H(t)) throw new TypeError("This stream has already been locked for exclusive reading by another reader");
+    if (!te(t._readableStreamController)) throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");
+    nr(this, t), this._readIntoRequests = new j();
+  }
+  get closed() {
+    return oe(this) ? this._closedPromise : c(ze("closed"));
+  }
+  cancel(t = void 0) {
+    return oe(this) ? this._ownerReadableStream === void 0 ? c(He("cancel")) : Et(this, t) : c(ze("cancel"));
+  }
+  read(t, r = {}) {
+    if (!oe(this)) return c(ze("read"));
+    if (!ArrayBuffer.isView(t)) return c(new TypeError("view must be an array buffer view"));
+    if (t.byteLength === 0) return c(new TypeError("view must have non-zero byteLength"));
+    if (t.buffer.byteLength === 0) return c(new TypeError("view's buffer must have non-zero byteLength"));
+    if (le(t.buffer)) return c(new TypeError("view's buffer has been detached"));
+    let o;
+    try {
+      V(i = r, n = "options"), o = { min: Ct((s = i?.min) !== null && s !== void 0 ? s : 1, `${n} has member 'min' that`) };
+    } catch (f) {
+      return c(f);
+    }
+    var i, n, s;
+    const a = o.min;
+    if (a === 0) return c(new TypeError("options.min must be greater than 0"));
+    if (function(f) {
+      return vr(f.constructor);
+    }(t)) {
+      if (a > t.byteLength) return c(new RangeError("options.min must be less than or equal to view's byteLength"));
+    } else if (a > t.length) return c(new RangeError("options.min must be less than or equal to view's length"));
+    if (this._ownerReadableStream === void 0) return c(He("read from"));
+    let l, u;
+    const h = P((f, b) => {
+      l = f, u = b;
+    });
+    return Wr(this, t, a, { _chunkSteps: (f) => l({ value: f, done: !1 }), _closeSteps: (f) => l({ value: f, done: !0 }), _errorSteps: (f) => u(f) }), h;
+  }
+  releaseLock() {
+    if (!oe(this)) throw ze("releaseLock");
+    var t;
+    this._ownerReadableStream !== void 0 && (L(t = this), zr(t, new TypeError("Reader was released")));
+  }
+}
+function oe(e) {
+  return !!R(e) && !!Object.prototype.hasOwnProperty.call(e, "_readIntoRequests") && e instanceof re;
+}
+function Wr(e, t, r, o) {
+  const i = e._ownerReadableStream;
+  i._disturbed = !0, i._state === "errored" ? o._errorSteps(i._storedError) : function(n, s, a, l) {
+    const u = n._controlledReadableByteStream, h = s.constructor, f = vr(q = h) ? 1 : q.BYTES_PER_ELEMENT, { byteOffset: b, byteLength: w } = s, T = a * f;
+    var q;
+    let y;
+    try {
+      y = se(s.buffer);
+    } catch (g) {
+      return void l._errorSteps(g);
+    }
+    const _ = { buffer: y, bufferByteLength: y.byteLength, byteOffset: b, byteLength: w, bytesFilled: 0, minimumFill: T, elementSize: f, viewConstructor: h, readerType: "byob" };
+    if (n._pendingPullIntos.length > 0) return n._pendingPullIntos.push(_), void Jt(u, l);
+    if (u._state !== "closed") {
+      if (n._queueTotalSize > 0) {
+        if (qr(n, _)) {
+          const g = Sr(_);
+          return Pr(n), void l._chunkSteps(g);
+        }
+        if (n._closeRequested) {
+          const g = new TypeError("Insufficient bytes to fill elements in the given buffer");
+          return A(n, g), void l._errorSteps(g);
+        }
+      }
+      n._pendingPullIntos.push(_), Jt(u, l), ue(n);
+    } else {
+      const g = new h(_.buffer, _.byteOffset, 0);
+      l._closeSteps(g);
+    }
+  }(i._readableStreamController, t, r, o);
+}
+function zr(e, t) {
+  const r = e._readIntoRequests;
+  e._readIntoRequests = new j(), r.forEach((o) => {
+    o._errorSteps(t);
+  });
+}
+function ze(e) {
+  return new TypeError(`ReadableStreamBYOBReader.prototype.${e} can only be used on a ReadableStreamBYOBReader`);
+}
+function yt(e, t) {
+  const { highWaterMark: r } = e;
+  if (r === void 0) return t;
+  if (yr(r) || r < 0) throw new RangeError("Invalid highWaterMark");
+  return r;
+}
+function Br(e) {
+  const { size: t } = e;
+  return t || (() => 1);
+}
+function Fr(e, t) {
+  V(e, t);
+  const r = e?.highWaterMark, o = e?.size;
+  return { highWaterMark: r === void 0 ? void 0 : lr(r), size: o === void 0 ? void 0 : ao(o, `${t} has member 'size' that`) };
+}
+function ao(e, t) {
+  return X(e, t), (r) => lr(e(r));
+}
+function so(e, t, r) {
+  return X(e, r), (o) => ge(e, t, [o]);
+}
+function lo(e, t, r) {
+  return X(e, r), () => ge(e, t, []);
+}
+function uo(e, t, r) {
+  return X(e, r), (o) => me(e, t, [o]);
+}
+function co(e, t, r) {
+  return X(e, r), (o, i) => ge(e, t, [o, i]);
+}
+function Ir(e, t) {
+  if (!he(e)) throw new TypeError(`${t} is not a WritableStream.`);
+}
+Object.defineProperties(re.prototype, { cancel: { enumerable: !0 }, read: { enumerable: !0 }, releaseLock: { enumerable: !0 }, closed: { enumerable: !0 } }), m(re.prototype.cancel, "cancel"), m(re.prototype.read, "read"), m(re.prototype.releaseLock, "releaseLock"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(re.prototype, Symbol.toStringTag, { value: "ReadableStreamBYOBReader", configurable: !0 });
+class de {
+  constructor(t = {}, r = {}) {
+    t === void 0 ? t = null : sr(t, "First parameter");
+    const o = Fr(r, "Second parameter"), i = function(a, l) {
+      V(a, l);
+      const u = a?.abort, h = a?.close, f = a?.start, b = a?.type, w = a?.write;
+      return { abort: u === void 0 ? void 0 : so(u, a, `${l} has member 'abort' that`), close: h === void 0 ? void 0 : lo(h, a, `${l} has member 'close' that`), start: f === void 0 ? void 0 : uo(f, a, `${l} has member 'start' that`), write: w === void 0 ? void 0 : co(w, a, `${l} has member 'write' that`), type: b };
+    }(t, "First parameter");
+    if ((n = this)._state = "writable", n._storedError = void 0, n._writer = void 0, n._writableStreamController = void 0, n._writeRequests = new j(), n._inFlightWriteRequest = void 0, n._closeRequest = void 0, n._inFlightCloseRequest = void 0, n._pendingAbortRequest = void 0, n._backpressure = !1, i.type !== void 0) throw new RangeError("Invalid type is specified");
+    var n;
+    const s = Br(o);
+    (function(a, l, u, h) {
+      const f = Object.create(Xe.prototype);
+      let b, w, T, q;
+      b = l.start !== void 0 ? () => l.start(f) : () => {
+      }, w = l.write !== void 0 ? (y) => l.write(y, f) : () => v(void 0), T = l.close !== void 0 ? () => l.close() : () => v(void 0), q = l.abort !== void 0 ? (y) => l.abort(y) : () => v(void 0), function(y, _, g, z, I, d, p, S) {
+        _._controlledWritableStream = y, y._writableStreamController = _, _._queue = void 0, _._queueTotalSize = void 0, J(_), _._abortReason = void 0, _._abortController = function() {
+          if (typeof AbortController == "function") return new AbortController();
+        }(), _._started = !1, _._strategySizeAlgorithm = S, _._strategyHWM = p, _._writeAlgorithm = z, _._closeAlgorithm = I, _._abortAlgorithm = d;
+        const E = It(_);
+        Ft(y, E), W(v(g()), () => (_._started = !0, tt(_), null), (O) => (_._started = !0, vt(y, O), null));
+      }(a, f, b, w, T, q, u, h);
+    })(this, i, yt(o, 1), s);
+  }
+  get locked() {
+    if (!he(this)) throw Fe("locked");
+    return pe(this);
+  }
+  abort(t = void 0) {
+    return he(this) ? pe(this) ? c(new TypeError("Cannot abort a stream that already has a writer")) : Ge(this, t) : c(Fe("abort"));
+  }
+  close() {
+    return he(this) ? pe(this) ? c(new TypeError("Cannot close a stream that already has a writer")) : F(this) ? c(new TypeError("Cannot close an already-closing stream")) : $r(this) : c(Fe("close"));
+  }
+  getWriter() {
+    if (!he(this)) throw Fe("getWriter");
+    return Lr(this);
+  }
+}
+function Lr(e) {
+  return new M(e);
+}
+function he(e) {
+  return !!R(e) && !!Object.prototype.hasOwnProperty.call(e, "_writableStreamController") && e instanceof de;
+}
+function pe(e) {
+  return e._writer !== void 0;
+}
+function Ge(e, t) {
+  var r;
+  if (e._state === "closed" || e._state === "errored") return v(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 v(void 0);
+  if (e._pendingAbortRequest !== void 0) return e._pendingAbortRequest._promise;
+  let i = !1;
+  o === "erroring" && (i = !0, t = void 0);
+  const n = P((s, a) => {
+    e._pendingAbortRequest = { _promise: void 0, _resolve: s, _reject: a, _reason: t, _wasAlreadyErroring: i };
+  });
+  return e._pendingAbortRequest._promise = n, i || zt(e, t), n;
+}
+function $r(e) {
+  const t = e._state;
+  if (t === "closed" || t === "errored") return c(new TypeError(`The stream (in ${t} state) is not in the writable state and cannot be closed`));
+  const r = P((n, s) => {
+    const a = { _resolve: n, _reject: s };
+    e._closeRequest = a;
+  }), o = e._writer;
+  var i;
+  return o !== void 0 && e._backpressure && t === "writable" && $t(o), jt(i = e._writableStreamController, Yr, 0), tt(i), r;
+}
+function vt(e, t) {
+  e._state !== "writable" ? Bt(e) : zt(e, t);
+}
+function zt(e, t) {
+  const r = e._writableStreamController;
+  e._state = "erroring", e._storedError = t;
+  const o = e._writer;
+  var i;
+  o !== void 0 && Dr(o, t), (i = e)._inFlightWriteRequest === void 0 && i._inFlightCloseRequest === void 0 && r._started && Bt(e);
+}
+function Bt(e) {
+  e._state = "errored", e._writableStreamController[or]();
+  const t = e._storedError;
+  if (e._writeRequests.forEach((o) => {
+    o._reject(t);
+  }), e._writeRequests = new j(), e._pendingAbortRequest === void 0) return void Be(e);
+  const r = e._pendingAbortRequest;
+  if (e._pendingAbortRequest = void 0, r._wasAlreadyErroring) return r._reject(t), void Be(e);
+  W(e._writableStreamController[rr](r._reason), () => (r._resolve(), Be(e), null), (o) => (r._reject(o), Be(e), null));
+}
+function F(e) {
+  return e._closeRequest !== void 0 || e._inFlightCloseRequest !== void 0;
+}
+function Be(e) {
+  e._closeRequest !== void 0 && (e._closeRequest._reject(e._storedError), e._closeRequest = void 0);
+  const t = e._writer;
+  t !== void 0 && Lt(t, e._storedError);
+}
+function Ft(e, t) {
+  const r = e._writer;
+  r !== void 0 && t !== e._backpressure && (t ? rt(r) : $t(r)), e._backpressure = t;
+}
+Object.defineProperties(de.prototype, { abort: { enumerable: !0 }, close: { enumerable: !0 }, getWriter: { enumerable: !0 }, locked: { enumerable: !0 } }), m(de.prototype.abort, "abort"), m(de.prototype.close, "close"), m(de.prototype.getWriter, "getWriter"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(de.prototype, Symbol.toStringTag, { value: "WritableStream", configurable: !0 });
+class M {
+  constructor(t) {
+    if (ae(t, 1, "WritableStreamDefaultWriter"), Ir(t, "First parameter"), pe(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") !F(t) && t._backpressure ? rt(this) : Kt(this), Ue(this);
+    else if (r === "erroring") gt(this, t._storedError), Ue(this);
+    else if (r === "closed") Kt(this), Ue(this), Gr(this);
+    else {
+      const o = t._storedError;
+      gt(this, o), Hr(this, o);
+    }
+  }
+  get closed() {
+    return K(this) ? this._closedPromise : c(Q("closed"));
+  }
+  get desiredSize() {
+    if (!K(this)) throw Q("desiredSize");
+    if (this._ownerWritableStream === void 0) throw Ee("desiredSize");
+    return function(t) {
+      const r = t._ownerWritableStream, o = r._state;
+      return o === "errored" || o === "erroring" ? null : o === "closed" ? 0 : Vr(r._writableStreamController);
+    }(this);
+  }
+  get ready() {
+    return K(this) ? this._readyPromise : c(Q("ready"));
+  }
+  abort(t = void 0) {
+    return K(this) ? this._ownerWritableStream === void 0 ? c(Ee("abort")) : (r = t, Ge(this._ownerWritableStream, r)) : c(Q("abort"));
+    var r;
+  }
+  close() {
+    if (!K(this)) return c(Q("close"));
+    const t = this._ownerWritableStream;
+    return t === void 0 ? c(Ee("close")) : F(t) ? c(new TypeError("Cannot close an already-closing stream")) : xr(this);
+  }
+  releaseLock() {
+    if (!K(this)) throw Q("releaseLock");
+    this._ownerWritableStream !== void 0 && Mr(this);
+  }
+  write(t = void 0) {
+    return K(this) ? this._ownerWritableStream === void 0 ? c(Ee("write to")) : Nr(this, t) : c(Q("write"));
+  }
+}
+function K(e) {
+  return !!R(e) && !!Object.prototype.hasOwnProperty.call(e, "_ownerWritableStream") && e instanceof M;
+}
+function xr(e) {
+  return $r(e._ownerWritableStream);
+}
+function Dr(e, t) {
+  e._readyPromiseState === "pending" ? Xr(e, t) : gt(e, t);
+}
+function Mr(e) {
+  const t = e._ownerWritableStream, r = new TypeError("Writer was released and can no longer be used to monitor the stream's closedness");
+  var o, i;
+  Dr(e, r), i = r, (o = e)._closedPromiseState === "pending" ? Lt(o, i) : Hr(o, i), t._writer = void 0, e._ownerWritableStream = void 0;
+}
+function Nr(e, t) {
+  const r = e._ownerWritableStream, o = r._writableStreamController, i = function(l, u) {
+    if (l._strategySizeAlgorithm === void 0) return 1;
+    try {
+      return l._strategySizeAlgorithm(u);
+    } catch (h) {
+      return wt(l, h), 1;
+    }
+  }(o, t);
+  if (r !== e._ownerWritableStream) return c(Ee("write to"));
+  const n = r._state;
+  if (n === "errored") return c(r._storedError);
+  if (F(r) || n === "closed") return c(new TypeError("The stream is closing or closed and cannot be written to"));
+  if (n === "erroring") return c(r._storedError);
+  const s = (a = r, P((l, u) => {
+    const h = { _resolve: l, _reject: u };
+    a._writeRequests.push(h);
+  }));
+  var a;
+  return function(l, u, h) {
+    try {
+      jt(l, u, h);
+    } catch (b) {
+      return void wt(l, b);
+    }
+    const f = l._controlledWritableStream;
+    F(f) || f._state !== "writable" || Ft(f, It(l)), tt(l);
+  }(o, t, i), s;
+}
+Object.defineProperties(M.prototype, { abort: { enumerable: !0 }, close: { enumerable: !0 }, releaseLock: { enumerable: !0 }, write: { enumerable: !0 }, closed: { enumerable: !0 }, desiredSize: { enumerable: !0 }, ready: { enumerable: !0 } }), m(M.prototype.abort, "abort"), m(M.prototype.close, "close"), m(M.prototype.releaseLock, "releaseLock"), m(M.prototype.write, "write"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(M.prototype, Symbol.toStringTag, { value: "WritableStreamDefaultWriter", configurable: !0 });
+const Yr = {};
+class Xe {
+  constructor() {
+    throw new TypeError("Illegal constructor");
+  }
+  get abortReason() {
+    if (!ct(this)) throw dt("abortReason");
+    return this._abortReason;
+  }
+  get signal() {
+    if (!ct(this)) throw dt("signal");
+    if (this._abortController === void 0) throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported");
+    return this._abortController.signal;
+  }
+  error(t = void 0) {
+    if (!ct(this)) throw dt("error");
+    this._controlledWritableStream._state === "writable" && Ur(this, t);
+  }
+  [rr](t) {
+    const r = this._abortAlgorithm(t);
+    return Je(this), r;
+  }
+  [or]() {
+    J(this);
+  }
+}
+function ct(e) {
+  return !!R(e) && !!Object.prototype.hasOwnProperty.call(e, "_controlledWritableStream") && e instanceof Xe;
+}
+function Je(e) {
+  e._writeAlgorithm = void 0, e._closeAlgorithm = void 0, e._abortAlgorithm = void 0, e._strategySizeAlgorithm = void 0;
+}
+function Vr(e) {
+  return e._strategyHWM - e._queueTotalSize;
+}
+function tt(e) {
+  const t = e._controlledWritableStream;
+  if (!e._started || t._inFlightWriteRequest !== void 0) return;
+  if (t._state === "erroring") return void Bt(t);
+  if (e._queue.length === 0) return;
+  const r = e._queue.peek().value;
+  r === Yr ? function(o) {
+    const i = o._controlledWritableStream;
+    var n;
+    (n = i)._inFlightCloseRequest = n._closeRequest, n._closeRequest = void 0, _t(o);
+    const s = o._closeAlgorithm();
+    Je(o), W(s, () => (function(a) {
+      a._inFlightCloseRequest._resolve(void 0), a._inFlightCloseRequest = void 0, a._state === "erroring" && (a._storedError = void 0, a._pendingAbortRequest !== void 0 && (a._pendingAbortRequest._resolve(), a._pendingAbortRequest = void 0)), a._state = "closed";
+      const l = a._writer;
+      l !== void 0 && Gr(l);
+    }(i), null), (a) => {
+      return u = a, (l = i)._inFlightCloseRequest._reject(u), l._inFlightCloseRequest = void 0, l._pendingAbortRequest !== void 0 && (l._pendingAbortRequest._reject(u), l._pendingAbortRequest = void 0), vt(l, u), null;
+      var l, u;
+    });
+  }(e) : function(o, i) {
+    const n = o._controlledWritableStream;
+    var s;
+    (s = n)._inFlightWriteRequest = s._writeRequests.shift(), W(o._writeAlgorithm(i), () => {
+      var a;
+      (a = n)._inFlightWriteRequest._resolve(void 0), a._inFlightWriteRequest = void 0;
+      const l = n._state;
+      if (_t(o), !F(n) && l === "writable") {
+        const u = It(o);
+        Ft(n, u);
+      }
+      return tt(o), null;
+    }, (a) => {
+      return n._state === "writable" && Je(o), u = a, (l = n)._inFlightWriteRequest._reject(u), l._inFlightWriteRequest = void 0, vt(l, u), null;
+      var l, u;
+    });
+  }(e, r);
+}
+function wt(e, t) {
+  e._controlledWritableStream._state === "writable" && Ur(e, t);
+}
+function It(e) {
+  return Vr(e) <= 0;
+}
+function Ur(e, t) {
+  const r = e._controlledWritableStream;
+  Je(e), zt(r, t);
+}
+function Fe(e) {
+  return new TypeError(`WritableStream.prototype.${e} can only be used on a WritableStream`);
+}
+function dt(e) {
+  return new TypeError(`WritableStreamDefaultController.prototype.${e} can only be used on a WritableStreamDefaultController`);
+}
+function Q(e) {
+  return new TypeError(`WritableStreamDefaultWriter.prototype.${e} can only be used on a WritableStreamDefaultWriter`);
+}
+function Ee(e) {
+  return new TypeError("Cannot " + e + " a stream using a released writer");
+}
+function Ue(e) {
+  e._closedPromise = P((t, r) => {
+    e._closedPromise_resolve = t, e._closedPromise_reject = r, e._closedPromiseState = "pending";
+  });
+}
+function Hr(e, t) {
+  Ue(e), Lt(e, t);
+}
+function Lt(e, t) {
+  e._closedPromise_reject !== void 0 && (Ae(e._closedPromise), e._closedPromise_reject(t), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0, e._closedPromiseState = "rejected");
+}
+function Gr(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 rt(e) {
+  e._readyPromise = P((t, r) => {
+    e._readyPromise_resolve = t, e._readyPromise_reject = r;
+  }), e._readyPromiseState = "pending";
+}
+function gt(e, t) {
+  rt(e), Xr(e, t);
+}
+function Kt(e) {
+  rt(e), $t(e);
+}
+function Xr(e, t) {
+  e._readyPromise_reject !== void 0 && (Ae(e._readyPromise), e._readyPromise_reject(t), e._readyPromise_resolve = void 0, e._readyPromise_reject = void 0, e._readyPromiseState = "rejected");
+}
+function $t(e) {
+  e._readyPromise_resolve !== void 0 && (e._readyPromise_resolve(void 0), e._readyPromise_resolve = void 0, e._readyPromise_reject = void 0, e._readyPromiseState = "fulfilled");
+}
+Object.defineProperties(Xe.prototype, { abortReason: { enumerable: !0 }, signal: { enumerable: !0 }, error: { enumerable: !0 } }), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(Xe.prototype, Symbol.toStringTag, { value: "WritableStreamDefaultController", configurable: !0 });
+const fo = typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : typeof global < "u" ? global : void 0, bo = function() {
+  const e = fo?.DOMException;
+  return function(t) {
+    if (typeof t != "function" && typeof t != "object" || t.name !== "DOMException") return !1;
+    try {
+      return new t(), !0;
+    } catch {
+      return !1;
+    }
+  }(e) ? e : void 0;
+}() || function() {
+  const e = function(t, r) {
+    this.message = t || "", this.name = r || "Error", Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
+  };
+  return m(e, "DOMException"), e.prototype = Object.create(Error.prototype), Object.defineProperty(e.prototype, "constructor", { value: e, writable: !0, configurable: !0 }), e;
+}();
+function Qt(e, t, r, o, i, n) {
+  const s = ce(e), a = Lr(t);
+  e._disturbed = !0;
+  let l = !1, u = v(void 0);
+  return P((h, f) => {
+    let b;
+    if (n !== void 0) {
+      if (b = () => {
+        const d = n.reason !== void 0 ? n.reason : new bo("Aborted", "AbortError"), p = [];
+        o || p.push(() => t._state === "writable" ? Ge(t, d) : v(void 0)), i || p.push(() => e._state === "readable" ? k(e, d) : v(void 0)), g(() => Promise.all(p.map((S) => S())), !0, d);
+      }, n.aborted) return void b();
+      n.addEventListener("abort", b);
+    }
+    var w, T, q;
+    if (_(e, s._closedPromise, (d) => (o ? z(!0, d) : g(() => Ge(t, d), !0, d), null)), _(t, a._closedPromise, (d) => (i ? z(!0, d) : g(() => k(e, d), !0, d), null)), w = e, T = s._closedPromise, q = () => (r ? z() : g(() => function(d) {
+      const p = d._ownerWritableStream, S = p._state;
+      return F(p) || S === "closed" ? v(void 0) : S === "errored" ? c(p._storedError) : xr(d);
+    }(a)), null), w._state === "closed" ? q() : nt(T, q), F(t) || t._state === "closed") {
+      const d = new TypeError("the destination writable stream closed before all data could be piped to it");
+      i ? z(!0, d) : g(() => k(e, d), !0, d);
+    }
+    function y() {
+      const d = u;
+      return B(u, () => d !== u ? y() : void 0);
+    }
+    function _(d, p, S) {
+      d._state === "errored" ? S(d._storedError) : bt(p, S);
+    }
+    function g(d, p, S) {
+      function E() {
+        return W(d(), () => I(p, S), (O) => I(!0, O)), null;
+      }
+      l || (l = !0, t._state !== "writable" || F(t) ? E() : nt(y(), E));
+    }
+    function z(d, p) {
+      l || (l = !0, t._state !== "writable" || F(t) ? I(d, p) : nt(y(), () => I(d, p)));
+    }
+    function I(d, p) {
+      return Mr(a), L(s), n !== void 0 && n.removeEventListener("abort", b), d ? f(p) : h(void 0), null;
+    }
+    Ae(P((d, p) => {
+      (function S(E) {
+        E ? d() : B(l ? v(!0) : B(a._readyPromise, () => P((O, $) => {
+          Ce(s, { _chunkSteps: (x) => {
+            u = B(Nr(a, x), void 0, Pe), O(!1);
+          }, _closeSteps: () => O(!0), _errorSteps: $ });
+        })), S, p);
+      })(!1);
+    }));
+  });
+}
+class Y {
+  constructor() {
+    throw new TypeError("Illegal constructor");
+  }
+  get desiredSize() {
+    if (!Ie(this)) throw Le("desiredSize");
+    return xt(this);
+  }
+  close() {
+    if (!Ie(this)) throw Le("close");
+    if (!we(this)) throw new TypeError("The stream is not in a state that permits close");
+    ye(this);
+  }
+  enqueue(t = void 0) {
+    if (!Ie(this)) throw Le("enqueue");
+    if (!we(this)) throw new TypeError("The stream is not in a state that permits enqueue");
+    return ve(this, t);
+  }
+  error(t = void 0) {
+    if (!Ie(this)) throw Le("error");
+    G(this, t);
+  }
+  [Rt](t) {
+    J(this);
+    const r = this._cancelAlgorithm(t);
+    return Ke(this), r;
+  }
+  [Tt](t) {
+    const r = this._controlledReadableStream;
+    if (this._queue.length > 0) {
+      const o = _t(this);
+      this._closeRequested && this._queue.length === 0 ? (Ke(this), ke(r)) : Oe(this), t._chunkSteps(o);
+    } else ur(r, t), Oe(this);
+  }
+  [qt]() {
+  }
+}
+function Ie(e) {
+  return !!R(e) && !!Object.prototype.hasOwnProperty.call(e, "_controlledReadableStream") && e instanceof Y;
+}
+function Oe(e) {
+  Jr(e) && (e._pulling ? e._pullAgain = !0 : (e._pulling = !0, W(e._pullAlgorithm(), () => (e._pulling = !1, e._pullAgain && (e._pullAgain = !1, Oe(e)), null), (t) => (G(e, t), null))));
+}
+function Jr(e) {
+  const t = e._controlledReadableStream;
+  return !!we(e) && !!e._started && (!!(H(t) && Ze(t) > 0) || xt(e) > 0);
+}
+function Ke(e) {
+  e._pullAlgorithm = void 0, e._cancelAlgorithm = void 0, e._strategySizeAlgorithm = void 0;
+}
+function ye(e) {
+  if (!we(e)) return;
+  const t = e._controlledReadableStream;
+  e._closeRequested = !0, e._queue.length === 0 && (Ke(e), ke(t));
+}
+function ve(e, t) {
+  if (!we(e)) return;
+  const r = e._controlledReadableStream;
+  if (H(r) && Ze(r) > 0) At(r, t, !1);
+  else {
+    let o;
+    try {
+      o = e._strategySizeAlgorithm(t);
+    } catch (i) {
+      throw G(e, i), i;
+    }
+    try {
+      jt(e, t, o);
+    } catch (i) {
+      throw G(e, i), i;
+    }
+  }
+  Oe(e);
+}
+function G(e, t) {
+  const r = e._controlledReadableStream;
+  r._state === "readable" && (J(e), Ke(e), Qr(r, t));
+}
+function xt(e) {
+  const t = e._controlledReadableStream._state;
+  return t === "errored" ? null : t === "closed" ? 0 : e._strategyHWM - e._queueTotalSize;
+}
+function we(e) {
+  const t = e._controlledReadableStream._state;
+  return !e._closeRequested && t === "readable";
+}
+function Kr(e, t, r, o, i, n, s) {
+  t._controlledReadableStream = e, t._queue = void 0, t._queueTotalSize = void 0, J(t), t._started = !1, t._closeRequested = !1, t._pullAgain = !1, t._pulling = !1, t._strategySizeAlgorithm = s, t._strategyHWM = n, t._pullAlgorithm = o, t._cancelAlgorithm = i, e._readableStreamController = t, W(v(r()), () => (t._started = !0, Oe(t), null), (a) => (G(t, a), null));
+}
+function Le(e) {
+  return new TypeError(`ReadableStreamDefaultController.prototype.${e} can only be used on a ReadableStreamDefaultController`);
+}
+function ho(e) {
+  return R(t = e) && t.getReader !== void 0 ? function(r) {
+    let o;
+    return o = Qe(Pe, function() {
+      let i;
+      try {
+        i = r.read();
+      } catch (n) {
+        return c(n);
+      }
+      return ne(i, (n) => {
+        if (!R(n)) throw new TypeError("The promise returned by the reader.read() method must fulfill with an object");
+        if (n.done) ye(o._readableStreamController);
+        else {
+          const s = n.value;
+          ve(o._readableStreamController, s);
+        }
+      });
+    }, function(i) {
+      try {
+        return v(r.cancel(i));
+      } catch (n) {
+        return c(n);
+      }
+    }, 0), o;
+  }(e.getReader()) : function(r) {
+    let o;
+    const i = hr(r, "async");
+    return o = Qe(Pe, function() {
+      let n;
+      try {
+        n = _r(i);
+      } catch (s) {
+        return c(s);
+      }
+      return ne(v(n), (s) => {
+        if (!R(s)) throw new TypeError("The promise returned by the iterator.next() method must fulfill with an object");
+        if (s.done) ye(o._readableStreamController);
+        else {
+          const a = s.value;
+          ve(o._readableStreamController, a);
+        }
+      });
+    }, function(n) {
+      const s = i.iterator;
+      let a;
+      try {
+        a = Te(s, "return");
+      } catch (l) {
+        return c(l);
+      }
+      return a === void 0 ? v(void 0) : ne(ge(a, s, [n]), (l) => {
+        if (!R(l)) throw new TypeError("The promise returned by the iterator.return() method must fulfill with an object");
+      });
+    }, 0), o;
+  }(e);
+  var t;
+}
+function _o(e, t, r) {
+  return X(e, r), (o) => ge(e, t, [o]);
+}
+function po(e, t, r) {
+  return X(e, r), (o) => ge(e, t, [o]);
+}
+function mo(e, t, r) {
+  return X(e, r), (o) => me(e, t, [o]);
+}
+function yo(e, t) {
+  if ((e = `${e}`) != "bytes") throw new TypeError(`${t} '${e}' is not a valid enumeration value for ReadableStreamType`);
+  return e;
+}
+function Zt(e, t) {
+  V(e, t);
+  const r = e?.preventAbort, o = e?.preventCancel, i = e?.preventClose, n = e?.signal;
+  return n !== void 0 && function(s, a) {
+    if (!function(l) {
+      if (typeof l != "object" || l === null) return !1;
+      try {
+        return typeof l.aborted == "boolean";
+      } catch {
+        return !1;
+      }
+    }(s)) throw new TypeError(`${a} is not an AbortSignal.`);
+  }(n, `${t} has member 'signal' that`), { preventAbort: !!r, preventCancel: !!o, preventClose: !!i, signal: n };
+}
+Object.defineProperties(Y.prototype, { close: { enumerable: !0 }, enqueue: { enumerable: !0 }, error: { enumerable: !0 }, desiredSize: { enumerable: !0 } }), m(Y.prototype.close, "close"), m(Y.prototype.enqueue, "enqueue"), m(Y.prototype.error, "error"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(Y.prototype, Symbol.toStringTag, { value: "ReadableStreamDefaultController", configurable: !0 });
+class C {
+  constructor(t = {}, r = {}) {
+    t === void 0 ? t = null : sr(t, "First parameter");
+    const o = Fr(r, "Second parameter"), i = function(n, s) {
+      V(n, s);
+      const a = n, l = a?.autoAllocateChunkSize, u = a?.cancel, h = a?.pull, f = a?.start, b = a?.type;
+      return { autoAllocateChunkSize: l === void 0 ? void 0 : Ct(l, `${s} has member 'autoAllocateChunkSize' that`), cancel: u === void 0 ? void 0 : _o(u, a, `${s} has member 'cancel' that`), pull: h === void 0 ? void 0 : po(h, a, `${s} has member 'pull' that`), start: f === void 0 ? void 0 : mo(f, a, `${s} has member 'start' that`), type: b === void 0 ? void 0 : yo(b, `${s} has member 'type' that`) };
+    }(t, "First parameter");
+    if (Dt(this), i.type === "bytes") {
+      if (o.size !== void 0) throw new RangeError("The strategy for a byte stream cannot have a size function");
+      (function(n, s, a) {
+        const l = Object.create(N.prototype);
+        let u, h, f;
+        u = s.start !== void 0 ? () => s.start(l) : () => {
+        }, h = s.pull !== void 0 ? () => s.pull(l) : () => v(void 0), f = s.cancel !== void 0 ? (w) => s.cancel(w) : () => v(void 0);
+        const b = s.autoAllocateChunkSize;
+        if (b === 0) throw new TypeError("autoAllocateChunkSize must be greater than 0");
+        jr(n, l, u, h, f, a, b);
+      })(this, i, yt(o, 0));
+    } else {
+      const n = Br(o);
+      (function(s, a, l, u) {
+        const h = Object.create(Y.prototype);
+        let f, b, w;
+        f = a.start !== void 0 ? () => a.start(h) : () => {
+        }, b = a.pull !== void 0 ? () => a.pull(h) : () => v(void 0), w = a.cancel !== void 0 ? (T) => a.cancel(T) : () => v(void 0), Kr(s, h, f, b, w, l, u);
+      })(this, i, yt(o, 1), n);
+    }
+  }
+  get locked() {
+    if (!D(this)) throw Z("locked");
+    return H(this);
+  }
+  cancel(t = void 0) {
+    return D(this) ? H(this) ? c(new TypeError("Cannot cancel a stream that already has a reader")) : k(this, t) : c(Z("cancel"));
+  }
+  getReader(t = void 0) {
+    if (!D(this)) throw Z("getReader");
+    return function(r, o) {
+      V(r, o);
+      const i = r?.mode;
+      return { mode: i === void 0 ? void 0 : io(i, `${o} has member 'mode' that`) };
+    }(t, "First parameter").mode === void 0 ? ce(this) : Xt(this);
+  }
+  pipeThrough(t, r = {}) {
+    if (!D(this)) throw Z("pipeThrough");
+    ae(t, 1, "pipeThrough");
+    const o = function(n, s) {
+      V(n, s);
+      const a = n?.readable;
+      Nt(a, "readable", "ReadableWritablePair"), Ot(a, `${s} has member 'readable' that`);
+      const l = n?.writable;
+      return Nt(l, "writable", "ReadableWritablePair"), Ir(l, `${s} has member 'writable' that`), { readable: a, writable: l };
+    }(t, "First parameter"), i = Zt(r, "Second parameter");
+    if (H(this)) throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");
+    if (pe(o.writable)) throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");
+    return Ae(Qt(this, o.writable, i.preventClose, i.preventAbort, i.preventCancel, i.signal)), o.readable;
+  }
+  pipeTo(t, r = {}) {
+    if (!D(this)) return c(Z("pipeTo"));
+    if (t === void 0) return c("Parameter 1 is required in 'pipeTo'.");
+    if (!he(t)) return c(new TypeError("ReadableStream.prototype.pipeTo's first argument must be a WritableStream"));
+    let o;
+    try {
+      o = Zt(r, "Second parameter");
+    } catch (i) {
+      return c(i);
+    }
+    return H(this) ? c(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream")) : pe(t) ? c(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream")) : Qt(this, t, o.preventClose, o.preventAbort, o.preventCancel, o.signal);
+  }
+  tee() {
+    if (!D(this)) throw Z("tee");
+    return Se(te((t = this)._readableStreamController) ? function(r) {
+      let o, i, n, s, a, l = ce(r), u = !1, h = !1, f = !1, b = !1, w = !1;
+      const T = P((d) => {
+        a = d;
+      });
+      function q(d) {
+        bt(d._closedPromise, (p) => (d !== l || (A(n._readableStreamController, p), A(s._readableStreamController, p), b && w || a(void 0)), null));
+      }
+      function y() {
+        oe(l) && (L(l), l = ce(r), q(l)), Ce(l, { _chunkSteps: (d) => {
+          ie(() => {
+            h = !1, f = !1;
+            const p = d;
+            let S = d;
+            if (!b && !w) try {
+              S = Gt(d);
+            } catch (E) {
+              return A(n._readableStreamController, E), A(s._readableStreamController, E), void a(k(r, E));
+            }
+            b || Ne(n._readableStreamController, p), w || Ne(s._readableStreamController, S), u = !1, h ? g() : f && z();
+          });
+        }, _closeSteps: () => {
+          u = !1, b || qe(n._readableStreamController), w || qe(s._readableStreamController), n._readableStreamController._pendingPullIntos.length > 0 && Ye(n._readableStreamController, 0), s._readableStreamController._pendingPullIntos.length > 0 && Ye(s._readableStreamController, 0), b && w || a(void 0);
+        }, _errorSteps: () => {
+          u = !1;
+        } });
+      }
+      function _(d, p) {
+        U(l) && (L(l), l = Xt(r), q(l));
+        const S = p ? s : n, E = p ? n : s;
+        Wr(l, d, 1, { _chunkSteps: (O) => {
+          ie(() => {
+            h = !1, f = !1;
+            const $ = p ? w : b;
+            if (p ? b : w) $ || Ve(S._readableStreamController, O);
+            else {
+              let x;
+              try {
+                x = Gt(O);
+              } catch (ot) {
+                return A(S._readableStreamController, ot), A(E._readableStreamController, ot), void a(k(r, ot));
+              }
+              $ || Ve(S._readableStreamController, O), Ne(E._readableStreamController, x);
+            }
+            u = !1, h ? g() : f && z();
+          });
+        }, _closeSteps: (O) => {
+          u = !1;
+          const $ = p ? w : b, x = p ? b : w;
+          $ || qe(S._readableStreamController), x || qe(E._readableStreamController), O !== void 0 && ($ || Ve(S._readableStreamController, O), !x && E._readableStreamController._pendingPullIntos.length > 0 && Ye(E._readableStreamController, 0)), $ && x || a(void 0);
+        }, _errorSteps: () => {
+          u = !1;
+        } });
+      }
+      function g() {
+        if (u) return h = !0, v(void 0);
+        u = !0;
+        const d = mt(n._readableStreamController);
+        return d === null ? y() : _(d._view, !1), v(void 0);
+      }
+      function z() {
+        if (u) return f = !0, v(void 0);
+        u = !0;
+        const d = mt(s._readableStreamController);
+        return d === null ? y() : _(d._view, !0), v(void 0);
+      }
+      function I() {
+      }
+      return n = er(I, g, function(d) {
+        if (b = !0, o = d, w) {
+          const p = Se([o, i]), S = k(r, p);
+          a(S);
+        }
+        return T;
+      }), s = er(I, z, function(d) {
+        if (w = !0, i = d, b) {
+          const p = Se([o, i]), S = k(r, p);
+          a(S);
+        }
+        return T;
+      }), q(l), [n, s];
+    }(t) : function(r) {
+      const o = ce(r);
+      let i, n, s, a, l, u = !1, h = !1, f = !1, b = !1;
+      const w = P((y) => {
+        l = y;
+      });
+      function T() {
+        return u ? (h = !0, v(void 0)) : (u = !0, Ce(o, { _chunkSteps: (y) => {
+          ie(() => {
+            h = !1;
+            const _ = y, g = y;
+            f || ve(s._readableStreamController, _), b || ve(a._readableStreamController, g), u = !1, h && T();
+          });
+        }, _closeSteps: () => {
+          u = !1, f || ye(s._readableStreamController), b || ye(a._readableStreamController), f && b || l(void 0);
+        }, _errorSteps: () => {
+          u = !1;
+        } }), v(void 0));
+      }
+      function q() {
+      }
+      return s = Qe(q, T, function(y) {
+        if (f = !0, i = y, b) {
+          const _ = Se([i, n]), g = k(r, _);
+          l(g);
+        }
+        return w;
+      }), a = Qe(q, T, function(y) {
+        if (b = !0, n = y, f) {
+          const _ = Se([i, n]), g = k(r, _);
+          l(g);
+        }
+        return w;
+      }), bt(o._closedPromise, (y) => (G(s._readableStreamController, y), G(a._readableStreamController, y), f && b || l(void 0), null)), [s, a];
+    }(t));
+    var t;
+  }
+  values(t = void 0) {
+    if (!D(this)) throw Z("values");
+    return function(o, i) {
+      const n = ce(o), s = new pr(n, i), a = Object.create(mr);
+      return a._asyncIteratorImpl = s, a;
+    }(this, (r = t, V(r, "First parameter"), { preventCancel: !!r?.preventCancel }).preventCancel);
+    var r;
+  }
+  [je](t) {
+    return this.values(t);
+  }
+  static from(t) {
+    return ho(t);
+  }
+}
+function Qe(e, t, r, o = 1, i = () => 1) {
+  const n = Object.create(C.prototype);
+  return Dt(n), Kr(n, Object.create(Y.prototype), e, t, r, o, i), n;
+}
+function er(e, t, r) {
+  const o = Object.create(C.prototype);
+  return Dt(o), jr(o, Object.create(N.prototype), e, t, r, 0, void 0), o;
+}
+function Dt(e) {
+  e._state = "readable", e._reader = void 0, e._storedError = void 0, e._disturbed = !1;
+}
+function D(e) {
+  return !!R(e) && !!Object.prototype.hasOwnProperty.call(e, "_readableStreamController") && e instanceof C;
+}
+function H(e) {
+  return e._reader !== void 0;
+}
+function k(e, t) {
+  if (e._disturbed = !0, e._state === "closed") return v(void 0);
+  if (e._state === "errored") return c(e._storedError);
+  ke(e);
+  const r = e._reader;
+  if (r !== void 0 && oe(r)) {
+    const o = r._readIntoRequests;
+    r._readIntoRequests = new j(), o.forEach((i) => {
+      i._closeSteps(void 0);
+    });
+  }
+  return ne(e._readableStreamController[Rt](t), Pe);
+}
+function ke(e) {
+  e._state = "closed";
+  const t = e._reader;
+  if (t !== void 0 && (ar(t), U(t))) {
+    const r = t._readRequests;
+    t._readRequests = new j(), r.forEach((o) => {
+      o._closeSteps();
+    });
+  }
+}
+function Qr(e, t) {
+  e._state = "errored", e._storedError = t;
+  const r = e._reader;
+  r !== void 0 && (Pt(r, t), U(r) ? dr(r, t) : zr(r, t));
+}
+function Z(e) {
+  return new TypeError(`ReadableStream.prototype.${e} can only be used on a ReadableStream`);
+}
+function ft(e, t) {
+  var r;
+  (r = e._transformStreamController)._transformAlgorithm = void 0, r._flushAlgorithm = void 0, r._cancelAlgorithm = void 0, wt(e._writable._writableStreamController, t), function(o) {
+    o._backpressure && Zr(o, !1);
+  }(e);
+}
+function Zr(e, t) {
+  e._backpressureChangePromise !== void 0 && e._backpressureChangePromise_resolve(), e._backpressureChangePromise = P((r) => {
+    e._backpressureChangePromise_resolve = r;
+  }), e._backpressure = t;
+}
+Object.defineProperties(C, { from: { enumerable: !0 } }), Object.defineProperties(C.prototype, { cancel: { enumerable: !0 }, getReader: { enumerable: !0 }, pipeThrough: { enumerable: !0 }, pipeTo: { enumerable: !0 }, tee: { enumerable: !0 }, values: { enumerable: !0 }, locked: { enumerable: !0 } }), m(C.from, "from"), m(C.prototype.cancel, "cancel"), m(C.prototype.getReader, "getReader"), m(C.prototype.pipeThrough, "pipeThrough"), m(C.prototype.pipeTo, "pipeTo"), m(C.prototype.tee, "tee"), m(C.prototype.values, "values"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(C.prototype, Symbol.toStringTag, { value: "ReadableStream", configurable: !0 }), Object.defineProperty(C.prototype, je, { value: C.prototype.values, writable: !0, configurable: !0 }), m((e) => e.byteLength, "size"), m(() => 1, "size");
+class fe {
+  constructor() {
+    throw new TypeError("Illegal constructor");
+  }
+  get desiredSize() {
+    if (!$e(this)) throw xe("desiredSize");
+    return xt(this._controlledTransformStream._readable._readableStreamController);
+  }
+  enqueue(t = void 0) {
+    if (!$e(this)) throw xe("enqueue");
+    (function(r, o) {
+      const i = r._controlledTransformStream, n = i._readable._readableStreamController;
+      if (!we(n)) throw new TypeError("Readable side is not in a state that permits enqueue");
+      try {
+        ve(n, o);
+      } catch (a) {
+        throw ft(i, a), i._readable._storedError;
+      }
+      var s;
+      !Jr(s = n) !== i._backpressure && Zr(i, !0);
+    })(this, t);
+  }
+  error(t = void 0) {
+    if (!$e(this)) throw xe("error");
+    var r, o, i;
+    r = t, o = this._controlledTransformStream, i = r, G(o._readable._readableStreamController, i), ft(o, i);
+  }
+  terminate() {
+    if (!$e(this)) throw xe("terminate");
+    (function(t) {
+      const r = t._controlledTransformStream;
+      ye(r._readable._readableStreamController), ft(r, new TypeError("TransformStream terminated"));
+    })(this);
+  }
+}
+function $e(e) {
+  return !!R(e) && !!Object.prototype.hasOwnProperty.call(e, "_controlledTransformStream") && e instanceof fe;
+}
+function xe(e) {
+  return new TypeError(`TransformStreamDefaultController.prototype.${e} can only be used on a TransformStreamDefaultController`);
+}
+Object.defineProperties(fe.prototype, { enqueue: { enumerable: !0 }, error: { enumerable: !0 }, terminate: { enumerable: !0 }, desiredSize: { enumerable: !0 } }), m(fe.prototype.enqueue, "enqueue"), m(fe.prototype.error, "error"), m(fe.prototype.terminate, "terminate"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(fe.prototype, Symbol.toStringTag, { value: "TransformStreamDefaultController", configurable: !0 });
+export {
+  N as ReadableByteStreamController,
+  C as ReadableStream,
+  re as ReadableStreamBYOBReader,
+  be as ReadableStreamBYOBRequest,
+  Y as ReadableStreamDefaultController,
+  ee as ReadableStreamDefaultReader,
+  fe as TransformStreamDefaultController,
+  de as WritableStream,
+  Xe as WritableStreamDefaultController,
+  M as WritableStreamDefaultWriter
+};