@storm-software/linting-tools/bin/chunk-LTEMM6OK.js

⚡ A package containing various linting tools used to validate syntax, enforce design standards, and format code in a Storm workspace.

import {
  __esm,
  __require,
  init_esm_shims
} from "./chunk-6WF54AHT.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) {