next/dist/compiled/@edge-runtime/primitives/streams.js.text.js

The React Framework

module.exports = "\"use strict\";\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __name = (target, value) => __defProp(target, \"name\", { value, configurable: true });\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\n\n// src/primitives/streams.js\nvar streams_exports = {};\n__export(streams_exports, {\n  ReadableStream: () => ReadableStream,\n  ReadableStreamBYOBReader: () => ReadableStreamBYOBReader,\n  ReadableStreamDefaultReader: () => ReadableStreamDefaultReader,\n  TransformStream: () => TransformStream,\n  WritableStream: () => WritableStream,\n  WritableStreamDefaultWriter: () => WritableStreamDefaultWriter\n});\nmodule.exports = __toCommonJS(streams_exports);\n\n// ../../node_modules/.pnpm/web-streams-polyfill@4.0.0-beta.3/node_modules/web-streams-polyfill/dist/ponyfill.mjs\nvar e = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? Symbol : (e2) => `Symbol(${e2})`;\nfunction t() {\n}\n__name(t, \"t\");\nfunction r(e2) {\n  return \"object\" == typeof e2 && null !== e2 || \"function\" == typeof e2;\n}\n__name(r, \"r\");\nvar o = t;\nfunction n(e2, t2) {\n  try {\n    Object.defineProperty(e2, \"name\", { value: t2, configurable: true });\n  } catch (e3) {\n  }\n}\n__name(n, \"n\");\nvar a = Promise;\nvar i = Promise.prototype.then;\nvar l = Promise.resolve.bind(a);\nvar s = Promise.reject.bind(a);\nfunction u(e2) {\n  return new a(e2);\n}\n__name(u, \"u\");\nfunction c(e2) {\n  return l(e2);\n}\n__name(c, \"c\");\nfunction d(e2) {\n  return s(e2);\n}\n__name(d, \"d\");\nfunction f(e2, t2, r2) {\n  return i.call(e2, t2, r2);\n}\n__name(f, \"f\");\nfunction b(e2, t2, r2) {\n  f(f(e2, t2, r2), void 0, o);\n}\n__name(b, \"b\");\nfunction h(e2, t2) {\n  b(e2, t2);\n}\n__name(h, \"h\");\nfunction _(e2, t2) {\n  b(e2, void 0, t2);\n}\n__name(_, \"_\");\nfunction p(e2, t2, r2) {\n  return f(e2, t2, r2);\n}\n__name(p, \"p\");\nfunction m(e2) {\n  f(e2, void 0, o);\n}\n__name(m, \"m\");\nvar y = /* @__PURE__ */ __name((e2) => {\n  if (\"function\" == typeof queueMicrotask)\n    y = queueMicrotask;\n  else {\n    const e3 = c(void 0);\n    y = /* @__PURE__ */ __name((t2) => f(e3, t2), \"y\");\n  }\n  return y(e2);\n}, \"y\");\nfunction g(e2, t2, r2) {\n  if (\"function\" != typeof e2)\n    throw new TypeError(\"Argument is not a function\");\n  return Function.prototype.apply.call(e2, t2, r2);\n}\n__name(g, \"g\");\nfunction w(e2, t2, r2) {\n  try {\n    return c(g(e2, t2, r2));\n  } catch (e3) {\n    return d(e3);\n  }\n}\n__name(w, \"w\");\nvar S = class {\n  constructor() {\n    this._cursor = 0, this._size = 0, this._front = { _elements: [], _next: void 0 }, this._back = this._front, this._cursor = 0, this._size = 0;\n  }\n  get length() {\n    return this._size;\n  }\n  push(e2) {\n    const t2 = this._back;\n    let r2 = t2;\n    16383 === t2._elements.length && (r2 = { _elements: [], _next: void 0 }), t2._elements.push(e2), r2 !== t2 && (this._back = r2, t2._next = r2), ++this._size;\n  }\n  shift() {\n    const e2 = this._front;\n    let t2 = e2;\n    const r2 = this._cursor;\n    let o2 = r2 + 1;\n    const n2 = e2._elements, a2 = n2[r2];\n    return 16384 === o2 && (t2 = e2._next, o2 = 0), --this._size, this._cursor = o2, e2 !== t2 && (this._front = t2), n2[r2] = void 0, a2;\n  }\n  forEach(e2) {\n    let t2 = this._cursor, r2 = this._front, o2 = r2._elements;\n    for (; !(t2 === o2.length && void 0 === r2._next || t2 === o2.length && (r2 = r2._next, o2 = r2._elements, t2 = 0, 0 === o2.length)); )\n      e2(o2[t2]), ++t2;\n  }\n  peek() {\n    const e2 = this._front, t2 = this._cursor;\n    return e2._elements[t2];\n  }\n};\n__name(S, \"S\");\nvar v = e(\"[[AbortSteps]]\");\nvar R = e(\"[[ErrorSteps]]\");\nvar T = e(\"[[CancelSteps]]\");\nvar q = e(\"[[PullSteps]]\");\nvar C = e(\"[[ReleaseSteps]]\");\nfunction E(e2, t2) {\n  e2._ownerReadableStream = t2, t2._reader = e2, \"readable\" === t2._state ? O(e2) : \"closed\" === t2._state ? function(e3) {\n    O(e3), j(e3);\n  }(e2) : B(e2, t2._storedError);\n}\n__name(E, \"E\");\nfunction P(e2, t2) {\n  return Gt(e2._ownerReadableStream, t2);\n}\n__name(P, \"P\");\nfunction W(e2) {\n  const t2 = e2._ownerReadableStream;\n  \"readable\" === t2._state ? A(e2, new TypeError(\"Reader was released and can no longer be used to monitor the stream's closedness\")) : function(e3, t3) {\n    B(e3, t3);\n  }(e2, new TypeError(\"Reader was released and can no longer be used to monitor the stream's closedness\")), t2._readableStreamController[C](), t2._reader = void 0, e2._ownerReadableStream = void 0;\n}\n__name(W, \"W\");\nfunction k(e2) {\n  return new TypeError(\"Cannot \" + e2 + \" a stream using a released reader\");\n}\n__name(k, \"k\");\nfunction O(e2) {\n  e2._closedPromise = u((t2, r2) => {\n    e2._closedPromise_resolve = t2, e2._closedPromise_reject = r2;\n  });\n}\n__name(O, \"O\");\nfunction B(e2, t2) {\n  O(e2), A(e2, t2);\n}\n__name(B, \"B\");\nfunction A(e2, t2) {\n  void 0 !== e2._closedPromise_reject && (m(e2._closedPromise), e2._closedPromise_reject(t2), e2._closedPromise_resolve = void 0, e2._closedPromise_reject = void 0);\n}\n__name(A, \"A\");\nfunction j(e2) {\n  void 0 !== e2._closedPromise_resolve && (e2._closedPromise_resolve(void 0), e2._closedPromise_resolve = void 0, e2._closedPromise_reject = void 0);\n}\n__name(j, \"j\");\nvar z = Number.isFinite || function(e2) {\n  return \"number\" == typeof e2 && isFinite(e2);\n};\nvar L = Math.trunc || function(e2) {\n  return e2 < 0 ? Math.ceil(e2) : Math.floor(e2);\n};\nfunction F(e2, t2) {\n  if (void 0 !== e2 && (\"object\" != typeof (r2 = e2) && \"function\" != typeof r2))\n    throw new TypeError(`${t2} is not an object.`);\n  var r2;\n}\n__name(F, \"F\");\nfunction I(e2, t2) {\n  if (\"function\" != typeof e2)\n    throw new TypeError(`${t2} is not a function.`);\n}\n__name(I, \"I\");\nfunction D(e2, t2) {\n  if (!function(e3) {\n    return \"object\" == typeof e3 && null !== e3 || \"function\" == typeof e3;\n  }(e2))\n    throw new TypeError(`${t2} is not an object.`);\n}\n__name(D, \"D\");\nfunction $(e2, t2, r2) {\n  if (void 0 === e2)\n    throw new TypeError(`Parameter ${t2} is required in '${r2}'.`);\n}\n__name($, \"$\");\nfunction M(e2, t2, r2) {\n  if (void 0 === e2)\n    throw new TypeError(`${t2} is required in '${r2}'.`);\n}\n__name(M, \"M\");\nfunction Y(e2) {\n  return Number(e2);\n}\n__name(Y, \"Y\");\nfunction Q(e2) {\n  return 0 === e2 ? 0 : e2;\n}\n__name(Q, \"Q\");\nfunction N(e2, t2) {\n  const r2 = Number.MAX_SAFE_INTEGER;\n  let o2 = Number(e2);\n  if (o2 = Q(o2), !z(o2))\n    throw new TypeError(`${t2} is not a finite number`);\n  if (o2 = function(e3) {\n    return Q(L(e3));\n  }(o2), o2 < 0 || o2 > r2)\n    throw new TypeError(`${t2} is outside the accepted range of 0 to ${r2}, inclusive`);\n  return z(o2) && 0 !== o2 ? o2 : 0;\n}\n__name(N, \"N\");\nfunction H(e2) {\n  if (!r(e2))\n    return false;\n  if (\"function\" != typeof e2.getReader)\n    return false;\n  try {\n    return \"boolean\" == typeof e2.locked;\n  } catch (e3) {\n    return false;\n  }\n}\n__name(H, \"H\");\nfunction x(e2) {\n  if (!r(e2))\n    return false;\n  if (\"function\" != typeof e2.getWriter)\n    return false;\n  try {\n    return \"boolean\" == typeof e2.locked;\n  } catch (e3) {\n    return false;\n  }\n}\n__name(x, \"x\");\nfunction V(e2, t2) {\n  if (!Vt(e2))\n    throw new TypeError(`${t2} is not a ReadableStream.`);\n}\n__name(V, \"V\");\nfunction U(e2, t2) {\n  e2._reader._readRequests.push(t2);\n}\n__name(U, \"U\");\nfunction G(e2, t2, r2) {\n  const o2 = e2._reader._readRequests.shift();\n  r2 ? o2._closeSteps() : o2._chunkSteps(t2);\n}\n__name(G, \"G\");\nfunction X(e2) {\n  return e2._reader._readRequests.length;\n}\n__name(X, \"X\");\nfunction J(e2) {\n  const t2 = e2._reader;\n  return void 0 !== t2 && !!K(t2);\n}\n__name(J, \"J\");\nvar ReadableStreamDefaultReader = class {\n  constructor(e2) {\n    if ($(e2, 1, \"ReadableStreamDefaultReader\"), V(e2, \"First parameter\"), Ut(e2))\n      throw new TypeError(\"This stream has already been locked for exclusive reading by another reader\");\n    E(this, e2), this._readRequests = new S();\n  }\n  get closed() {\n    return K(this) ? this._closedPromise : d(ee(\"closed\"));\n  }\n  cancel(e2) {\n    return K(this) ? void 0 === this._ownerReadableStream ? d(k(\"cancel\")) : P(this, e2) : d(ee(\"cancel\"));\n  }\n  read() {\n    if (!K(this))\n      return d(ee(\"read\"));\n    if (void 0 === this._ownerReadableStream)\n      return d(k(\"read from\"));\n    let e2, t2;\n    const r2 = u((r3, o2) => {\n      e2 = r3, t2 = o2;\n    });\n    return function(e3, t3) {\n      const r3 = e3._ownerReadableStream;\n      r3._disturbed = true, \"closed\" === r3._state ? t3._closeSteps() : \"errored\" === r3._state ? t3._errorSteps(r3._storedError) : r3._readableStreamController[q](t3);\n    }(this, { _chunkSteps: (t3) => e2({ value: t3, done: false }), _closeSteps: () => e2({ value: void 0, done: true }), _errorSteps: (e3) => t2(e3) }), r2;\n  }\n  releaseLock() {\n    if (!K(this))\n      throw ee(\"releaseLock\");\n    void 0 !== this._ownerReadableStream && function(e2) {\n      W(e2);\n      const t2 = new TypeError(\"Reader was released\");\n      Z(e2, t2);\n    }(this);\n  }\n};\n__name(ReadableStreamDefaultReader, \"ReadableStreamDefaultReader\");\nfunction K(e2) {\n  return !!r(e2) && (!!Object.prototype.hasOwnProperty.call(e2, \"_readRequests\") && e2 instanceof ReadableStreamDefaultReader);\n}\n__name(K, \"K\");\nfunction Z(e2, t2) {\n  const r2 = e2._readRequests;\n  e2._readRequests = new S(), r2.forEach((e3) => {\n    e3._errorSteps(t2);\n  });\n}\n__name(Z, \"Z\");\nfunction ee(e2) {\n  return new TypeError(`ReadableStreamDefaultReader.prototype.${e2} can only be used on a ReadableStreamDefaultReader`);\n}\n__name(ee, \"ee\");\nObject.defineProperties(ReadableStreamDefaultReader.prototype, { cancel: { enumerable: true }, read: { enumerable: true }, releaseLock: { enumerable: true }, closed: { enumerable: true } }), n(ReadableStreamDefaultReader.prototype.cancel, \"cancel\"), n(ReadableStreamDefaultReader.prototype.read, \"read\"), n(ReadableStreamDefaultReader.prototype.releaseLock, \"releaseLock\"), \"symbol\" == typeof e.toStringTag && Object.defineProperty(ReadableStreamDefaultReader.prototype, e.toStringTag, { value: \"ReadableStreamDefaultReader\", configurable: true });\nvar te = class {\n  constructor(e2, t2) {\n    this._ongoingPromise = void 0, this._isFinished = false, this._reader = e2, this._preventCancel = t2;\n  }\n  next() {\n    const e2 = /* @__PURE__ */ __name(() => this._nextSteps(), \"e\");\n    return this._ongoingPromise = this._ongoingPromise ? p(this._ongoingPromise, e2, e2) : e2(), this._ongoingPromise;\n  }\n  return(e2) {\n    const t2 = /* @__PURE__ */ __name(() => this._returnSteps(e2), \"t\");\n    return this._ongoingPromise ? p(this._ongoingPromise, t2, t2) : t2();\n  }\n  _nextSteps() {\n    if (this._isFinished)\n      return Promise.resolve({ value: void 0, done: true });\n    const e2 = this._reader;\n    return void 0 === e2 ? d(k(\"iterate\")) : f(e2.read(), (e3) => {\n      var t2;\n      return this._ongoingPromise = void 0, e3.done && (this._isFinished = true, null === (t2 = this._reader) || void 0 === t2 || t2.releaseLock(), this._reader = void 0), e3;\n    }, (e3) => {\n      var t2;\n      throw this._ongoingPromise = void 0, this._isFinished = true, null === (t2 = this._reader) || void 0 === t2 || t2.releaseLock(), this._reader = void 0, e3;\n    });\n  }\n  _returnSteps(e2) {\n    if (this._isFinished)\n      return Promise.resolve({ value: e2, done: true });\n    this._isFinished = true;\n    const t2 = this._reader;\n    if (void 0 === t2)\n      return d(k(\"finish iterating\"));\n    if (this._reader = void 0, !this._preventCancel) {\n      const r2 = t2.cancel(e2);\n      return t2.releaseLock(), p(r2, () => ({ value: e2, done: true }));\n    }\n    return t2.releaseLock(), c({ value: e2, done: true });\n  }\n};\n__name(te, \"te\");\nvar re = { next() {\n  return oe(this) ? this._asyncIteratorImpl.next() : d(ne(\"next\"));\n}, return(e2) {\n  return oe(this) ? this._asyncIteratorImpl.return(e2) : d(ne(\"return\"));\n} };\nfunction oe(e2) {\n  if (!r(e2))\n    return false;\n  if (!Object.prototype.hasOwnProperty.call(e2, \"_asyncIteratorImpl\"))\n    return false;\n  try {\n    return e2._asyncIteratorImpl instanceof te;\n  } catch (e3) {\n    return false;\n  }\n}\n__name(oe, \"oe\");\nfunction ne(e2) {\n  return new TypeError(`ReadableStreamAsyncIterator.${e2} can only be used on a ReadableSteamAsyncIterator`);\n}\n__name(ne, \"ne\");\n\"symbol\" == typeof e.asyncIterator && Object.defineProperty(re, e.asyncIterator, { value() {\n  return this;\n}, writable: true, configurable: true });\nvar ae = Number.isNaN || function(e2) {\n  return e2 != e2;\n};\nfunction ie(e2, t2, r2, o2, n2) {\n  new Uint8Array(e2).set(new Uint8Array(r2, o2, n2), t2);\n}\n__name(ie, \"ie\");\nfunction le(e2) {\n  const t2 = function(e3, t3, r2) {\n    if (e3.slice)\n      return e3.slice(t3, r2);\n    const o2 = r2 - t3, n2 = new ArrayBuffer(o2);\n    return ie(n2, 0, e3, t3, o2), n2;\n  }(e2.buffer, e2.byteOffset, e2.byteOffset + e2.byteLength);\n  return new Uint8Array(t2);\n}\n__name(le, \"le\");\nfunction se(e2) {\n  const t2 = e2._queue.shift();\n  return e2._queueTotalSize -= t2.size, e2._queueTotalSize < 0 && (e2._queueTotalSize = 0), t2.value;\n}\n__name(se, \"se\");\nfunction ue(e2, t2, r2) {\n  if (\"number\" != typeof (o2 = r2) || ae(o2) || o2 < 0 || r2 === 1 / 0)\n    throw new RangeError(\"Size must be a finite, non-NaN, non-negative number.\");\n  var o2;\n  e2._queue.push({ value: t2, size: r2 }), e2._queueTotalSize += r2;\n}\n__name(ue, \"ue\");\nfunction ce(e2) {\n  e2._queue = new S(), e2._queueTotalSize = 0;\n}\n__name(ce, \"ce\");\nvar ReadableStreamBYOBRequest = class {\n  constructor() {\n    throw new TypeError(\"Illegal constructor\");\n  }\n  get view() {\n    if (!fe(this))\n      throw Be(\"view\");\n    return this._view;\n  }\n  respond(e2) {\n    if (!fe(this))\n      throw Be(\"respond\");\n    if ($(e2, 1, \"respond\"), e2 = N(e2, \"First parameter\"), void 0 === this._associatedReadableByteStreamController)\n      throw new TypeError(\"This BYOB request has been invalidated\");\n    this._view.buffer, function(e3, t2) {\n      const r2 = e3._pendingPullIntos.peek();\n      if (\"closed\" === e3._controlledReadableByteStream._state) {\n        if (0 !== t2)\n          throw new TypeError(\"bytesWritten must be 0 when calling respond() on a closed stream\");\n      } else {\n        if (0 === t2)\n          throw new TypeError(\"bytesWritten must be greater than 0 when calling respond() on a readable stream\");\n        if (r2.bytesFilled + t2 > r2.byteLength)\n          throw new RangeError(\"bytesWritten out of range\");\n      }\n      r2.buffer = r2.buffer, qe(e3, t2);\n    }(this._associatedReadableByteStreamController, e2);\n  }\n  respondWithNewView(e2) {\n    if (!fe(this))\n      throw Be(\"respondWithNewView\");\n    if ($(e2, 1, \"respondWithNewView\"), !ArrayBuffer.isView(e2))\n      throw new TypeError(\"You can only respond with array buffer views\");\n    if (void 0 === this._associatedReadableByteStreamController)\n      throw new TypeError(\"This BYOB request has been invalidated\");\n    e2.buffer, function(e3, t2) {\n      const r2 = e3._pendingPullIntos.peek();\n      if (\"closed\" === e3._controlledReadableByteStream._state) {\n        if (0 !== t2.byteLength)\n          throw new TypeError(\"The view's length must be 0 when calling respondWithNewView() on a closed stream\");\n      } else if (0 === t2.byteLength)\n        throw new TypeError(\"The view's length must be greater than 0 when calling respondWithNewView() on a readable stream\");\n      if (r2.byteOffset + r2.bytesFilled !== t2.byteOffset)\n        throw new RangeError(\"The region specified by view does not match byobRequest\");\n      if (r2.bufferByteLength !== t2.buffer.byteLength)\n        throw new RangeError(\"The buffer of view has different capacity than byobRequest\");\n      if (r2.bytesFilled + t2.byteLength > r2.byteLength)\n        throw new RangeError(\"The region specified by view is larger than byobRequest\");\n      const o2 = t2.byteLength;\n      r2.buffer = t2.buffer, qe(e3, o2);\n    }(this._associatedReadableByteStreamController, e2);\n  }\n};\n__name(ReadableStreamBYOBRequest, \"ReadableStreamBYOBRequest\");\nObject.defineProperties(ReadableStreamBYOBRequest.prototype, { respond: { enumerable: true }, respondWithNewView: { enumerable: true }, view: { enumerable: true } }), n(ReadableStreamBYOBRequest.prototype.respond, \"respond\"), n(ReadableStreamBYOBRequest.prototype.respondWithNewView, \"respondWithNewView\"), \"symbol\" == typeof e.toStringTag && Object.defineProperty(ReadableStreamBYOBRequest.prototype, e.toStringTag, { value: \"ReadableStreamBYOBRequest\", configurable: true });\nvar ReadableByteStreamController = class {\n  constructor() {\n    throw new TypeError(\"Illegal constructor\");\n  }\n  get byobRequest() {\n    if (!de(this))\n      throw Ae(\"byobRequest\");\n    return function(e2) {\n      if (null === e2._byobRequest && e2._pendingPullIntos.length > 0) {\n        const t2 = e2._pendingPullIntos.peek(), r2 = new Uint8Array(t2.buffer, t2.byteOffset + t2.bytesFilled, t2.byteLength - t2.bytesFilled), o2 = Object.create(ReadableStreamBYOBRequest.prototype);\n        !function(e3, t3, r3) {\n          e3._associatedReadableByteStreamController = t3, e3._view = r3;\n        }(o2, e2, r2), e2._byobRequest = o2;\n      }\n      return e2._byobRequest;\n    }(this);\n  }\n  get desiredSize() {\n    if (!de(this))\n      throw Ae(\"desiredSize\");\n    return ke(this);\n  }\n  close() {\n    if (!de(this))\n      throw Ae(\"close\");\n    if (this._closeRequested)\n      throw new TypeError(\"The stream has already been closed; do not close it again!\");\n    const e2 = this._controlledReadableByteStream._state;\n    if (\"readable\" !== e2)\n      throw new TypeError(`The stream (in ${e2} state) is not in the readable state and cannot be closed`);\n    !function(e3) {\n      const t2 = e3._controlledReadableByteStream;\n      if (e3._closeRequested || \"readable\" !== t2._state)\n        return;\n      if (e3._queueTotalSize > 0)\n        return void (e3._closeRequested = true);\n      if (e3._pendingPullIntos.length > 0) {\n        if (e3._pendingPullIntos.peek().bytesFilled > 0) {\n          const t3 = new TypeError(\"Insufficient bytes to fill elements in the given buffer\");\n          throw Pe(e3, t3), t3;\n        }\n      }\n      Ee(e3), Xt(t2);\n    }(this);\n  }\n  enqueue(e2) {\n    if (!de(this))\n      throw Ae(\"enqueue\");\n    if ($(e2, 1, \"enqueue\"), !ArrayBuffer.isView(e2))\n      throw new TypeError(\"chunk must be an array buffer view\");\n    if (0 === e2.byteLength)\n      throw new TypeError(\"chunk must have non-zero byteLength\");\n    if (0 === e2.buffer.byteLength)\n      throw new TypeError(\"chunk's buffer must have non-zero byteLength\");\n    if (this._closeRequested)\n      throw new TypeError(\"stream is closed or draining\");\n    const t2 = this._controlledReadableByteStream._state;\n    if (\"readable\" !== t2)\n      throw new TypeError(`The stream (in ${t2} state) is not in the readable state and cannot be enqueued to`);\n    !function(e3, t3) {\n      const r2 = e3._controlledReadableByteStream;\n      if (e3._closeRequested || \"readable\" !== r2._state)\n        return;\n      const o2 = t3.buffer, n2 = t3.byteOffset, a2 = t3.byteLength, i2 = o2;\n      if (e3._pendingPullIntos.length > 0) {\n        const t4 = e3._pendingPullIntos.peek();\n        t4.buffer, 0, Re(e3), t4.buffer = t4.buffer, \"none\" === t4.readerType && ge(e3, t4);\n      }\n      if (J(r2))\n        if (function(e4) {\n          const t4 = e4._controlledReadableByteStream._reader;\n          for (; t4._readRequests.length > 0; ) {\n            if (0 === e4._queueTotalSize)\n              return;\n            We(e4, t4._readRequests.shift());\n          }\n        }(e3), 0 === X(r2))\n          me(e3, i2, n2, a2);\n        else {\n          e3._pendingPullIntos.length > 0 && Ce(e3);\n          G(r2, new Uint8Array(i2, n2, a2), false);\n        }\n      else\n        Le(r2) ? (me(e3, i2, n2, a2), Te(e3)) : me(e3, i2, n2, a2);\n      be(e3);\n    }(this, e2);\n  }\n  error(e2) {\n    if (!de(this))\n      throw Ae(\"error\");\n    Pe(this, e2);\n  }\n  [T](e2) {\n    he(this), ce(this);\n    const t2 = this._cancelAlgorithm(e2);\n    return Ee(this), t2;\n  }\n  [q](e2) {\n    const t2 = this._controlledReadableByteStream;\n    if (this._queueTotalSize > 0)\n      return void We(this, e2);\n    const r2 = this._autoAllocateChunkSize;\n    if (void 0 !== r2) {\n      let t3;\n      try {\n        t3 = new ArrayBuffer(r2);\n      } catch (t4) {\n        return void e2._errorSteps(t4);\n      }\n      const o2 = { buffer: t3, bufferByteLength: r2, byteOffset: 0, byteLength: r2, bytesFilled: 0, elementSize: 1, viewConstructor: Uint8Array, readerType: \"default\" };\n      this._pendingPullIntos.push(o2);\n    }\n    U(t2, e2), be(this);\n  }\n  [C]() {\n    if (this._pendingPullIntos.length > 0) {\n      const e2 = this._pendingPullIntos.peek();\n      e2.readerType = \"none\", this._pendingPullIntos = new S(), this._pendingPullIntos.push(e2);\n    }\n  }\n};\n__name(ReadableByteStreamController, \"ReadableByteStreamController\");\nfunction de(e2) {\n  return !!r(e2) && (!!Object.prototype.hasOwnProperty.call(e2, \"_controlledReadableByteStream\") && e2 instanceof ReadableByteStreamController);\n}\n__name(de, \"de\");\nfunction fe(e2) {\n  return !!r(e2) && (!!Object.prototype.hasOwnProperty.call(e2, \"_associatedReadableByteStreamController\") && e2 instanceof ReadableStreamBYOBRequest);\n}\n__name(fe, \"fe\");\nfunction be(e2) {\n  const t2 = function(e3) {\n    const t3 = e3._controlledReadableByteStream;\n    if (\"readable\" !== t3._state)\n      return false;\n    if (e3._closeRequested)\n      return false;\n    if (!e3._started)\n      return false;\n    if (J(t3) && X(t3) > 0)\n      return true;\n    if (Le(t3) && ze(t3) > 0)\n      return true;\n    if (ke(e3) > 0)\n      return true;\n    return false;\n  }(e2);\n  if (!t2)\n    return;\n  if (e2._pulling)\n    return void (e2._pullAgain = true);\n  e2._pulling = true;\n  b(e2._pullAlgorithm(), () => (e2._pulling = false, e2._pullAgain && (e2._pullAgain = false, be(e2)), null), (t3) => (Pe(e2, t3), null));\n}\n__name(be, \"be\");\nfunction he(e2) {\n  Re(e2), e2._pendingPullIntos = new S();\n}\n__name(he, \"he\");\nfunction _e(e2, t2) {\n  let r2 = false;\n  \"closed\" === e2._state && (r2 = true);\n  const o2 = pe(t2);\n  \"default\" === t2.readerType ? G(e2, o2, r2) : function(e3, t3, r3) {\n    const o3 = e3._reader._readIntoRequests.shift();\n    r3 ? o3._closeSteps(t3) : o3._chunkSteps(t3);\n  }(e2, o2, r2);\n}\n__name(_e, \"_e\");\nfunction pe(e2) {\n  const t2 = e2.bytesFilled, r2 = e2.elementSize;\n  return new e2.viewConstructor(e2.buffer, e2.byteOffset, t2 / r2);\n}\n__name(pe, \"pe\");\nfunction me(e2, t2, r2, o2) {\n  e2._queue.push({ buffer: t2, byteOffset: r2, byteLength: o2 }), e2._queueTotalSize += o2;\n}\n__name(me, \"me\");\nfunction ye(e2, t2, r2, o2) {\n  let n2;\n  try {\n    n2 = t2.slice(r2, r2 + o2);\n  } catch (t3) {\n    throw Pe(e2, t3), t3;\n  }\n  me(e2, n2, 0, o2);\n}\n__name(ye, \"ye\");\nfunction ge(e2, t2) {\n  t2.bytesFilled > 0 && ye(e2, t2.buffer, t2.byteOffset, t2.bytesFilled), Ce(e2);\n}\n__name(ge, \"ge\");\nfunction we(e2, t2) {\n  const r2 = t2.elementSize, o2 = t2.bytesFilled - t2.bytesFilled % r2, n2 = Math.min(e2._queueTotalSize, t2.byteLength - t2.bytesFilled), a2 = t2.bytesFilled + n2, i2 = a2 - a2 % r2;\n  let l2 = n2, s2 = false;\n  i2 > o2 && (l2 = i2 - t2.bytesFilled, s2 = true);\n  const u2 = e2._queue;\n  for (; l2 > 0; ) {\n    const r3 = u2.peek(), o3 = Math.min(l2, r3.byteLength), n3 = t2.byteOffset + t2.bytesFilled;\n    ie(t2.buffer, n3, r3.buffer, r3.byteOffset, o3), r3.byteLength === o3 ? u2.shift() : (r3.byteOffset += o3, r3.byteLength -= o3), e2._queueTotalSize -= o3, Se(e2, o3, t2), l2 -= o3;\n  }\n  return s2;\n}\n__name(we, \"we\");\nfunction Se(e2, t2, r2) {\n  r2.bytesFilled += t2;\n}\n__name(Se, \"Se\");\nfunction ve(e2) {\n  0 === e2._queueTotalSize && e2._closeRequested ? (Ee(e2), Xt(e2._controlledReadableByteStream)) : be(e2);\n}\n__name(ve, \"ve\");\nfunction Re(e2) {\n  null !== e2._byobRequest && (e2._byobRequest._associatedReadableByteStreamController = void 0, e2._byobRequest._view = null, e2._byobRequest = null);\n}\n__name(Re, \"Re\");\nfunction Te(e2) {\n  for (; e2._pendingPullIntos.length > 0; ) {\n    if (0 === e2._queueTotalSize)\n      return;\n    const t2 = e2._pendingPullIntos.peek();\n    we(e2, t2) && (Ce(e2), _e(e2._controlledReadableByteStream, t2));\n  }\n}\n__name(Te, \"Te\");\nfunction qe(e2, t2) {\n  const r2 = e2._pendingPullIntos.peek();\n  Re(e2);\n  \"closed\" === e2._controlledReadableByteStream._state ? function(e3, t3) {\n    \"none\" === t3.readerType && Ce(e3);\n    const r3 = e3._controlledReadableByteStream;\n    if (Le(r3))\n      for (; ze(r3) > 0; )\n        _e(r3, Ce(e3));\n  }(e2, r2) : function(e3, t3, r3) {\n    if (Se(0, t3, r3), \"none\" === r3.readerType)\n      return ge(e3, r3), void Te(e3);\n    if (r3.bytesFilled < r3.elementSize)\n      return;\n    Ce(e3);\n    const o2 = r3.bytesFilled % r3.elementSize;\n    if (o2 > 0) {\n      const t4 = r3.byteOffset + r3.bytesFilled;\n      ye(e3, r3.buffer, t4 - o2, o2);\n    }\n    r3.bytesFilled -= o2, _e(e3._controlledReadableByteStream, r3), Te(e3);\n  }(e2, t2, r2), be(e2);\n}\n__name(qe, \"qe\");\nfunction Ce(e2) {\n  return e2._pendingPullIntos.shift();\n}\n__name(Ce, \"Ce\");\nfunction Ee(e2) {\n  e2._pullAlgorithm = void 0, e2._cancelAlgorithm = void 0;\n}\n__name(Ee, \"Ee\");\nfunction Pe(e2, t2) {\n  const r2 = e2._controlledReadableByteStream;\n  \"readable\" === r2._state && (he(e2), ce(e2), Ee(e2), Jt(r2, t2));\n}\n__name(Pe, \"Pe\");\nfunction We(e2, t2) {\n  const r2 = e2._queue.shift();\n  e2._queueTotalSize -= r2.byteLength, ve(e2);\n  const o2 = new Uint8Array(r2.buffer, r2.byteOffset, r2.byteLength);\n  t2._chunkSteps(o2);\n}\n__name(We, \"We\");\nfunction ke(e2) {\n  const t2 = e2._controlledReadableByteStream._state;\n  return \"errored\" === t2 ? null : \"closed\" === t2 ? 0 : e2._strategyHWM - e2._queueTotalSize;\n}\n__name(ke, \"ke\");\nfunction Oe(e2, t2, r2) {\n  const o2 = Object.create(ReadableByteStreamController.prototype);\n  let n2, a2, i2;\n  n2 = void 0 !== t2.start ? () => t2.start(o2) : () => {\n  }, a2 = void 0 !== t2.pull ? () => t2.pull(o2) : () => c(void 0), i2 = void 0 !== t2.cancel ? (e3) => t2.cancel(e3) : () => c(void 0);\n  const l2 = t2.autoAllocateChunkSize;\n  if (0 === l2)\n    throw new TypeError(\"autoAllocateChunkSize must be greater than 0\");\n  !function(e3, t3, r3, o3, n3, a3, i3) {\n    t3._controlledReadableByteStream = e3, t3._pullAgain = false, t3._pulling = false, t3._byobRequest = null, t3._queue = t3._queueTotalSize = void 0, ce(t3), t3._closeRequested = false, t3._started = false, t3._strategyHWM = a3, t3._pullAlgorithm = o3, t3._cancelAlgorithm = n3, t3._autoAllocateChunkSize = i3, t3._pendingPullIntos = new S(), e3._readableStreamController = t3, b(c(r3()), () => (t3._started = true, be(t3), null), (e4) => (Pe(t3, e4), null));\n  }(e2, o2, n2, a2, i2, r2, l2);\n}\n__name(Oe, \"Oe\");\nfunction Be(e2) {\n  return new TypeError(`ReadableStreamBYOBRequest.prototype.${e2} can only be used on a ReadableStreamBYOBRequest`);\n}\n__name(Be, \"Be\");\nfunction Ae(e2) {\n  return new TypeError(`ReadableByteStreamController.prototype.${e2} can only be used on a ReadableByteStreamController`);\n}\n__name(Ae, \"Ae\");\nfunction je(e2, t2) {\n  e2._reader._readIntoRequests.push(t2);\n}\n__name(je, \"je\");\nfunction ze(e2) {\n  return e2._reader._readIntoRequests.length;\n}\n__name(ze, \"ze\");\nfunction Le(e2) {\n  const t2 = e2._reader;\n  return void 0 !== t2 && !!Fe(t2);\n}\n__name(Le, \"Le\");\nObject.defineProperties(ReadableByteStreamController.prototype, { close: { enumerable: true }, enqueue: { enumerable: true }, error: { enumerable: true }, byobRequest: { enumerable: true }, desiredSize: { enumerable: true } }), n(ReadableByteStreamController.prototype.close, \"close\"), n(ReadableByteStreamController.prototype.enqueue, \"enqueue\"), n(ReadableByteStreamController.prototype.error, \"error\"), \"symbol\" == typeof e.toStringTag && Object.defineProperty(ReadableByteStreamController.prototype, e.toStringTag, { value: \"ReadableByteStreamController\", configurable: true });\nvar ReadableStreamBYOBReader = class {\n  constructor(e2) {\n    if ($(e2, 1, \"ReadableStreamBYOBReader\"), V(e2, \"First parameter\"), Ut(e2))\n      throw new TypeError(\"This stream has already been locked for exclusive reading by another reader\");\n    if (!de(e2._readableStreamController))\n      throw new TypeError(\"Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source\");\n    E(this, e2), this._readIntoRequests = new S();\n  }\n  get closed() {\n    return Fe(this) ? this._closedPromise : d(De(\"closed\"));\n  }\n  cancel(e2) {\n    return Fe(this) ? void 0 === this._ownerReadableStream ? d(k(\"cancel\")) : P(this, e2) : d(De(\"cancel\"));\n  }\n  read(e2) {\n    if (!Fe(this))\n      return d(De(\"read\"));\n    if (!ArrayBuffer.isView(e2))\n      return d(new TypeError(\"view must be an array buffer view\"));\n    if (0 === e2.byteLength)\n      return d(new TypeError(\"view must have non-zero byteLength\"));\n    if (0 === e2.buffer.byteLength)\n      return d(new TypeError(\"view's buffer must have non-zero byteLength\"));\n    if (e2.buffer, void 0 === this._ownerReadableStream)\n      return d(k(\"read from\"));\n    let t2, r2;\n    const o2 = u((e3, o3) => {\n      t2 = e3, r2 = o3;\n    });\n    return function(e3, t3, r3) {\n      const o3 = e3._ownerReadableStream;\n      o3._disturbed = true, \"errored\" === o3._state ? r3._errorSteps(o3._storedError) : function(e4, t4, r4) {\n        const o4 = e4._controlledReadableByteStream;\n        let n2 = 1;\n        t4.constructor !== DataView && (n2 = t4.constructor.BYTES_PER_ELEMENT);\n        const a2 = t4.constructor, i2 = t4.buffer, l2 = { buffer: i2, bufferByteLength: i2.byteLength, byteOffset: t4.byteOffset, byteLength: t4.byteLength, bytesFilled: 0, elementSize: n2, viewConstructor: a2, readerType: \"byob\" };\n        if (e4._pendingPullIntos.length > 0)\n          return e4._pendingPullIntos.push(l2), void je(o4, r4);\n        if (\"closed\" !== o4._state) {\n          if (e4._queueTotalSize > 0) {\n            if (we(e4, l2)) {\n              const t5 = pe(l2);\n              return ve(e4), void r4._chunkSteps(t5);\n            }\n            if (e4._closeRequested) {\n              const t5 = new TypeError(\"Insufficient bytes to fill elements in the given buffer\");\n              return Pe(e4, t5), void r4._errorSteps(t5);\n            }\n          }\n          e4._pendingPullIntos.push(l2), je(o4, r4), be(e4);\n        } else {\n          const e5 = new a2(l2.buffer, l2.byteOffset, 0);\n          r4._closeSteps(e5);\n        }\n      }(o3._readableStreamController, t3, r3);\n    }(this, e2, { _chunkSteps: (e3) => t2({ value: e3, done: false }), _closeSteps: (e3) => t2({ value: e3, done: true }), _errorSteps: (e3) => r2(e3) }), o2;\n  }\n  releaseLock() {\n    if (!Fe(this))\n      throw De(\"releaseLock\");\n    void 0 !== this._ownerReadableStream && function(e2) {\n      W(e2);\n      const t2 = new TypeError(\"Reader was released\");\n      Ie(e2, t2);\n    }(this);\n  }\n};\n__name(ReadableStreamBYOBReader, \"ReadableStreamBYOBReader\");\nfunction Fe(e2) {\n  return !!r(e2) && (!!Object.prototype.hasOwnProperty.call(e2, \"_readIntoRequests\") && e2 instanceof ReadableStreamBYOBReader);\n}\n__name(Fe, \"Fe\");\nfunction Ie(e2, t2) {\n  const r2 = e2._readIntoRequests;\n  e2._readIntoRequests = new S(), r2.forEach((e3) => {\n    e3._errorSteps(t2);\n  });\n}\n__name(Ie, \"Ie\");\nfunction De(e2) {\n  return new TypeError(`ReadableStreamBYOBReader.prototype.${e2} can only be used on a ReadableStreamBYOBReader`);\n}\n__name(De, \"De\");\nfunction $e(e2, t2) {\n  const { highWaterMark: r2 } = e2;\n  if (void 0 === r2)\n    return t2;\n  if (ae(r2) || r2 < 0)\n    throw new RangeError(\"Invalid highWaterMark\");\n  return r2;\n}\n__name($e, \"$e\");\nfunction Me(e2) {\n  const { size: t2 } = e2;\n  return t2 || (() => 1);\n}\n__name(Me, \"Me\");\nfunction Ye(e2, t2) {\n  F(e2, t2);\n  const r2 = null == e2 ? void 0 : e2.highWaterMark, o2 = null == e2 ? void 0 : e2.size;\n  return { highWaterMark: void 0 === r2 ? void 0 : Y(r2), size: void 0 === o2 ? void 0 : Qe(o2, `${t2} has member 'size' that`) };\n}\n__name(Ye, \"Ye\");\nfunction Qe(e2, t2) {\n  return I(e2, t2), (t3) => Y(e2(t3));\n}\n__name(Qe, \"Qe\");\nfunction Ne(e2, t2, r2) {\n  return I(e2, r2), (r3) => w(e2, t2, [r3]);\n}\n__name(Ne, \"Ne\");\nfunction He(e2, t2, r2) {\n  return I(e2, r2), () => w(e2, t2, []);\n}\n__name(He, \"He\");\nfunction xe(e2, t2, r2) {\n  return I(e2, r2), (r3) => g(e2, t2, [r3]);\n}\n__name(xe, \"xe\");\nfunction Ve(e2, t2, r2) {\n  return I(e2, r2), (r3, o2) => w(e2, t2, [r3, o2]);\n}\n__name(Ve, \"Ve\");\nObject.defineProperties(ReadableStreamBYOBReader.prototype, { cancel: { enumerable: true }, read: { enumerable: true }, releaseLock: { enumerable: true }, closed: { enumerable: true } }), n(ReadableStreamBYOBReader.prototype.cancel, \"cancel\"), n(ReadableStreamBYOBReader.prototype.read, \"read\"), n(ReadableStreamBYOBReader.prototype.releaseLock, \"releaseLock\"), \"symbol\" == typeof e.toStringTag && Object.defineProperty(ReadableStreamBYOBReader.prototype, e.toStringTag, { value: \"ReadableStreamBYOBReader\", configurable: true });\nvar Ue = \"function\" == typeof AbortController;\nvar WritableStream = class {\n  constructor(e2 = {}, t2 = {}) {\n    void 0 === e2 ? e2 = null : D(e2, \"First parameter\");\n    const r2 = Ye(t2, \"Second parameter\"), o2 = function(e3, t3) {\n      F(e3, t3);\n      const r3 = null == e3 ? void 0 : e3.abort, o3 = null == e3 ? void 0 : e3.close, n3 = null == e3 ? void 0 : e3.start, a3 = null == e3 ? void 0 : e3.type, i2 = null == e3 ? void 0 : e3.write;\n      return { abort: void 0 === r3 ? void 0 : Ne(r3, e3, `${t3} has member 'abort' that`), close: void 0 === o3 ? void 0 : He(o3, e3, `${t3} has member 'close' that`), start: void 0 === n3 ? void 0 : xe(n3, e3, `${t3} has member 'start' that`), write: void 0 === i2 ? void 0 : Ve(i2, e3, `${t3} has member 'write' that`), type: a3 };\n    }(e2, \"First parameter\");\n    var n2;\n    (n2 = this)._state = \"writable\", n2._storedError = void 0, n2._writer = void 0, n2._writableStreamController = void 0, n2._writeRequests = new S(), n2._inFlightWriteRequest = void 0, n2._closeRequest = void 0, n2._inFlightCloseRequest = void 0, n2._pendingAbortRequest = void 0, n2._backpressure = false;\n    if (void 0 !== o2.type)\n      throw new RangeError(\"Invalid type is specified\");\n    const a2 = Me(r2);\n    !function(e3, t3, r3, o3) {\n      const n3 = Object.create(WritableStreamDefaultController.prototype);\n      let a3, i2, l2, s2;\n      a3 = void 0 !== t3.start ? () => t3.start(n3) : () => {\n      };\n      i2 = void 0 !== t3.write ? (e4) => t3.write(e4, n3) : () => c(void 0);\n      l2 = void 0 !== t3.close ? () => t3.close() : () => c(void 0);\n      s2 = void 0 !== t3.abort ? (e4) => t3.abort(e4) : () => c(void 0);\n      !function(e4, t4, r4, o4, n4, a4, i3, l3) {\n        t4._controlledWritableStream = e4, e4._writableStreamController = t4, t4._queue = void 0, t4._queueTotalSize = void 0, ce(t4), t4._abortReason = void 0, t4._abortController = function() {\n          if (Ue)\n            return new AbortController();\n        }(), t4._started = false, t4._strategySizeAlgorithm = l3, t4._strategyHWM = i3, t4._writeAlgorithm = o4, t4._closeAlgorithm = n4, t4._abortAlgorithm = a4;\n        const s3 = bt(t4);\n        nt(e4, s3);\n        const u2 = r4();\n        b(c(u2), () => (t4._started = true, dt(t4), null), (r5) => (t4._started = true, Ze(e4, r5), null));\n      }(e3, n3, a3, i2, l2, s2, r3, o3);\n    }(this, o2, $e(r2, 1), a2);\n  }\n  get locked() {\n    if (!Ge(this))\n      throw _t(\"locked\");\n    return Xe(this);\n  }\n  abort(e2) {\n    return Ge(this) ? Xe(this) ? d(new TypeError(\"Cannot abort a stream that already has a writer\")) : Je(this, e2) : d(_t(\"abort\"));\n  }\n  close() {\n    return Ge(this) ? Xe(this) ? d(new TypeError(\"Cannot close a stream that already has a writer\")) : rt(this) ? d(new TypeError(\"Cannot close an already-closing stream\")) : Ke(this) : d(_t(\"close\"));\n  }\n  getWriter() {\n    if (!Ge(this))\n      throw _t(\"getWriter\");\n    return new WritableStreamDefaultWriter(this);\n  }\n};\n__name(WritableStream, \"WritableStream\");\nfunction Ge(e2) {\n  return !!r(e2) && (!!Object.prototype.hasOwnProperty.call(e2, \"_writableStreamController\") && e2 instanceof WritableStream);\n}\n__name(Ge, \"Ge\");\nfunction Xe(e2) {\n  return void 0 !== e2._writer;\n}\n__name(Xe, \"Xe\");\nfunction Je(e2, t2) {\n  var r2;\n  if (\"closed\" === e2._state || \"errored\" === e2._state)\n    return c(void 0);\n  e2._writableStreamController._abortReason = t2, null === (r2 = e2._writableStreamController._abortController) || void 0 === r2 || r2.abort(t2);\n  const o2 = e2._state;\n  if (\"closed\" === o2 || \"errored\" === o2)\n    return c(void 0);\n  if (void 0 !== e2._pendingAbortRequest)\n    return e2._pendingAbortRequest._promise;\n  let n2 = false;\n  \"erroring\" === o2 && (n2 = true, t2 = void 0);\n  const a2 = u((r3, o3) => {\n    e2._pendingAbortRequest = { _promise: void 0, _resolve: r3, _reject: o3, _reason: t2, _wasAlreadyErroring: n2 };\n  });\n  return e2._pendingAbortRequest._promise = a2, n2 || et(e2, t2), a2;\n}\n__name(Je, \"Je\");\nfunction Ke(e2) {\n  const t2 = e2._state;\n  if (\"closed\" === t2 || \"errored\" === t2)\n    return d(new TypeError(`The stream (in ${t2} state) is not in the writable state and cannot be closed`));\n  const r2 = u((t3, r3) => {\n    const o3 = { _resolve: t3, _reject: r3 };\n    e2._closeRequest = o3;\n  }), o2 = e2._writer;\n  var n2;\n  return void 0 !== o2 && e2._backpressure && \"writable\" === t2 && Et(o2), ue(n2 = e2._writableStreamController, lt, 0), dt(n2), r2;\n}\n__name(Ke, \"Ke\");\nfunction Ze(e2, t2) {\n  \"writable\" !== e2._state ? tt(e2) : et(e2, t2);\n}\n__name(Ze, \"Ze\");\nfunction et(e2, t2) {\n  const r2 = e2._writableStreamController;\n  e2._state = \"erroring\", e2._storedError = t2;\n  const o2 = e2._writer;\n  void 0 !== o2 && it(o2, t2), !function(e3) {\n    if (void 0 === e3._inFlightWriteRequest && void 0 === e3._inFlightCloseRequest)\n      return false;\n    return true;\n  }(e2) && r2._started && tt(e2);\n}\n__name(et, \"et\");\nfunction tt(e2) {\n  e2._state = \"errored\", e2._writableStreamController[R]();\n  const t2 = e2._storedError;\n  if (e2._writeRequests.forEach((e3) => {\n    e3._reject(t2);\n  }), e2._writeRequests = new S(), void 0 === e2._pendingAbortRequest)\n    return void ot(e2);\n  const r2 = e2._pendingAbortRequest;\n  if (e2._pendingAbortRequest = void 0, r2._wasAlreadyErroring)\n    return r2._reject(t2), void ot(e2);\n  b(e2._writableStreamController[v](r2._reason), () => (r2._resolve(), ot(e2), null), (t3) => (r2._reject(t3), ot(e2), null));\n}\n__name(tt, \"tt\");\nfunction rt(e2) {\n  return void 0 !== e2._closeRequest || void 0 !== e2._inFlightCloseRequest;\n}\n__name(rt, \"rt\");\nfunction ot(e2) {\n  void 0 !== e2._closeRequest && (e2._closeRequest._reject(e2._storedError), e2._closeRequest = void 0);\n  const t2 = e2._writer;\n  void 0 !== t2 && St(t2, e2._storedError);\n}\n__name(ot, \"ot\");\nfunction nt(e2, t2) {\n  const r2 = e2._writer;\n  void 0 !== r2 && t2 !== e2._backpressure && (t2 ? function(e3) {\n    Rt(e3);\n  }(r2) : Et(r2)), e2._backpressure = t2;\n}\n__name(nt, \"nt\");\nObject.defineProperties(WritableStream.prototype, { abort: { enumerable: true }, close: { enumerable: true }, getWriter: { enumerable: true }, locked: { enumerable: true } }), n(WritableStream.prototype.abort, \"abort\"), n(WritableStream.prototype.close, \"close\"), n(WritableStream.prototype.getWriter, \"getWriter\"), \"symbol\" == typeof e.toStringTag && Object.defineProperty(WritableStream.prototype, e.toStringTag, { value: \"WritableStream\", configurable: true });\nvar WritableStreamDefaultWriter = class {\n  constructor(e2) {\n    if ($(e2, 1, \"WritableStreamDefaultWriter\"), function(e3, t3) {\n      if (!Ge(e3))\n        throw new TypeError(`${t3} is not a WritableStream.`);\n    }(e2, \"First parameter\"), Xe(e2))\n      throw new TypeError(\"This stream has already been locked for exclusive writing by another writer\");\n    this._ownerWritableStream = e2, e2._writer = this;\n    const t2 = e2._state;\n    if (\"writable\" === t2)\n      !rt(e2) && e2._backpressure ? Rt(this) : qt(this), gt(this);\n    else if (\"erroring\" === t2)\n      Tt(this, e2._storedError), gt(this);\n    else if (\"closed\" === t2)\n      qt(this), gt(r2 = this), vt(r2);\n    else {\n      const t3 = e2._storedError;\n      Tt(this, t3), wt(this, t3);\n    }\n    var r2;\n  }\n  get closed() {\n    return at(this) ? this._closedPromise : d(mt(\"closed\"));\n  }\n  get desiredSize() {\n    if (!at(this))\n      throw mt(\"desiredSize\");\n    if (void 0 === this._ownerWritableStream)\n      throw yt(\"desiredSize\");\n    return function(e2) {\n      const t2 = e2._ownerWritableStream, r2 = t2._state;\n      if (\"errored\" === r2 || \"erroring\" === r2)\n        return null;\n      if (\"closed\" === r2)\n        return 0;\n      return ct(t2._writableStreamController);\n    }(this);\n  }\n  get ready() {\n    return at(this) ? this._readyPromise : d(mt(\"ready\"));\n  }\n  abort(e2) {\n    return at(this) ? void 0 === this._ownerWritableStream ? d(yt(\"abort\")) : function(e3, t2) {\n      return Je(e3._ownerWritableStream, t2);\n    }(this, e2) : d(mt(\"abort\"));\n  }\n  close() {\n    if (!at(this))\n      return d(mt(\"close\"));\n    const e2 = this._ownerWritableStream;\n    return void 0 === e2 ? d(yt(\"close\")) : rt(e2) ? d(new TypeError(\"Cannot close an already-closing stream\")) : Ke(this._ownerWritableStream);\n  }\n  releaseLock() {\n    if (!at(this))\n      throw mt(\"releaseLock\");\n    void 0 !== this._ownerWritableStream && function(e2) {\n      const t2 = e2._ownerWritableStream, r2 = new TypeError(\"Writer was released and can no longer be used to monitor the stream's closedness\");\n      it(e2, r2), function(e3, t3) {\n        \"pending\" === e3._closedPromiseState ? St(e3, t3) : function(e4, t4) {\n          wt(e4, t4);\n        }(e3, t3);\n      }(e2, r2), t2._writer = void 0, e2._ownerWritableStream = void 0;\n    }(this);\n  }\n  write(e2) {\n    return at(this) ? void 0 === this._ownerWritableStream ? d(yt(\"write to\")) : function(e3, t2) {\n      const r2 = e3._ownerWritableStream, o2 = r2._writableStreamController, n2 = function(e4, t3) {\n        try {\n          return e4._strategySizeAlgorithm(t3);\n        } catch (t4) {\n          return ft(e4, t4), 1;\n        }\n      }(o2, t2);\n      if (r2 !== e3._ownerWritableStream)\n        return d(yt(\"write to\"));\n      const a2 = r2._state;\n      if (\"errored\" === a2)\n        return d(r2._storedError);\n      if (rt(r2) || \"closed\" === a2)\n        return d(new TypeError(\"The stream is closing or closed and cannot be written to\"));\n      if (\"erroring\" === a2)\n        return d(r2._storedError);\n      const i2 = function(e4) {\n        return u((t3, r3) => {\n          const o3 = { _resolve: t3, _reject: r3 };\n          e4._writeRequests.push(o3);\n        });\n      }(r2);\n      return function(e4, t3, r3) {\n        try {\n          ue(e4, t3, r3);\n        } catch (t4) {\n          return void ft(e4, t4);\n        }\n        const o3 = e4._controlledWritableStream;\n        if (!rt(o3) && \"writable\" === o3._state) {\n          nt(o3, bt(e4));\n        }\n        dt(e4);\n      }(o2, t2, n2), i2;\n    }(this, e2) : d(mt(\"write\"));\n  }\n};\n__name(WritableStreamDefaultWriter, \"WritableStreamDefaultWriter\");\nfunction at(e2) {\n  return !!r(e2) && (!!Object.prototype.hasOwnProperty.call(e2, \"_ownerWritableStream\") && e2 instanceof WritableStreamDefaultWriter);\n}\n__name(at, \"at\");\nfunction it(e2, t2) {\n  \"pending\" === e2._readyPromiseState ? Ct(e2, t2) : function(e3, t3) {\n    Tt(e3, t3);\n  }(e2, t2);\n}\n__name(it, \"it\");\nObject.defineProperties(WritableStreamDefaultWriter.prototype, { abort: { enumerable: true }, close: { enumerable: true }, releaseLock: { enumerable: true }, write: { enumerable: true }, closed: { enumerable: true }, desiredSize: { enumerable: true }, ready: { enumerable: true } }), n(WritableStreamDefaultWriter.prototype.abort, \"abort\"), n(WritableStreamDefaultWriter.prototype.close, \"close\"), n(WritableStreamDefaultWriter.prototype.releaseLock, \"releaseLock\"), n(WritableStreamDefaultWriter.prototype.write, \"write\"), \"symbol\" == typeof e.toStringTag && Object.defineProperty(WritableStreamDefaultWriter.prototype, e.toStringTag, { value: \"WritableStreamDefaultWriter\", configurable: true });\nvar lt = {};\nvar WritableStreamDefaultController = class {\n  constructor() {\n    throw new TypeError(\"Illegal constructor\");\n  }\n  get abortReason() {\n    if (!st(this))\n      throw pt(\"abortReason\");\n    return this._abortReason;\n  }\n  get signal() {\n    if (!st(this))\n      throw pt(\"signal\");\n    if (void 0 === this._abortController)\n      throw new TypeError(\"WritableStreamDefaultController.prototype.signal is not supported\");\n    return this._abortController.signal;\n  }\n  error(e2) {\n    if (!st(this))\n      throw pt(\"error\");\n    \"writable\" === this._controlledWritableStream._state && ht(this, e2);\n  }\n  [v](e2) {\n    const t2 = this._abortAlgorithm(e2);\n    return ut(this), t2;\n  }\n  [R]() {\n    ce(this);\n  }\n};\n__name(WritableStreamDefaultController, \"WritableStreamDefaultController\");\nfunction st(e2) {\n  return !!r(e2) && (!!Object.prototype.hasOwnProperty.call(e2, \"_controlledWritableStream\") && e2 instanceof WritableStreamDefaultController);\n}\n__name(st, \"st\");\nfunction ut(e2) {\n  e2._writeAlgorithm = void 0, e2._closeAlgorithm = void 0, e2._abortAlgorithm = void 0, e2._strategySizeAlgorithm = void 0;\n}\n__name(ut, \"ut\");\nfunction ct(e2) {\n  return e2._strategyHWM - e2._queueTotalSize;\n}\n__name(ct, \"ct\");\nfunction dt(e2) {\n  const t2 = e2._controlledWritableStream;\n  if (!e2._started)\n    return;\n  if (void 0 !== t2._inFlightWriteRequest)\n    return;\n  if (\"erroring\" === t2._state)\n    return void tt(t2);\n  if (0 === e2._queue.length)\n    return;\n  const r2 = e2._queue.peek().value;\n  r2 === lt ? function(e3) {\n    const t3 = e3._controlledWritableStream;\n    (function(e4) {\n      e4._inFlightCloseRequest = e4._closeRequest, e4._closeRequest = void 0;\n    })(t3), se(e3);\n    const r3 = e3._closeAlgorithm();\n    ut(e3), b(r3, () => (function(e4) {\n      e4._inFlightCloseRequest._resolve(void 0), e4._inFlightCloseRequest = void 0, \"erroring\" === e4._state && (e4._storedError = void 0, void 0 !== e4._pendingAbortRequest && (e4._pendingAbortRequest._resolve(), e4._pendingAbortRequest = void 0)), e4._state = \"closed\";\n      const t4 = e4._writer;\n      void 0 !== t4 && vt(t4);\n    }(t3), null), (e4) => (function(e5, t4) {\n      e5._inFlightCloseRequest._reject(t4), e5._inFlightCloseRequest = void 0, void 0 !== e5._pendingAbortRequest && (e5._pendingAbortRequest._reject(t4), e5._pendingAbortRequest = void 0), Ze(e5, t4);\n    }(t3, e4), null));\n  }(e2) : function(e3, t3) {\n    const r3 = e3._controlledWritableStream;\n    !function(e4) {\n      e4._inFlightWriteRequest = e4._writeRequests.shift();\n    }(r3);\n    b(e3._writeAlgorithm(t3), () => {\n      !function(e4) {\n        e4._inFlightWriteRequest._resolve(void 0), e4._inFlightWriteRequest = void 0;\n      }(r3);\n      const t4 = r3._state;\n      if (se(e3), !rt(r3) && \"writable\" === t4) {\n        const t5 = bt(e3);\n        nt(r3, t5);\n      }\n      return dt(e3), null;\n    }, (t4) => (\"writable\" === r3._state && ut(e3), function(e4, t5) {\n      e4._inFlightWriteRequest._reject(t5), e4._inFlightWriteRequest = void 0, Ze(e4, t5);\n    }(r3, t4), null));\n  }(e2, r2);\n}\n__name(dt, \"dt\");\nfunction ft(e2, t2) {\n  \"writable\" === e2._controlledWritableStream._state && ht(e2, t2);\n}\n__name(ft, \"ft\");\nfunction bt(e2) {\n  return ct(e2) <= 0;\n}\n__name(bt, \"bt\");\nfunction ht(e2, t2) {\n  const r2 = e2._controlledWritableStream;\n  ut(e2), et(r2, t2);\n}\n__name(ht, \"ht\");\nfunction _t(e2) {\n  return new TypeError(`WritableStream.prototype.${e2} can only be used on a WritableStream`);\n}\n__name(_t, \"_t\");\nfunction pt(e2) {\n  return new TypeError(`WritableStreamDefault