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