@storm-software/linting-tools
Version:
⚡ A package containing various linting tools used to validate syntax, enforce design standards, and format code in a Storm workspace.
1,134 lines (1,131 loc) • 158 kB
JavaScript
import {
__esm,
__require,
init_esm_shims
} from "./chunk-LXPMPMVD.js";
// ../../node_modules/.pnpm/node-fetch-native@1.6.7/node_modules/node-fetch-native/dist/shared/node-fetch-native.DfbY2q-x.mjs
function f(e) {
return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
}
var t, o, n;
var init_node_fetch_native_DfbY2q_x = __esm({
"../../node_modules/.pnpm/node-fetch-native@1.6.7/node_modules/node-fetch-native/dist/shared/node-fetch-native.DfbY2q-x.mjs"() {
init_esm_shims();
t = Object.defineProperty;
o = (e, l) => t(e, "name", { value: l, configurable: true });
n = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
o(f, "getDefaultExportFromCjs");
}
});
// ../../node_modules/.pnpm/node-fetch-native@1.6.7/node_modules/node-fetch-native/dist/node.mjs
import Bt from "node:http";
import zs from "node:https";
import st from "node:zlib";
import me, { PassThrough as dr, pipeline as lt } from "node:stream";
import { Buffer as M } from "node:buffer";
import { types as hr, deprecate as pr, promisify as Is } from "node:util";
import { format as js } from "node:url";
import { isIP as Ls } from "node:net";
import { promises as $s, statSync as hi, createReadStream as Ds } from "node:fs";
import { basename as Ms } from "node:path";
function Us(i) {
if (!/^data:/i.test(i)) throw new TypeError('`uri` does not appear to be a Data URI (must begin with "data:")');
i = i.replace(/\r?\n/g, "");
const o2 = i.indexOf(",");
if (o2 === -1 || o2 <= 4) throw new TypeError("malformed data: URI");
const a = i.substring(5, o2).split(";");
let f2 = "", l = false;
const p = a[0] || "text/plain";
let h = p;
for (let A = 1; A < a.length; A++) a[A] === "base64" ? l = true : a[A] && (h += `;${a[A]}`, a[A].indexOf("charset=") === 0 && (f2 = a[A].substring(8)));
!a[0] && !f2.length && (h += ";charset=US-ASCII", f2 = "US-ASCII");
const S = l ? "base64" : "ascii", v = unescape(i.substring(o2 + 1)), w = Buffer.from(v, S);
return w.type = p, w.typeFull = h, w.charset = f2, w;
}
function Ns() {
return bi || (bi = 1, function(i, o2) {
(function(a, f2) {
f2(o2);
})(xs, function(a) {
function f2() {
}
n2(f2, "noop");
function l(e) {
return typeof e == "object" && e !== null || typeof e == "function";
}
n2(l, "typeIsObject");
const p = f2;
function h(e, t2) {
try {
Object.defineProperty(e, "name", { value: t2, configurable: true });
} catch {
}
}
n2(h, "setFunctionName");
const S = Promise, v = Promise.prototype.then, w = Promise.reject.bind(S);
function A(e) {
return new S(e);
}
n2(A, "newPromise");
function T(e) {
return A((t2) => t2(e));
}
n2(T, "promiseResolvedWith");
function b(e) {
return w(e);
}
n2(b, "promiseRejectedWith");
function q(e, t2, r) {
return v.call(e, t2, r);
}
n2(q, "PerformPromiseThen");
function g(e, t2, r) {
q(q(e, t2, r), void 0, p);
}
n2(g, "uponPromise");
function V(e, t2) {
g(e, t2);
}
n2(V, "uponFulfillment");
function I(e, t2) {
g(e, void 0, t2);
}
n2(I, "uponRejection");
function F(e, t2, r) {
return q(e, t2, r);
}
n2(F, "transformPromiseWith");
function Q(e) {
q(e, void 0, p);
}
n2(Q, "setPromiseIsHandledToTrue");
let ge = n2((e) => {
if (typeof queueMicrotask == "function") ge = queueMicrotask;
else {
const t2 = T(void 0);
ge = n2((r) => q(t2, r), "_queueMicrotask");
}
return ge(e);
}, "_queueMicrotask");
function z(e, t2, r) {
if (typeof e != "function") throw new TypeError("Argument is not a function");
return Function.prototype.apply.call(e, t2, r);
}
n2(z, "reflectCall");
function j(e, t2, r) {
try {
return T(z(e, t2, r));
} catch (s) {
return b(s);
}
}
n2(j, "promiseCall");
const U = 16384, bn = class bn {
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(t2) {
const r = this._back;
let s = r;
r._elements.length === U - 1 && (s = { _elements: [], _next: void 0 }), r._elements.push(t2), s !== r && (this._back = s, r._next = s), ++this._size;
}
shift() {
const t2 = this._front;
let r = t2;
const s = this._cursor;
let u = s + 1;
const c = t2._elements, d = c[s];
return u === U && (r = t2._next, u = 0), --this._size, this._cursor = u, t2 !== r && (this._front = r), c[s] = void 0, d;
}
forEach(t2) {
let r = this._cursor, s = this._front, u = s._elements;
for (; (r !== u.length || s._next !== void 0) && !(r === u.length && (s = s._next, u = s._elements, r = 0, u.length === 0)); ) t2(u[r]), ++r;
}
peek() {
const t2 = this._front, r = this._cursor;
return t2._elements[r];
}
};
n2(bn, "SimpleQueue");
let D = bn;
const jt = Symbol("[[AbortSteps]]"), Qn = Symbol("[[ErrorSteps]]"), Ar = Symbol("[[CancelSteps]]"), Br = Symbol("[[PullSteps]]"), kr = Symbol("[[ReleaseSteps]]");
function Yn(e, t2) {
e._ownerReadableStream = t2, t2._reader = e, t2._state === "readable" ? qr(e) : t2._state === "closed" ? xi(e) : Gn(e, t2._storedError);
}
n2(Yn, "ReadableStreamReaderGenericInitialize");
function Wr(e, t2) {
const r = e._ownerReadableStream;
return ie(r, t2);
}
n2(Wr, "ReadableStreamReaderGenericCancel");
function _e(e) {
const t2 = e._ownerReadableStream;
t2._state === "readable" ? Or(e, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")) : Ni(e, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")), t2._readableStreamController[kr](), t2._reader = void 0, e._ownerReadableStream = void 0;
}
n2(_e, "ReadableStreamReaderGenericRelease");
function Lt(e) {
return new TypeError("Cannot " + e + " a stream using a released reader");
}
n2(Lt, "readerLockException");
function qr(e) {
e._closedPromise = A((t2, r) => {
e._closedPromise_resolve = t2, e._closedPromise_reject = r;
});
}
n2(qr, "defaultReaderClosedPromiseInitialize");
function Gn(e, t2) {
qr(e), Or(e, t2);
}
n2(Gn, "defaultReaderClosedPromiseInitializeAsRejected");
function xi(e) {
qr(e), Zn(e);
}
n2(xi, "defaultReaderClosedPromiseInitializeAsResolved");
function Or(e, t2) {
e._closedPromise_reject !== void 0 && (Q(e._closedPromise), e._closedPromise_reject(t2), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0);
}
n2(Or, "defaultReaderClosedPromiseReject");
function Ni(e, t2) {
Gn(e, t2);
}
n2(Ni, "defaultReaderClosedPromiseResetToRejected");
function Zn(e) {
e._closedPromise_resolve !== void 0 && (e._closedPromise_resolve(void 0), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0);
}
n2(Zn, "defaultReaderClosedPromiseResolve");
const Kn = Number.isFinite || function(e) {
return typeof e == "number" && isFinite(e);
}, Hi = Math.trunc || function(e) {
return e < 0 ? Math.ceil(e) : Math.floor(e);
};
function Vi(e) {
return typeof e == "object" || typeof e == "function";
}
n2(Vi, "isDictionary");
function ue(e, t2) {
if (e !== void 0 && !Vi(e)) throw new TypeError(`${t2} is not an object.`);
}
n2(ue, "assertDictionary");
function Z(e, t2) {
if (typeof e != "function") throw new TypeError(`${t2} is not a function.`);
}
n2(Z, "assertFunction");
function Qi(e) {
return typeof e == "object" && e !== null || typeof e == "function";
}
n2(Qi, "isObject");
function Jn(e, t2) {
if (!Qi(e)) throw new TypeError(`${t2} is not an object.`);
}
n2(Jn, "assertObject");
function Se(e, t2, r) {
if (e === void 0) throw new TypeError(`Parameter ${t2} is required in '${r}'.`);
}
n2(Se, "assertRequiredArgument");
function zr(e, t2, r) {
if (e === void 0) throw new TypeError(`${t2} is required in '${r}'.`);
}
n2(zr, "assertRequiredField");
function Ir(e) {
return Number(e);
}
n2(Ir, "convertUnrestrictedDouble");
function Xn(e) {
return e === 0 ? 0 : e;
}
n2(Xn, "censorNegativeZero");
function Yi(e) {
return Xn(Hi(e));
}
n2(Yi, "integerPart");
function Fr(e, t2) {
const s = Number.MAX_SAFE_INTEGER;
let u = Number(e);
if (u = Xn(u), !Kn(u)) throw new TypeError(`${t2} is not a finite number`);
if (u = Yi(u), u < 0 || u > s) throw new TypeError(`${t2} is outside the accepted range of 0 to ${s}, inclusive`);
return !Kn(u) || u === 0 ? 0 : u;
}
n2(Fr, "convertUnsignedLongLongWithEnforceRange");
function jr(e, t2) {
if (!We(e)) throw new TypeError(`${t2} is not a ReadableStream.`);
}
n2(jr, "assertReadableStream");
function Qe(e) {
return new fe(e);
}
n2(Qe, "AcquireReadableStreamDefaultReader");
function eo(e, t2) {
e._reader._readRequests.push(t2);
}
n2(eo, "ReadableStreamAddReadRequest");
function Lr(e, t2, r) {
const u = e._reader._readRequests.shift();
r ? u._closeSteps() : u._chunkSteps(t2);
}
n2(Lr, "ReadableStreamFulfillReadRequest");
function $t(e) {
return e._reader._readRequests.length;
}
n2($t, "ReadableStreamGetNumReadRequests");
function to(e) {
const t2 = e._reader;
return !(t2 === void 0 || !Ee(t2));
}
n2(to, "ReadableStreamHasDefaultReader");
const mn = class mn {
constructor(t2) {
if (Se(t2, 1, "ReadableStreamDefaultReader"), jr(t2, "First parameter"), qe(t2)) throw new TypeError("This stream has already been locked for exclusive reading by another reader");
Yn(this, t2), this._readRequests = new D();
}
get closed() {
return Ee(this) ? this._closedPromise : b(Dt("closed"));
}
cancel(t2 = void 0) {
return Ee(this) ? this._ownerReadableStream === void 0 ? b(Lt("cancel")) : Wr(this, t2) : b(Dt("cancel"));
}
read() {
if (!Ee(this)) return b(Dt("read"));
if (this._ownerReadableStream === void 0) return b(Lt("read from"));
let t2, r;
const s = A((c, d) => {
t2 = c, r = d;
});
return _t(this, { _chunkSteps: n2((c) => t2({ value: c, done: false }), "_chunkSteps"), _closeSteps: n2(() => t2({ value: void 0, done: true }), "_closeSteps"), _errorSteps: n2((c) => r(c), "_errorSteps") }), s;
}
releaseLock() {
if (!Ee(this)) throw Dt("releaseLock");
this._ownerReadableStream !== void 0 && Gi(this);
}
};
n2(mn, "ReadableStreamDefaultReader");
let fe = mn;
Object.defineProperties(fe.prototype, { cancel: { enumerable: true }, read: { enumerable: true }, releaseLock: { enumerable: true }, closed: { enumerable: true } }), h(fe.prototype.cancel, "cancel"), h(fe.prototype.read, "read"), h(fe.prototype.releaseLock, "releaseLock"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(fe.prototype, Symbol.toStringTag, { value: "ReadableStreamDefaultReader", configurable: true });
function Ee(e) {
return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_readRequests") ? false : e instanceof fe;
}
n2(Ee, "IsReadableStreamDefaultReader");
function _t(e, t2) {
const r = e._ownerReadableStream;
r._disturbed = true, r._state === "closed" ? t2._closeSteps() : r._state === "errored" ? t2._errorSteps(r._storedError) : r._readableStreamController[Br](t2);
}
n2(_t, "ReadableStreamDefaultReaderRead");
function Gi(e) {
_e(e);
const t2 = new TypeError("Reader was released");
ro(e, t2);
}
n2(Gi, "ReadableStreamDefaultReaderRelease");
function ro(e, t2) {
const r = e._readRequests;
e._readRequests = new D(), r.forEach((s) => {
s._errorSteps(t2);
});
}
n2(ro, "ReadableStreamDefaultReaderErrorReadRequests");
function Dt(e) {
return new TypeError(`ReadableStreamDefaultReader.prototype.${e} can only be used on a ReadableStreamDefaultReader`);
}
n2(Dt, "defaultReaderBrandCheckException");
const Zi = Object.getPrototypeOf(Object.getPrototypeOf(async function* () {
}).prototype), yn = class yn {
constructor(t2, r) {
this._ongoingPromise = void 0, this._isFinished = false, this._reader = t2, this._preventCancel = r;
}
next() {
const t2 = n2(() => this._nextSteps(), "nextSteps");
return this._ongoingPromise = this._ongoingPromise ? F(this._ongoingPromise, t2, t2) : t2(), this._ongoingPromise;
}
return(t2) {
const r = n2(() => this._returnSteps(t2), "returnSteps");
return this._ongoingPromise ? F(this._ongoingPromise, r, r) : r();
}
_nextSteps() {
if (this._isFinished) return Promise.resolve({ value: void 0, done: true });
const t2 = this._reader;
let r, s;
const u = A((d, m) => {
r = d, s = m;
});
return _t(t2, { _chunkSteps: n2((d) => {
this._ongoingPromise = void 0, ge(() => r({ value: d, done: false }));
}, "_chunkSteps"), _closeSteps: n2(() => {
this._ongoingPromise = void 0, this._isFinished = true, _e(t2), r({ value: void 0, done: true });
}, "_closeSteps"), _errorSteps: n2((d) => {
this._ongoingPromise = void 0, this._isFinished = true, _e(t2), s(d);
}, "_errorSteps") }), u;
}
_returnSteps(t2) {
if (this._isFinished) return Promise.resolve({ value: t2, done: true });
this._isFinished = true;
const r = this._reader;
if (!this._preventCancel) {
const s = Wr(r, t2);
return _e(r), F(s, () => ({ value: t2, done: true }));
}
return _e(r), T({ value: t2, done: true });
}
};
n2(yn, "ReadableStreamAsyncIteratorImpl");
let Mt = yn;
const no = { next() {
return oo(this) ? this._asyncIteratorImpl.next() : b(io("next"));
}, return(e) {
return oo(this) ? this._asyncIteratorImpl.return(e) : b(io("return"));
} };
Object.setPrototypeOf(no, Zi);
function Ki(e, t2) {
const r = Qe(e), s = new Mt(r, t2), u = Object.create(no);
return u._asyncIteratorImpl = s, u;
}
n2(Ki, "AcquireReadableStreamAsyncIterator");
function oo(e) {
if (!l(e) || !Object.prototype.hasOwnProperty.call(e, "_asyncIteratorImpl")) return false;
try {
return e._asyncIteratorImpl instanceof Mt;
} catch {
return false;
}
}
n2(oo, "IsReadableStreamAsyncIterator");
function io(e) {
return new TypeError(`ReadableStreamAsyncIterator.${e} can only be used on a ReadableSteamAsyncIterator`);
}
n2(io, "streamAsyncIteratorBrandCheckException");
const ao = Number.isNaN || function(e) {
return e !== e;
};
var $r, Dr, Mr;
function St(e) {
return e.slice();
}
n2(St, "CreateArrayFromList");
function so(e, t2, r, s, u) {
new Uint8Array(e).set(new Uint8Array(r, s, u), t2);
}
n2(so, "CopyDataBlockBytes");
let we = n2((e) => (typeof e.transfer == "function" ? we = n2((t2) => t2.transfer(), "TransferArrayBuffer") : typeof structuredClone == "function" ? we = n2((t2) => structuredClone(t2, { transfer: [t2] }), "TransferArrayBuffer") : we = n2((t2) => t2, "TransferArrayBuffer"), we(e)), "TransferArrayBuffer"), Ae = n2((e) => (typeof e.detached == "boolean" ? Ae = n2((t2) => t2.detached, "IsDetachedBuffer") : Ae = n2((t2) => t2.byteLength === 0, "IsDetachedBuffer"), Ae(e)), "IsDetachedBuffer");
function lo(e, t2, r) {
if (e.slice) return e.slice(t2, r);
const s = r - t2, u = new ArrayBuffer(s);
return so(u, 0, e, t2, s), u;
}
n2(lo, "ArrayBufferSlice");
function Ut(e, t2) {
const r = e[t2];
if (r != null) {
if (typeof r != "function") throw new TypeError(`${String(t2)} is not a function`);
return r;
}
}
n2(Ut, "GetMethod");
function Ji(e) {
const t2 = { [Symbol.iterator]: () => e.iterator }, r = async function* () {
return yield* t2;
}(), s = r.next;
return { iterator: r, nextMethod: s, done: false };
}
n2(Ji, "CreateAsyncFromSyncIterator");
const Ur = (Mr = ($r = Symbol.asyncIterator) !== null && $r !== void 0 ? $r : (Dr = Symbol.for) === null || Dr === void 0 ? void 0 : Dr.call(Symbol, "Symbol.asyncIterator")) !== null && Mr !== void 0 ? Mr : "@@asyncIterator";
function uo(e, t2 = "sync", r) {
if (r === void 0) if (t2 === "async") {
if (r = Ut(e, Ur), r === void 0) {
const c = Ut(e, Symbol.iterator), d = uo(e, "sync", c);
return Ji(d);
}
} else r = Ut(e, Symbol.iterator);
if (r === void 0) throw new TypeError("The object is not iterable");
const s = z(r, e, []);
if (!l(s)) throw new TypeError("The iterator method must return an object");
const u = s.next;
return { iterator: s, nextMethod: u, done: false };
}
n2(uo, "GetIterator");
function Xi(e) {
const t2 = z(e.nextMethod, e.iterator, []);
if (!l(t2)) throw new TypeError("The iterator.next() method must return an object");
return t2;
}
n2(Xi, "IteratorNext");
function ea(e) {
return !!e.done;
}
n2(ea, "IteratorComplete");
function ta(e) {
return e.value;
}
n2(ta, "IteratorValue");
function ra(e) {
return !(typeof e != "number" || ao(e) || e < 0);
}
n2(ra, "IsNonNegativeNumber");
function fo(e) {
const t2 = lo(e.buffer, e.byteOffset, e.byteOffset + e.byteLength);
return new Uint8Array(t2);
}
n2(fo, "CloneAsUint8Array");
function xr(e) {
const t2 = e._queue.shift();
return e._queueTotalSize -= t2.size, e._queueTotalSize < 0 && (e._queueTotalSize = 0), t2.value;
}
n2(xr, "DequeueValue");
function Nr(e, t2, r) {
if (!ra(r) || r === 1 / 0) throw new RangeError("Size must be a finite, non-NaN, non-negative number.");
e._queue.push({ value: t2, size: r }), e._queueTotalSize += r;
}
n2(Nr, "EnqueueValueWithSize");
function na(e) {
return e._queue.peek().value;
}
n2(na, "PeekQueueValue");
function Be(e) {
e._queue = new D(), e._queueTotalSize = 0;
}
n2(Be, "ResetQueue");
function co(e) {
return e === DataView;
}
n2(co, "isDataViewConstructor");
function oa(e) {
return co(e.constructor);
}
n2(oa, "isDataView");
function ia(e) {
return co(e) ? 1 : e.BYTES_PER_ELEMENT;
}
n2(ia, "arrayBufferViewElementSize");
const gn = class gn {
constructor() {
throw new TypeError("Illegal constructor");
}
get view() {
if (!Hr(this)) throw Zr("view");
return this._view;
}
respond(t2) {
if (!Hr(this)) throw Zr("respond");
if (Se(t2, 1, "respond"), t2 = Fr(t2, "First parameter"), this._associatedReadableByteStreamController === void 0) throw new TypeError("This BYOB request has been invalidated");
if (Ae(this._view.buffer)) throw new TypeError("The BYOB request's buffer has been detached and so cannot be used as a response");
Vt(this._associatedReadableByteStreamController, t2);
}
respondWithNewView(t2) {
if (!Hr(this)) throw Zr("respondWithNewView");
if (Se(t2, 1, "respondWithNewView"), !ArrayBuffer.isView(t2)) 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 (Ae(t2.buffer)) throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");
Qt(this._associatedReadableByteStreamController, t2);
}
};
n2(gn, "ReadableStreamBYOBRequest");
let Re = gn;
Object.defineProperties(Re.prototype, { respond: { enumerable: true }, respondWithNewView: { enumerable: true }, view: { enumerable: true } }), h(Re.prototype.respond, "respond"), h(Re.prototype.respondWithNewView, "respondWithNewView"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(Re.prototype, Symbol.toStringTag, { value: "ReadableStreamBYOBRequest", configurable: true });
const _n = class _n {
constructor() {
throw new TypeError("Illegal constructor");
}
get byobRequest() {
if (!Ie(this)) throw Rt("byobRequest");
return Gr(this);
}
get desiredSize() {
if (!Ie(this)) throw Rt("desiredSize");
return Ro(this);
}
close() {
if (!Ie(this)) throw Rt("close");
if (this._closeRequested) throw new TypeError("The stream has already been closed; do not close it again!");
const t2 = this._controlledReadableByteStream._state;
if (t2 !== "readable") throw new TypeError(`The stream (in ${t2} state) is not in the readable state and cannot be closed`);
wt(this);
}
enqueue(t2) {
if (!Ie(this)) throw Rt("enqueue");
if (Se(t2, 1, "enqueue"), !ArrayBuffer.isView(t2)) throw new TypeError("chunk must be an array buffer view");
if (t2.byteLength === 0) throw new TypeError("chunk must have non-zero byteLength");
if (t2.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`);
Ht(this, t2);
}
error(t2 = void 0) {
if (!Ie(this)) throw Rt("error");
K(this, t2);
}
[Ar](t2) {
ho(this), Be(this);
const r = this._cancelAlgorithm(t2);
return Nt(this), r;
}
[Br](t2) {
const r = this._controlledReadableByteStream;
if (this._queueTotalSize > 0) {
wo(this, t2);
return;
}
const s = this._autoAllocateChunkSize;
if (s !== void 0) {
let u;
try {
u = new ArrayBuffer(s);
} catch (d) {
t2._errorSteps(d);
return;
}
const c = { buffer: u, bufferByteLength: s, byteOffset: 0, byteLength: s, bytesFilled: 0, minimumFill: 1, elementSize: 1, viewConstructor: Uint8Array, readerType: "default" };
this._pendingPullIntos.push(c);
}
eo(r, t2), Fe(this);
}
[kr]() {
if (this._pendingPullIntos.length > 0) {
const t2 = this._pendingPullIntos.peek();
t2.readerType = "none", this._pendingPullIntos = new D(), this._pendingPullIntos.push(t2);
}
}
};
n2(_n, "ReadableByteStreamController");
let te = _n;
Object.defineProperties(te.prototype, { close: { enumerable: true }, enqueue: { enumerable: true }, error: { enumerable: true }, byobRequest: { enumerable: true }, desiredSize: { enumerable: true } }), h(te.prototype.close, "close"), h(te.prototype.enqueue, "enqueue"), h(te.prototype.error, "error"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(te.prototype, Symbol.toStringTag, { value: "ReadableByteStreamController", configurable: true });
function Ie(e) {
return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_controlledReadableByteStream") ? false : e instanceof te;
}
n2(Ie, "IsReadableByteStreamController");
function Hr(e) {
return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_associatedReadableByteStreamController") ? false : e instanceof Re;
}
n2(Hr, "IsReadableStreamBYOBRequest");
function Fe(e) {
if (!fa(e)) return;
if (e._pulling) {
e._pullAgain = true;
return;
}
e._pulling = true;
const r = e._pullAlgorithm();
g(r, () => (e._pulling = false, e._pullAgain && (e._pullAgain = false, Fe(e)), null), (s) => (K(e, s), null));
}
n2(Fe, "ReadableByteStreamControllerCallPullIfNeeded");
function ho(e) {
Qr(e), e._pendingPullIntos = new D();
}
n2(ho, "ReadableByteStreamControllerClearPendingPullIntos");
function Vr(e, t2) {
let r = false;
e._state === "closed" && (r = true);
const s = po(t2);
t2.readerType === "default" ? Lr(e, s, r) : ma(e, s, r);
}
n2(Vr, "ReadableByteStreamControllerCommitPullIntoDescriptor");
function po(e) {
const t2 = e.bytesFilled, r = e.elementSize;
return new e.viewConstructor(e.buffer, e.byteOffset, t2 / r);
}
n2(po, "ReadableByteStreamControllerConvertPullIntoDescriptor");
function xt(e, t2, r, s) {
e._queue.push({ buffer: t2, byteOffset: r, byteLength: s }), e._queueTotalSize += s;
}
n2(xt, "ReadableByteStreamControllerEnqueueChunkToQueue");
function bo(e, t2, r, s) {
let u;
try {
u = lo(t2, r, r + s);
} catch (c) {
throw K(e, c), c;
}
xt(e, u, 0, s);
}
n2(bo, "ReadableByteStreamControllerEnqueueClonedChunkToQueue");
function mo(e, t2) {
t2.bytesFilled > 0 && bo(e, t2.buffer, t2.byteOffset, t2.bytesFilled), Ye(e);
}
n2(mo, "ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue");
function yo(e, t2) {
const r = Math.min(e._queueTotalSize, t2.byteLength - t2.bytesFilled), s = t2.bytesFilled + r;
let u = r, c = false;
const d = s % t2.elementSize, m = s - d;
m >= t2.minimumFill && (u = m - t2.bytesFilled, c = true);
const R = e._queue;
for (; u > 0; ) {
const y = R.peek(), C = Math.min(u, y.byteLength), P = t2.byteOffset + t2.bytesFilled;
so(t2.buffer, P, y.buffer, y.byteOffset, C), y.byteLength === C ? R.shift() : (y.byteOffset += C, y.byteLength -= C), e._queueTotalSize -= C, go(e, C, t2), u -= C;
}
return c;
}
n2(yo, "ReadableByteStreamControllerFillPullIntoDescriptorFromQueue");
function go(e, t2, r) {
r.bytesFilled += t2;
}
n2(go, "ReadableByteStreamControllerFillHeadPullIntoDescriptor");
function _o(e) {
e._queueTotalSize === 0 && e._closeRequested ? (Nt(e), At(e._controlledReadableByteStream)) : Fe(e);
}
n2(_o, "ReadableByteStreamControllerHandleQueueDrain");
function Qr(e) {
e._byobRequest !== null && (e._byobRequest._associatedReadableByteStreamController = void 0, e._byobRequest._view = null, e._byobRequest = null);
}
n2(Qr, "ReadableByteStreamControllerInvalidateBYOBRequest");
function Yr(e) {
for (; e._pendingPullIntos.length > 0; ) {
if (e._queueTotalSize === 0) return;
const t2 = e._pendingPullIntos.peek();
yo(e, t2) && (Ye(e), Vr(e._controlledReadableByteStream, t2));
}
}
n2(Yr, "ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue");
function aa(e) {
const t2 = e._controlledReadableByteStream._reader;
for (; t2._readRequests.length > 0; ) {
if (e._queueTotalSize === 0) return;
const r = t2._readRequests.shift();
wo(e, r);
}
}
n2(aa, "ReadableByteStreamControllerProcessReadRequestsUsingQueue");
function sa(e, t2, r, s) {
const u = e._controlledReadableByteStream, c = t2.constructor, d = ia(c), { byteOffset: m, byteLength: R } = t2, y = r * d;
let C;
try {
C = we(t2.buffer);
} catch (B) {
s._errorSteps(B);
return;
}
const P = { buffer: C, bufferByteLength: C.byteLength, byteOffset: m, byteLength: R, bytesFilled: 0, minimumFill: y, elementSize: d, viewConstructor: c, readerType: "byob" };
if (e._pendingPullIntos.length > 0) {
e._pendingPullIntos.push(P), Po(u, s);
return;
}
if (u._state === "closed") {
const B = new c(P.buffer, P.byteOffset, 0);
s._closeSteps(B);
return;
}
if (e._queueTotalSize > 0) {
if (yo(e, P)) {
const B = po(P);
_o(e), s._chunkSteps(B);
return;
}
if (e._closeRequested) {
const B = new TypeError("Insufficient bytes to fill elements in the given buffer");
K(e, B), s._errorSteps(B);
return;
}
}
e._pendingPullIntos.push(P), Po(u, s), Fe(e);
}
n2(sa, "ReadableByteStreamControllerPullInto");
function la(e, t2) {
t2.readerType === "none" && Ye(e);
const r = e._controlledReadableByteStream;
if (Kr(r)) for (; vo(r) > 0; ) {
const s = Ye(e);
Vr(r, s);
}
}
n2(la, "ReadableByteStreamControllerRespondInClosedState");
function ua(e, t2, r) {
if (go(e, t2, r), r.readerType === "none") {
mo(e, r), Yr(e);
return;
}
if (r.bytesFilled < r.minimumFill) return;
Ye(e);
const s = r.bytesFilled % r.elementSize;
if (s > 0) {
const u = r.byteOffset + r.bytesFilled;
bo(e, r.buffer, u - s, s);
}
r.bytesFilled -= s, Vr(e._controlledReadableByteStream, r), Yr(e);
}
n2(ua, "ReadableByteStreamControllerRespondInReadableState");
function So(e, t2) {
const r = e._pendingPullIntos.peek();
Qr(e), e._controlledReadableByteStream._state === "closed" ? la(e, r) : ua(e, t2, r), Fe(e);
}
n2(So, "ReadableByteStreamControllerRespondInternal");
function Ye(e) {
return e._pendingPullIntos.shift();
}
n2(Ye, "ReadableByteStreamControllerShiftPendingPullInto");
function fa(e) {
const t2 = e._controlledReadableByteStream;
return t2._state !== "readable" || e._closeRequested || !e._started ? false : !!(to(t2) && $t(t2) > 0 || Kr(t2) && vo(t2) > 0 || Ro(e) > 0);
}
n2(fa, "ReadableByteStreamControllerShouldCallPull");
function Nt(e) {
e._pullAlgorithm = void 0, e._cancelAlgorithm = void 0;
}
n2(Nt, "ReadableByteStreamControllerClearAlgorithms");
function wt(e) {
const t2 = e._controlledReadableByteStream;
if (!(e._closeRequested || t2._state !== "readable")) {
if (e._queueTotalSize > 0) {
e._closeRequested = true;
return;
}
if (e._pendingPullIntos.length > 0) {
const r = e._pendingPullIntos.peek();
if (r.bytesFilled % r.elementSize !== 0) {
const s = new TypeError("Insufficient bytes to fill elements in the given buffer");
throw K(e, s), s;
}
}
Nt(e), At(t2);
}
}
n2(wt, "ReadableByteStreamControllerClose");
function Ht(e, t2) {
const r = e._controlledReadableByteStream;
if (e._closeRequested || r._state !== "readable") return;
const { buffer: s, byteOffset: u, byteLength: c } = t2;
if (Ae(s)) throw new TypeError("chunk's buffer is detached and so cannot be enqueued");
const d = we(s);
if (e._pendingPullIntos.length > 0) {
const m = e._pendingPullIntos.peek();
if (Ae(m.buffer)) throw new TypeError("The BYOB request's buffer has been detached and so cannot be filled with an enqueued chunk");
Qr(e), m.buffer = we(m.buffer), m.readerType === "none" && mo(e, m);
}
if (to(r)) if (aa(e), $t(r) === 0) xt(e, d, u, c);
else {
e._pendingPullIntos.length > 0 && Ye(e);
const m = new Uint8Array(d, u, c);
Lr(r, m, false);
}
else Kr(r) ? (xt(e, d, u, c), Yr(e)) : xt(e, d, u, c);
Fe(e);
}
n2(Ht, "ReadableByteStreamControllerEnqueue");
function K(e, t2) {
const r = e._controlledReadableByteStream;
r._state === "readable" && (ho(e), Be(e), Nt(e), Zo(r, t2));
}
n2(K, "ReadableByteStreamControllerError");
function wo(e, t2) {
const r = e._queue.shift();
e._queueTotalSize -= r.byteLength, _o(e);
const s = new Uint8Array(r.buffer, r.byteOffset, r.byteLength);
t2._chunkSteps(s);
}
n2(wo, "ReadableByteStreamControllerFillReadRequestFromQueue");
function Gr(e) {
if (e._byobRequest === null && e._pendingPullIntos.length > 0) {
const t2 = e._pendingPullIntos.peek(), r = new Uint8Array(t2.buffer, t2.byteOffset + t2.bytesFilled, t2.byteLength - t2.bytesFilled), s = Object.create(Re.prototype);
da(s, e, r), e._byobRequest = s;
}
return e._byobRequest;
}
n2(Gr, "ReadableByteStreamControllerGetBYOBRequest");
function Ro(e) {
const t2 = e._controlledReadableByteStream._state;
return t2 === "errored" ? null : t2 === "closed" ? 0 : e._strategyHWM - e._queueTotalSize;
}
n2(Ro, "ReadableByteStreamControllerGetDesiredSize");
function Vt(e, t2) {
const r = e._pendingPullIntos.peek();
if (e._controlledReadableByteStream._state === "closed") {
if (t2 !== 0) throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream");
} else {
if (t2 === 0) throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");
if (r.bytesFilled + t2 > r.byteLength) throw new RangeError("bytesWritten out of range");
}
r.buffer = we(r.buffer), So(e, t2);
}
n2(Vt, "ReadableByteStreamControllerRespond");
function Qt(e, t2) {
const r = e._pendingPullIntos.peek();
if (e._controlledReadableByteStream._state === "closed") {
if (t2.byteLength !== 0) throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream");
} else if (t2.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 !== t2.byteOffset) throw new RangeError("The region specified by view does not match byobRequest");
if (r.bufferByteLength !== t2.buffer.byteLength) throw new RangeError("The buffer of view has different capacity than byobRequest");
if (r.bytesFilled + t2.byteLength > r.byteLength) throw new RangeError("The region specified by view is larger than byobRequest");
const u = t2.byteLength;
r.buffer = we(t2.buffer), So(e, u);
}
n2(Qt, "ReadableByteStreamControllerRespondWithNewView");
function To(e, t2, r, s, u, c, d) {
t2._controlledReadableByteStream = e, t2._pullAgain = false, t2._pulling = false, t2._byobRequest = null, t2._queue = t2._queueTotalSize = void 0, Be(t2), t2._closeRequested = false, t2._started = false, t2._strategyHWM = c, t2._pullAlgorithm = s, t2._cancelAlgorithm = u, t2._autoAllocateChunkSize = d, t2._pendingPullIntos = new D(), e._readableStreamController = t2;
const m = r();
g(T(m), () => (t2._started = true, Fe(t2), null), (R) => (K(t2, R), null));
}
n2(To, "SetUpReadableByteStreamController");
function ca(e, t2, r) {
const s = Object.create(te.prototype);
let u, c, d;
t2.start !== void 0 ? u = n2(() => t2.start(s), "startAlgorithm") : u = n2(() => {
}, "startAlgorithm"), t2.pull !== void 0 ? c = n2(() => t2.pull(s), "pullAlgorithm") : c = n2(() => T(void 0), "pullAlgorithm"), t2.cancel !== void 0 ? d = n2((R) => t2.cancel(R), "cancelAlgorithm") : d = n2(() => T(void 0), "cancelAlgorithm");
const m = t2.autoAllocateChunkSize;
if (m === 0) throw new TypeError("autoAllocateChunkSize must be greater than 0");
To(e, s, u, c, d, r, m);
}
n2(ca, "SetUpReadableByteStreamControllerFromUnderlyingSource");
function da(e, t2, r) {
e._associatedReadableByteStreamController = t2, e._view = r;
}
n2(da, "SetUpReadableStreamBYOBRequest");
function Zr(e) {
return new TypeError(`ReadableStreamBYOBRequest.prototype.${e} can only be used on a ReadableStreamBYOBRequest`);
}
n2(Zr, "byobRequestBrandCheckException");
function Rt(e) {
return new TypeError(`ReadableByteStreamController.prototype.${e} can only be used on a ReadableByteStreamController`);
}
n2(Rt, "byteStreamControllerBrandCheckException");
function ha(e, t2) {
ue(e, t2);
const r = e?.mode;
return { mode: r === void 0 ? void 0 : pa(r, `${t2} has member 'mode' that`) };
}
n2(ha, "convertReaderOptions");
function pa(e, t2) {
if (e = `${e}`, e !== "byob") throw new TypeError(`${t2} '${e}' is not a valid enumeration value for ReadableStreamReaderMode`);
return e;
}
n2(pa, "convertReadableStreamReaderMode");
function ba(e, t2) {
var r;
ue(e, t2);
const s = (r = e?.min) !== null && r !== void 0 ? r : 1;
return { min: Fr(s, `${t2} has member 'min' that`) };
}
n2(ba, "convertByobReadOptions");
function Co(e) {
return new ce(e);
}
n2(Co, "AcquireReadableStreamBYOBReader");
function Po(e, t2) {
e._reader._readIntoRequests.push(t2);
}
n2(Po, "ReadableStreamAddReadIntoRequest");
function ma(e, t2, r) {
const u = e._reader._readIntoRequests.shift();
r ? u._closeSteps(t2) : u._chunkSteps(t2);
}
n2(ma, "ReadableStreamFulfillReadIntoRequest");
function vo(e) {
return e._reader._readIntoRequests.length;
}
n2(vo, "ReadableStreamGetNumReadIntoRequests");
function Kr(e) {
const t2 = e._reader;
return !(t2 === void 0 || !je(t2));
}
n2(Kr, "ReadableStreamHasBYOBReader");
const Sn = class Sn {
constructor(t2) {
if (Se(t2, 1, "ReadableStreamBYOBReader"), jr(t2, "First parameter"), qe(t2)) throw new TypeError("This stream has already been locked for exclusive reading by another reader");
if (!Ie(t2._readableStreamController)) throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");
Yn(this, t2), this._readIntoRequests = new D();
}
get closed() {
return je(this) ? this._closedPromise : b(Yt("closed"));
}
cancel(t2 = void 0) {
return je(this) ? this._ownerReadableStream === void 0 ? b(Lt("cancel")) : Wr(this, t2) : b(Yt("cancel"));
}
read(t2, r = {}) {
if (!je(this)) return b(Yt("read"));
if (!ArrayBuffer.isView(t2)) return b(new TypeError("view must be an array buffer view"));
if (t2.byteLength === 0) return b(new TypeError("view must have non-zero byteLength"));
if (t2.buffer.byteLength === 0) return b(new TypeError("view's buffer must have non-zero byteLength"));
if (Ae(t2.buffer)) return b(new TypeError("view's buffer has been detached"));
let s;
try {
s = ba(r, "options");
} catch (y) {
return b(y);
}
const u = s.min;
if (u === 0) return b(new TypeError("options.min must be greater than 0"));
if (oa(t2)) {
if (u > t2.byteLength) return b(new RangeError("options.min must be less than or equal to view's byteLength"));
} else if (u > t2.length) return b(new RangeError("options.min must be less than or equal to view's length"));
if (this._ownerReadableStream === void 0) return b(Lt("read from"));
let c, d;
const m = A((y, C) => {
c = y, d = C;
});
return Eo(this, t2, u, { _chunkSteps: n2((y) => c({ value: y, done: false }), "_chunkSteps"), _closeSteps: n2((y) => c({ value: y, done: true }), "_closeSteps"), _errorSteps: n2((y) => d(y), "_errorSteps") }), m;
}
releaseLock() {
if (!je(this)) throw Yt("releaseLock");
this._ownerReadableStream !== void 0 && ya(this);
}
};
n2(Sn, "ReadableStreamBYOBReader");
let ce = Sn;
Object.defineProperties(ce.prototype, { cancel: { enumerable: true }, read: { enumerable: true }, releaseLock: { enumerable: true }, closed: { enumerable: true } }), h(ce.prototype.cancel, "cancel"), h(ce.prototype.read, "read"), h(ce.prototype.releaseLock, "releaseLock"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(ce.prototype, Symbol.toStringTag, { value: "ReadableStreamBYOBReader", configurable: true });
function je(e) {
return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_readIntoRequests") ? false : e instanceof ce;
}
n2(je, "IsReadableStreamBYOBReader");
function Eo(e, t2, r, s) {
const u = e._ownerReadableStream;
u._disturbed = true, u._state === "errored" ? s._errorSteps(u._storedError) : sa(u._readableStreamController, t2, r, s);
}
n2(Eo, "ReadableStreamBYOBReaderRead");
function ya(e) {
_e(e);
const t2 = new TypeError("Reader was released");
Ao(e, t2);
}
n2(ya, "ReadableStreamBYOBReaderRelease");
function Ao(e, t2) {
const r = e._readIntoRequests;
e._readIntoRequests = new D(), r.forEach((s) => {
s._errorSteps(t2);
});
}
n2(Ao, "ReadableStreamBYOBReaderErrorReadIntoRequests");
function Yt(e) {
return new TypeError(`ReadableStreamBYOBReader.prototype.${e} can only be used on a ReadableStreamBYOBReader`);
}
n2(Yt, "byobReaderBrandCheckException");
function Tt(e, t2) {
const { highWaterMark: r } = e;
if (r === void 0) return t2;
if (ao(r) || r < 0) throw new RangeError("Invalid highWaterMark");
return r;
}
n2(Tt, "ExtractHighWaterMark");
function Gt(e) {
const { size: t2 } = e;
return t2 || (() => 1);
}
n2(Gt, "ExtractSizeAlgorithm");
function Zt(e, t2) {
ue(e, t2);
const r = e?.highWaterMark, s = e?.size;
return { highWaterMark: r === void 0 ? void 0 : Ir(r), size: s === void 0 ? void 0 : ga(s, `${t2} has member 'size' that`) };
}
n2(Zt, "convertQueuingStrategy");
function ga(e, t2) {
return Z(e, t2), (r) => Ir(e(r));
}
n2(ga, "convertQueuingStrategySize");
function _a(e, t2) {
ue(e, t2);
const r = e?.abort, s = e?.close, u = e?.start, c = e?.type, d = e?.write;
return { abort: r === void 0 ? void 0 : Sa(r, e, `${t2} has member 'abort' that`), close: s === void 0 ? void 0 : wa(s, e, `${t2} has member 'close' that`), start: u === void 0 ? void 0 : Ra(u, e, `${t2} has member 'start' that`), write: d === void 0 ? void 0 : Ta(d, e, `${t2} has member 'write' that`), type: c };
}
n2(_a, "convertUnderlyingSink");
function Sa(e, t2, r) {
return Z(e, r), (s) => j(e, t2, [s]);
}
n2(Sa, "convertUnderlyingSinkAbortCallback");
function wa(e, t2, r) {
return Z(e, r), () => j(e, t2, []);
}
n2(wa, "convertUnderlyingSinkCloseCallback");
function Ra(e, t2, r) {
return Z(e, r), (s) => z(e, t2, [s]);
}
n2(Ra, "convertUnderlyingSinkStartCallback");
function Ta(e, t2, r) {
return Z(e, r), (s, u) => j(e, t2, [s, u]);
}
n2(Ta, "convertUnderlyingSinkWriteCallback");
function Bo(e, t2) {
if (!Ge(e)) throw new TypeError(`${t2} is not a WritableStream.`);
}
n2(Bo, "assertWritableStream");
function Ca(e) {
if (typeof e != "object" || e === null) return false;
try {
return typeof e.aborted == "boolean";
} catch {
return false;
}
}
n2(Ca, "isAbortSignal");
const Pa = typeof AbortController == "function";
function va() {
if (Pa) return new AbortController();
}
n2(va, "createAbortController");
const wn = class wn {
constructor(t2 = {}, r = {}) {
t2 === void 0 ? t2 = null : Jn(t2, "First parameter");
const s = Zt(r, "Second parameter"), u = _a(t2, "First parameter");
if (Wo(this), u.type !== void 0) throw new RangeError("Invalid type is specified");
const d = Gt(s), m = Tt(s, 1);
Da(this, u, m, d);
}
get locked() {
if (!Ge(this)) throw tr("locked");
return Ze(this);
}
abort(t2 = void 0) {
return Ge(this) ? Ze(this) ? b(new TypeError("Cannot abort a stream that already has a writer")) : Kt(this, t2) : b(tr("abort"));
}
close() {
return Ge(this) ? Ze(this) ? b(new TypeError("Cannot close a stream that already has a writer")) : he(this) ? b(new TypeError("Cannot close an already-closing stream")) : qo(this) : b(tr("close"));
}
getWriter() {
if (!Ge(this)) throw tr("getWriter");
return ko(this);
}
};
n2(wn, "WritableStream");
let de = wn;
Object.defineProperties(de.prototype, { abort: { enumerable: true }, close: { enumerable: true }, getWriter: { enumerable: true }, locked: { enumerable: true } }), h(de.prototype.abort, "abort"), h(de.prototype.close, "close"), h(de.prototype.getWriter, "getWriter"), typeof Symbol.toStringTag == "symbol" && Object.defineProperty(de.prototype, Symbol.toStringTag, { value: "WritableStream", configurable: true });
function ko(e) {
return new re(e);
}
n2(ko, "AcquireWritableStreamDefaultWriter");
function Ea(e, t2, r, s, u = 1, c = () => 1) {
const d = Object.create(de.prototype);
Wo(d);
const m = Object.create(ke.prototype);
return Lo(d, m, e, t2, r, s, u, c), d;
}
n2(Ea, "CreateWritableStream");
function Wo(e) {
e._state = "writable", e._storedError = void 0, e._writer = void 0, e._writableStreamController = void 0, e._writeRequests = new D(), e._inFlightWriteRequest = void 0, e._closeRequest = void 0, e._inFlightCloseRequest = void 0, e._pendingAbortRequest = void 0, e._backpressure = false;
}
n2(Wo, "InitializeWritableStream");
function Ge(e) {
return !l(e) || !Object.prototype.hasOwnProperty.call(e, "_writableStreamController") ? false : e instanceof de;
}
n2(Ge, "IsWritableStream");
function Ze(e) {
return e._writer !== void 0;
}
n2(Ze, "IsWritableStreamLocked");
function Kt(e, t2) {
var r;
if (e._state === "closed" || e._state === "errored") return T(void 0);
e._writableStreamController._abortReason = t2, (r = e._writableStreamController._abortController) === null || r === void 0 || r.abort(t2);
const s = e._state;
if (s === "closed" || s === "errored") return T(void 0);
if (e._pendingAbortRequest !== void 0) return e._pendingAbortRequest._promise;
let u = false;
s === "erroring" && (u = true, t2 = void 0);
const c = A((d, m) => {
e._pendingAbortRequest = { _promise: void 0, _resolve: d, _reject: m, _reason: t2, _wasAlreadyErroring: u };
});
return e._pendingAbortRequest._promise = c, u || Xr(e, t2), c;
}
n2(Kt, "WritableStreamAbort");
function qo(e) {
const t2 = e._state;
if (t2 === "closed" || t2 === "errored") return b(new TypeError(`The stream (in ${t2} state) is not in the writable state and cannot be closed`));
const r = A((u, c) => {
const d = { _resolve: u, _reject: c };
e._closeRequest = d;
}), s = e._writer;
return s !== void 0 && e._backpressure && t2 === "writable" && ln(s), Ma(e._writableStreamController), r;
}
n2(qo, "WritableStreamClose");
function Aa(e) {
return A((r, s) => {
const u = { _resolve: r, _reject: s };
e._writeRequests.push(u);
});
}
n2(Aa, "WritableStreamAddWriteRequest");
function Jr(e, t2) {