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