next-ssr-middleware 1.1.2 → 1.1.4

package/dist/index.cjs

@@ -0,0 +1,3254 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _koa_bodyparser = require("@koa/bodyparser");
+_koa_bodyparser = __toESM(_koa_bodyparser);
+let _koa_router = require("@koa/router");
+let koa = require("koa");
+koa = __toESM(koa);
+let jsonwebtoken = require("jsonwebtoken");
+let web_utility = require("web-utility");
+//#region source/API.ts
+function withKoa(...parameters) {
+	let option;
+	let middlewares = [];
+	if (typeof parameters[0] === "function") {
+		option = void 0;
+		middlewares = parameters;
+	} else [option, ...middlewares] = parameters;
+	const app = new koa.default(option).use((0, _koa_bodyparser.default)());
+	for (const middleware of middlewares) app.use(middleware);
+	return app.callback();
+}
+const pageApiRouteOf = (path) => decodeURI(path).match(/pages(\/api\/.+)\.(j|t)s/)?.[1]?.split("/[")[0]?.replace(/\/index$/, "");
+const createKoaRouter = (moduleURI, option) => new _koa_router.Router({
+	...option,
+	prefix: pageApiRouteOf(moduleURI)
+});
+function withKoaRouter(...parameters) {
+	let option;
+	let router;
+	let middlewares = [];
+	if (!parameters[1] || typeof parameters[1] === "function") [router, ...middlewares] = parameters;
+	else [option, router, ...middlewares] = parameters;
+	return withKoa(option, router.routes(), router.allowedMethods(), ...middlewares);
+}
+//#endregion
+//#region source/SSR/compose.ts
+function compose(...middlewares) {
+	return ((context) => {
+		const [first, ...rest] = middlewares;
+		const next = async () => await rest.shift()?.(context, next) || { props: {} };
+		return first(context, next);
+	});
+}
+//#endregion
+//#region node_modules/.pnpm/web-streams-polyfill@4.3.0/node_modules/web-streams-polyfill/dist/ponyfill.mjs
+/**
+* @license
+* web-streams-polyfill v4.3.0
+* Copyright 2026 Mattias Buelens, Diwank Singh Tomer and other contributors.
+* This code is released under the MIT license.
+* SPDX-License-Identifier: MIT
+*/
+function e() {}
+function t(e) {
+	return "object" == typeof e && null !== e || "function" == typeof e;
+}
+const r = e;
+function o(e, t) {
+	try {
+		Object.defineProperty(e, "name", {
+			value: t,
+			configurable: !0
+		});
+	} catch (e) {}
+}
+const n = Promise;
+const i = Promise.resolve.bind(n);
+const a = Promise.prototype.then;
+const s = Promise.reject.bind(n);
+const l = i;
+function u(e) {
+	return new n(e);
+}
+function c(e) {
+	return u((t) => t(e));
+}
+function d(e) {
+	return s(e);
+}
+function f(e, t, r) {
+	return a.call(e, t, r);
+}
+function h(e, t, o) {
+	f(f(e, t, o), void 0, r);
+}
+function b(e, t) {
+	h(e, t);
+}
+function _(e, t) {
+	h(e, void 0, t);
+}
+function m(e, t, r) {
+	return f(e, t, r);
+}
+function p(e) {
+	f(e, void 0, r);
+}
+let y = (e) => {
+	if ("function" == typeof queueMicrotask) y = queueMicrotask;
+	else {
+		const e = c(void 0);
+		y = (t) => f(e, t);
+	}
+	return y(e);
+};
+function S(e, t, r) {
+	if ("function" != typeof e) throw new TypeError("Argument is not a function");
+	return Function.prototype.apply.call(e, t, r);
+}
+function g(e, t, r) {
+	try {
+		return c(S(e, t, r));
+	} catch (e) {
+		return d(e);
+	}
+}
+var v = class {
+	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(e) {
+		const t = this._back;
+		let r = t;
+		16383 === t._elements.length && (r = {
+			_elements: [],
+			_next: void 0
+		}), t._elements.push(e), r !== t && (this._back = r, t._next = r), ++this._size;
+	}
+	shift() {
+		const e = this._front;
+		let t = e;
+		const r = this._cursor;
+		let o = r + 1;
+		const n = e._elements, i = n[r];
+		return 16384 === o && (t = e._next, o = 0), --this._size, this._cursor = o, e !== t && (this._front = t), n[r] = void 0, i;
+	}
+	forEach(e) {
+		let t = this._cursor, r = this._front, o = r._elements;
+		for (; !(t === o.length && void 0 === r._next || t === o.length && (r = r._next, o = r._elements, t = 0, 0 === o.length));) e(o[t]), ++t;
+	}
+	peek() {
+		const e = this._front, t = this._cursor;
+		return e._elements[t];
+	}
+};
+const w = Symbol("[[AbortSteps]]");
+const R = Symbol("[[ErrorSteps]]");
+const T = Symbol("[[CancelSteps]]");
+const P = Symbol("[[PullSteps]]");
+const C = Symbol("[[CanPullSyncSteps]]");
+const q = Symbol("[[ReleaseSteps]]");
+function E(e, t) {
+	e._ownerReadableStream = t, t._reader = e, "readable" === t._state ? j(e) : "closed" === t._state ? function(e) {
+		j(e), z(e);
+	}(e) : k(e, t._storedError);
+}
+function W(e, t) {
+	return Mr(e._ownerReadableStream, t);
+}
+function O(e) {
+	const t = e._ownerReadableStream;
+	"readable" === t._state ? A(e, /* @__PURE__ */ new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")) : function(e, t) {
+		k(e, t);
+	}(e, /* @__PURE__ */ new TypeError("Reader was released and can no longer be used to monitor the stream's closedness")), t._readableStreamController[q](), t._reader = void 0, e._ownerReadableStream = void 0;
+}
+function B(e) {
+	return /* @__PURE__ */ new TypeError("Cannot " + e + " a stream using a released reader");
+}
+function j(e) {
+	e._closedPromise = u((t, r) => {
+		e._closedPromise_resolve = t, e._closedPromise_reject = r;
+	});
+}
+function k(e, t) {
+	j(e), A(e, t);
+}
+function A(e, t) {
+	void 0 !== e._closedPromise_reject && (p(e._closedPromise), e._closedPromise_reject(t), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0);
+}
+function z(e) {
+	void 0 !== e._closedPromise_resolve && (e._closedPromise_resolve(void 0), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0);
+}
+const D = Number.isFinite || function(e) {
+	return "number" == typeof e && isFinite(e);
+};
+const F = Math.trunc || function(e) {
+	return e < 0 ? Math.ceil(e) : Math.floor(e);
+};
+function L(e, t) {
+	if (void 0 !== e && "object" != typeof (r = e) && "function" != typeof r) throw new TypeError(`${t} is not an object.`);
+	var r;
+}
+function I(e, t) {
+	if ("function" != typeof e) throw new TypeError(`${t} is not a function.`);
+}
+function $(e, t) {
+	if (!function(e) {
+		return "object" == typeof e && null !== e || "function" == typeof e;
+	}(e)) throw new TypeError(`${t} is not an object.`);
+}
+function M(e, t, r) {
+	if (void 0 === e) throw new TypeError(`Parameter ${t} is required in '${r}'.`);
+}
+function Y(e, t, r) {
+	if (void 0 === e) throw new TypeError(`${t} is required in '${r}'.`);
+}
+function x(e) {
+	return Number(e);
+}
+function Q(e) {
+	return 0 === e ? 0 : e;
+}
+function N(e, t) {
+	const r = Number.MAX_SAFE_INTEGER;
+	let o = Number(e);
+	if (o = Q(o), !D(o)) throw new TypeError(`${t} is not a finite number`);
+	if (o = function(e) {
+		return Q(F(e));
+	}(o), o < 0 || o > r) throw new TypeError(`${t} is outside the accepted range of 0 to ${r}, inclusive`);
+	return D(o) && 0 !== o ? o : 0;
+}
+function H(e, t) {
+	if (!Ir(e)) throw new TypeError(`${t} is not a ReadableStream.`);
+}
+function V(e) {
+	return new ReadableStreamDefaultReader(e);
+}
+function U(e, t) {
+	e._reader._readRequests.push(t);
+}
+function G(e, t, r) {
+	const o = e._reader._readRequests.shift();
+	r ? o._closeSteps() : o._chunkSteps(t);
+}
+function X(e) {
+	return e._reader._readRequests.length;
+}
+function J(e) {
+	const t = e._reader;
+	return void 0 !== t && !!ee(t);
+}
+var ReadableStreamDefaultReader = class {
+	constructor(e) {
+		if (M(e, 1, "ReadableStreamDefaultReader"), H(e, "First parameter"), $r(e)) throw new TypeError("This stream has already been locked for exclusive reading by another reader");
+		E(this, e), this._readRequests = new v();
+	}
+	get closed() {
+		return ee(this) ? this._closedPromise : d(ne("closed"));
+	}
+	cancel(e = void 0) {
+		return ee(this) ? void 0 === this._ownerReadableStream ? d(B("cancel")) : W(this, e) : d(ne("cancel"));
+	}
+	read() {
+		if (!ee(this)) return d(ne("read"));
+		if (void 0 === this._ownerReadableStream) return d(B("read from"));
+		const e = re(this) ? new Z() : new K();
+		return te(this, e), e._promise;
+	}
+	releaseLock() {
+		if (!ee(this)) throw ne("releaseLock");
+		void 0 !== this._ownerReadableStream && function(e) {
+			O(e);
+			oe(e, /* @__PURE__ */ new TypeError("Reader was released"));
+		}(this);
+	}
+};
+Object.defineProperties(ReadableStreamDefaultReader.prototype, {
+	cancel: { enumerable: !0 },
+	read: { enumerable: !0 },
+	releaseLock: { enumerable: !0 },
+	closed: { enumerable: !0 }
+}), o(ReadableStreamDefaultReader.prototype.cancel, "cancel"), o(ReadableStreamDefaultReader.prototype.read, "read"), o(ReadableStreamDefaultReader.prototype.releaseLock, "releaseLock"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(ReadableStreamDefaultReader.prototype, Symbol.toStringTag, {
+	value: "ReadableStreamDefaultReader",
+	configurable: !0
+});
+var K = class {
+	constructor() {
+		this._promise = u((e, t) => {
+			this._resolvePromise = e, this._rejectPromise = t;
+		});
+	}
+	_chunkSteps(e) {
+		this._resolvePromise({
+			value: e,
+			done: !1
+		});
+	}
+	_closeSteps() {
+		this._resolvePromise({
+			value: void 0,
+			done: !0
+		});
+	}
+	_errorSteps(e) {
+		this._rejectPromise(e);
+	}
+};
+var Z = class {
+	constructor() {
+		this._promise = void 0;
+	}
+	_chunkSteps(e) {
+		this._promise = l({
+			value: e,
+			done: !1
+		});
+	}
+	_closeSteps() {
+		this._promise = l({
+			value: void 0,
+			done: !0
+		});
+	}
+	_errorSteps(e) {
+		this._promise = d(e);
+	}
+};
+function ee(e) {
+	return !!t(e) && !!Object.prototype.hasOwnProperty.call(e, "_readRequests") && e instanceof ReadableStreamDefaultReader;
+}
+function te(e, t) {
+	const r = e._ownerReadableStream;
+	r._disturbed = !0, "closed" === r._state ? t._closeSteps() : "errored" === r._state ? t._errorSteps(r._storedError) : r._readableStreamController[P](t);
+}
+function re(e) {
+	const t = e._ownerReadableStream;
+	return "closed" === t._state || "errored" === t._state || t._readableStreamController[C]();
+}
+function oe(e, t) {
+	const r = e._readRequests;
+	e._readRequests = new v(), r.forEach((e) => {
+		e._errorSteps(t);
+	});
+}
+function ne(e) {
+	return /* @__PURE__ */ new TypeError(`ReadableStreamDefaultReader.prototype.${e} can only be used on a ReadableStreamDefaultReader`);
+}
+var ie;
+var ae;
+var se;
+function le(e) {
+	return e.slice();
+}
+function ue(e, t, r, o, n) {
+	new Uint8Array(e).set(new Uint8Array(r, o, n), t);
+}
+let ce = (e) => (ce = "function" == typeof e.transfer ? (e) => e.transfer() : "function" == typeof structuredClone ? (e) => structuredClone(e, { transfer: [e] }) : (e) => e, ce(e));
+let de = (e) => (de = "boolean" == typeof e.detached ? (e) => e.detached : (e) => 0 === e.byteLength, de(e));
+function fe(e, t, r) {
+	if (e.slice) return e.slice(t, r);
+	const o = r - t, n = new ArrayBuffer(o);
+	return ue(n, 0, e, t, o), n;
+}
+function he(e, t) {
+	const r = e[t];
+	if (null != r) {
+		if ("function" != typeof r) throw new TypeError(`${String(t)} is not a function`);
+		return r;
+	}
+}
+function be(e) {
+	try {
+		const t = e.done, r = e.value;
+		return f(l(r), (e) => ({
+			done: t,
+			value: e
+		}));
+	} catch (e) {
+		return d(e);
+	}
+}
+const _e = null !== (se = null !== (ie = Symbol.asyncIterator) && void 0 !== ie ? ie : null === (ae = Symbol.for) || void 0 === ae ? void 0 : ae.call(Symbol, "Symbol.asyncIterator")) && void 0 !== se ? se : "@@asyncIterator";
+function me(e, r = "sync", o) {
+	if (void 0 === o) if ("async" === r) {
+		if (void 0 === (o = he(e, _e))) return function(e) {
+			const r = {
+				next() {
+					let t;
+					try {
+						t = pe(e);
+					} catch (e) {
+						return d(e);
+					}
+					return be(t);
+				},
+				return(r) {
+					let o;
+					try {
+						const t = he(e.iterator, "return");
+						if (void 0 === t) return c({
+							done: !0,
+							value: r
+						});
+						o = S(t, e.iterator, [r]);
+					} catch (e) {
+						return d(e);
+					}
+					return t(o) ? be(o) : d(/* @__PURE__ */ new TypeError("The iterator.return() method must return an object"));
+				}
+			};
+			return {
+				iterator: r,
+				nextMethod: r.next,
+				done: !1
+			};
+		}(me(e, "sync", he(e, Symbol.iterator)));
+	} else o = he(e, Symbol.iterator);
+	if (void 0 === o) throw new TypeError("The object is not iterable");
+	const n = S(o, e, []);
+	if (!t(n)) throw new TypeError("The iterator method must return an object");
+	return {
+		iterator: n,
+		nextMethod: n.next,
+		done: !1
+	};
+}
+function pe(e) {
+	const r = S(e.nextMethod, e.iterator, []);
+	if (!t(r)) throw new TypeError("The iterator.next() method must return an object");
+	return r;
+}
+var ye = class {
+	constructor(e, t) {
+		this._ongoingPromise = void 0, this._isFinished = !1, this._reader = e, this._preventCancel = t;
+	}
+	next() {
+		const e = () => this._nextSteps();
+		return this._ongoingPromise = this._ongoingPromise ? m(this._ongoingPromise, e, e) : e(), this._ongoingPromise;
+	}
+	return(e) {
+		const t = () => this._returnSteps(e);
+		return this._ongoingPromise = this._ongoingPromise ? m(this._ongoingPromise, t, t) : t(), this._ongoingPromise;
+	}
+	_nextSteps() {
+		if (this._isFinished) return Promise.resolve({
+			value: void 0,
+			done: !0
+		});
+		const e = this._reader, t = new Se(this);
+		return te(e, t), t._promise;
+	}
+	_returnSteps(e) {
+		if (this._isFinished) return Promise.resolve({
+			value: e,
+			done: !0
+		});
+		this._isFinished = !0;
+		const t = this._reader;
+		if (!this._preventCancel) {
+			const r = W(t, e);
+			return O(t), m(r, () => ({
+				value: e,
+				done: !0
+			}));
+		}
+		return O(t), c({
+			value: e,
+			done: !0
+		});
+	}
+};
+var Se = class {
+	constructor(e) {
+		this._iterator = e, this._promise = u((e, t) => {
+			this._resolvePromise = e, this._rejectPromise = t;
+		});
+	}
+	_chunkSteps(e) {
+		this._iterator._ongoingPromise = void 0, y(() => this._resolvePromise({
+			value: e,
+			done: !1
+		}));
+	}
+	_closeSteps() {
+		const e = this._iterator;
+		e._ongoingPromise = void 0, e._isFinished = !0, O(e._reader), this._resolvePromise({
+			value: void 0,
+			done: !0
+		});
+	}
+	_errorSteps(e) {
+		const t = this._iterator;
+		t._ongoingPromise = void 0, t._isFinished = !0, O(t._reader), this._rejectPromise(e);
+	}
+};
+const ge = {
+	next() {
+		return ve(this) ? this._asyncIteratorImpl.next() : d(we("next"));
+	},
+	return(e) {
+		return ve(this) ? this._asyncIteratorImpl.return(e) : d(we("return"));
+	},
+	[_e]() {
+		return this;
+	}
+};
+function ve(e) {
+	if (!t(e)) return !1;
+	if (!Object.prototype.hasOwnProperty.call(e, "_asyncIteratorImpl")) return !1;
+	try {
+		return e._asyncIteratorImpl instanceof ye;
+	} catch (e) {
+		return !1;
+	}
+}
+function we(e) {
+	return /* @__PURE__ */ new TypeError(`ReadableStreamAsyncIterator.${e} can only be used on a ReadableSteamAsyncIterator`);
+}
+Object.defineProperty(ge, _e, { enumerable: !1 });
+const Re = Number.isNaN || function(e) {
+	return e != e;
+};
+function Te(e) {
+	const t = fe(e.buffer, e.byteOffset, e.byteOffset + e.byteLength);
+	return new Uint8Array(t);
+}
+function Pe(e) {
+	const t = e._queue.shift();
+	return e._queueTotalSize -= t.size, e._queueTotalSize < 0 && (e._queueTotalSize = 0), t.value;
+}
+function Ce(e, t, r) {
+	if ("number" != typeof (o = r) || Re(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 qe(e) {
+	e._queue = new v(), e._queueTotalSize = 0;
+}
+function Ee(e) {
+	return e === DataView;
+}
+function We(e) {
+	return Ee(e) ? 1 : e.BYTES_PER_ELEMENT;
+}
+var ReadableStreamBYOBRequest = class {
+	constructor() {
+		throw new TypeError("Illegal constructor");
+	}
+	get view() {
+		if (!Be(this)) throw ot("view");
+		return this._view;
+	}
+	respond(e) {
+		if (!Be(this)) throw ot("respond");
+		if (M(e, 1, "respond"), e = N(e, "First parameter"), void 0 === this._associatedReadableByteStreamController) throw new TypeError("This BYOB request has been invalidated");
+		if (de(this._view.buffer)) throw new TypeError("The BYOB request's buffer has been detached and so cannot be used as a response");
+		et(this._associatedReadableByteStreamController, e);
+	}
+	respondWithNewView(e) {
+		if (!Be(this)) throw ot("respondWithNewView");
+		if (M(e, 1, "respondWithNewView"), !ArrayBuffer.isView(e)) throw new TypeError("You can only respond with array buffer views");
+		if (void 0 === this._associatedReadableByteStreamController) throw new TypeError("This BYOB request has been invalidated");
+		if (de(e.buffer)) throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");
+		tt(this._associatedReadableByteStreamController, e);
+	}
+};
+Object.defineProperties(ReadableStreamBYOBRequest.prototype, {
+	respond: { enumerable: !0 },
+	respondWithNewView: { enumerable: !0 },
+	view: { enumerable: !0 }
+}), o(ReadableStreamBYOBRequest.prototype.respond, "respond"), o(ReadableStreamBYOBRequest.prototype.respondWithNewView, "respondWithNewView"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(ReadableStreamBYOBRequest.prototype, Symbol.toStringTag, {
+	value: "ReadableStreamBYOBRequest",
+	configurable: !0
+});
+var ReadableByteStreamController = class {
+	constructor() {
+		throw new TypeError("Illegal constructor");
+	}
+	get byobRequest() {
+		if (!Oe(this)) throw nt("byobRequest");
+		return Ke(this);
+	}
+	get desiredSize() {
+		if (!Oe(this)) throw nt("desiredSize");
+		return Ze(this);
+	}
+	close() {
+		if (!Oe(this)) throw nt("close");
+		if (this._closeRequested) throw new TypeError("The stream has already been closed; do not close it again!");
+		const e = this._controlledReadableByteStream._state;
+		if ("readable" !== e) throw new TypeError(`The stream (in ${e} state) is not in the readable state and cannot be closed`);
+		Ue(this);
+	}
+	enqueue(e) {
+		if (!Oe(this)) throw nt("enqueue");
+		if (M(e, 1, "enqueue"), !ArrayBuffer.isView(e)) throw new TypeError("chunk must be an array buffer view");
+		if (0 === e.byteLength) throw new TypeError("chunk must have non-zero byteLength");
+		if (0 === e.buffer.byteLength) throw new TypeError("chunk's buffer must have non-zero byteLength");
+		if (this._closeRequested) throw new TypeError("stream is closed or draining");
+		const t = this._controlledReadableByteStream._state;
+		if ("readable" !== t) throw new TypeError(`The stream (in ${t} state) is not in the readable state and cannot be enqueued to`);
+		Ge(this, e);
+	}
+	error(e = void 0) {
+		if (!Oe(this)) throw nt("error");
+		Xe(this, e);
+	}
+	[T](e) {
+		ke(this), qe(this);
+		const t = this._cancelAlgorithm(e);
+		return Ve(this), t;
+	}
+	[P](e) {
+		const t = this._controlledReadableByteStream;
+		if (this._queueTotalSize > 0) return void Je(this, e);
+		const r = this._autoAllocateChunkSize;
+		if (void 0 !== r) {
+			let t;
+			try {
+				t = new ArrayBuffer(r);
+			} catch (t) {
+				e._errorSteps(t);
+				return;
+			}
+			const o = {
+				buffer: t,
+				bufferByteLength: r,
+				byteOffset: 0,
+				byteLength: r,
+				bytesFilled: 0,
+				minimumFill: 1,
+				elementSize: 1,
+				viewConstructor: Uint8Array,
+				readerType: "default"
+			};
+			this._pendingPullIntos.push(o);
+		}
+		U(t, e), je(this);
+	}
+	[C]() {
+		return this._queueTotalSize > 0;
+	}
+	[q]() {
+		if (this._pendingPullIntos.length > 0) {
+			const e = this._pendingPullIntos.peek();
+			e.readerType = "none", this._pendingPullIntos = new v(), this._pendingPullIntos.push(e);
+		}
+	}
+};
+function Oe(e) {
+	return !!t(e) && !!Object.prototype.hasOwnProperty.call(e, "_controlledReadableByteStream") && e instanceof ReadableByteStreamController;
+}
+function Be(e) {
+	return !!t(e) && !!Object.prototype.hasOwnProperty.call(e, "_associatedReadableByteStreamController") && e instanceof ReadableStreamBYOBRequest;
+}
+function je(e) {
+	if (!function(e) {
+		const t = e._controlledReadableByteStream;
+		if ("readable" !== t._state) return !1;
+		if (e._closeRequested) return !1;
+		if (!e._started) return !1;
+		if (J(t) && X(t) > 0) return !0;
+		if (ut(t) && lt(t) > 0) return !0;
+		if (Ze(e) > 0) return !0;
+		return !1;
+	}(e)) return;
+	if (e._pulling) return void (e._pullAgain = !0);
+	e._pulling = !0;
+	h(e._pullAlgorithm(), () => (e._pulling = !1, e._pullAgain && (e._pullAgain = !1, je(e)), null), (t) => (Xe(e, t), null));
+}
+function ke(e) {
+	xe(e), e._pendingPullIntos = new v();
+}
+function Ae(e, t) {
+	let r = !1;
+	"closed" === e._state && (r = !0);
+	const o = De(t);
+	"default" === t.readerType ? G(e, o, r) : function(e, t, r) {
+		const n = e._reader._readIntoRequests.shift();
+		r ? n._closeSteps(t) : n._chunkSteps(t);
+	}(e, o, r);
+}
+function ze(e, t) {
+	for (let r = 0; r < t.length; ++r) Ae(e, t[r]);
+}
+function De(e) {
+	const t = e.bytesFilled, r = e.elementSize;
+	return new e.viewConstructor(e.buffer, e.byteOffset, t / r);
+}
+function Fe(e, t, r, o) {
+	e._queue.push({
+		buffer: t,
+		byteOffset: r,
+		byteLength: o
+	}), e._queueTotalSize += o;
+}
+function Le(e, t, r, o) {
+	let n;
+	try {
+		n = fe(t, r, r + o);
+	} catch (t) {
+		throw Xe(e, t), t;
+	}
+	Fe(e, n, 0, o);
+}
+function Ie(e, t) {
+	t.bytesFilled > 0 && Le(e, t.buffer, t.byteOffset, t.bytesFilled), He(e);
+}
+function $e(e, t) {
+	const r = Math.min(e._queueTotalSize, t.byteLength - t.bytesFilled), o = t.bytesFilled + r;
+	let n = r, i = !1;
+	const a = o - o % t.elementSize;
+	a >= t.minimumFill && (n = a - t.bytesFilled, i = !0);
+	const s = e._queue;
+	for (; n > 0;) {
+		const r = s.peek(), o = Math.min(n, r.byteLength), i = t.byteOffset + t.bytesFilled;
+		ue(t.buffer, i, r.buffer, r.byteOffset, o), r.byteLength === o ? s.shift() : (r.byteOffset += o, r.byteLength -= o), e._queueTotalSize -= o, Me(e, o, t), n -= o;
+	}
+	return i;
+}
+function Me(e, t, r) {
+	r.bytesFilled += t;
+}
+function Ye(e) {
+	0 === e._queueTotalSize && e._closeRequested ? (Ve(e), Yr(e._controlledReadableByteStream)) : je(e);
+}
+function xe(e) {
+	null !== e._byobRequest && (e._byobRequest._associatedReadableByteStreamController = void 0, e._byobRequest._view = null, e._byobRequest = null);
+}
+function Qe(e) {
+	const t = [];
+	for (; e._pendingPullIntos.length > 0 && 0 !== e._queueTotalSize;) {
+		const r = e._pendingPullIntos.peek();
+		$e(e, r) && (He(e), t.push(r));
+	}
+	return t;
+}
+function Ne(e, t) {
+	const r = e._pendingPullIntos.peek();
+	xe(e);
+	"closed" === e._controlledReadableByteStream._state ? function(e, t) {
+		"none" === t.readerType && He(e);
+		const r = e._controlledReadableByteStream;
+		if (ut(r)) {
+			const t = [];
+			for (; t.length < lt(r);) t.push(He(e));
+			ze(r, t);
+		}
+	}(e, r) : function(e, t, r) {
+		if (Me(0, t, r), "none" === r.readerType) {
+			Ie(e, r);
+			const t = Qe(e);
+			ze(e._controlledReadableByteStream, t);
+			return;
+		}
+		if (r.bytesFilled < r.minimumFill) return;
+		He(e);
+		const o = r.bytesFilled % r.elementSize;
+		if (o > 0) {
+			const t = r.byteOffset + r.bytesFilled;
+			Le(e, r.buffer, t - o, o);
+		}
+		r.bytesFilled -= o;
+		const n = Qe(e);
+		Ae(e._controlledReadableByteStream, r), ze(e._controlledReadableByteStream, n);
+	}(e, t, r), je(e);
+}
+function He(e) {
+	return e._pendingPullIntos.shift();
+}
+function Ve(e) {
+	e._pullAlgorithm = void 0, e._cancelAlgorithm = void 0;
+}
+function Ue(e) {
+	const t = e._controlledReadableByteStream;
+	if (!e._closeRequested && "readable" === t._state) if (e._queueTotalSize > 0) e._closeRequested = !0;
+	else {
+		if (e._pendingPullIntos.length > 0) {
+			const t = e._pendingPullIntos.peek();
+			if (t.bytesFilled % t.elementSize !== 0) {
+				const t = /* @__PURE__ */ new TypeError("Insufficient bytes to fill elements in the given buffer");
+				throw Xe(e, t), t;
+			}
+		}
+		Ve(e), Yr(t);
+	}
+}
+function Ge(e, t) {
+	const r = e._controlledReadableByteStream;
+	if (e._closeRequested || "readable" !== r._state) return;
+	const { buffer: o, byteOffset: n, byteLength: i } = t;
+	if (de(o)) throw new TypeError("chunk's buffer is detached and so cannot be enqueued");
+	const a = ce(o);
+	if (e._pendingPullIntos.length > 0) {
+		const t = e._pendingPullIntos.peek();
+		if (de(t.buffer)) throw new TypeError("The BYOB request's buffer has been detached and so cannot be filled with an enqueued chunk");
+		xe(e), t.buffer = ce(t.buffer), "none" === t.readerType && Ie(e, t);
+	}
+	if (J(r)) if (function(e) {
+		const t = e._controlledReadableByteStream._reader;
+		for (; t._readRequests.length > 0;) {
+			if (0 === e._queueTotalSize) return;
+			Je(e, t._readRequests.shift());
+		}
+	}(e), 0 === X(r)) Fe(e, a, n, i);
+	else {
+		e._pendingPullIntos.length > 0 && He(e);
+		G(r, new Uint8Array(a, n, i), !1);
+	}
+	else if (ut(r)) {
+		Fe(e, a, n, i);
+		ze(r, Qe(e));
+	} else Fe(e, a, n, i);
+	je(e);
+}
+function Xe(e, t) {
+	const r = e._controlledReadableByteStream;
+	"readable" === r._state && (ke(e), qe(e), Ve(e), xr(r, t));
+}
+function Je(e, t) {
+	const r = e._queue.shift();
+	e._queueTotalSize -= r.byteLength, Ye(e);
+	const o = new Uint8Array(r.buffer, r.byteOffset, r.byteLength);
+	t._chunkSteps(o);
+}
+function Ke(e) {
+	if (null === e._byobRequest && e._pendingPullIntos.length > 0) {
+		const t = e._pendingPullIntos.peek(), r = new Uint8Array(t.buffer, t.byteOffset + t.bytesFilled, t.byteLength - t.bytesFilled), o = Object.create(ReadableStreamBYOBRequest.prototype);
+		(function(e, t, r) {
+			e._associatedReadableByteStreamController = t, e._view = r;
+		})(o, e, r), e._byobRequest = o;
+	}
+	return e._byobRequest;
+}
+function Ze(e) {
+	const t = e._controlledReadableByteStream._state;
+	return "errored" === t ? null : "closed" === t ? 0 : e._strategyHWM - e._queueTotalSize;
+}
+function et(e, t) {
+	const r = e._pendingPullIntos.peek();
+	if ("closed" === e._controlledReadableByteStream._state) {
+		if (0 !== t) throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream");
+	} else {
+		if (0 === t) 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 = ce(r.buffer), Ne(e, t);
+}
+function tt(e, t) {
+	const r = e._pendingPullIntos.peek();
+	if ("closed" === e._controlledReadableByteStream._state) {
+		if (0 !== t.byteLength) throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream");
+	} else if (0 === t.byteLength) 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 = ce(t.buffer), Ne(e, o);
+}
+function rt(e, t, r, o, n, i, a) {
+	t._controlledReadableByteStream = e, t._pullAgain = !1, t._pulling = !1, t._byobRequest = null, t._queue = t._queueTotalSize = void 0, qe(t), t._closeRequested = !1, t._started = !1, t._strategyHWM = i, t._pullAlgorithm = o, t._cancelAlgorithm = n, t._autoAllocateChunkSize = a, t._pendingPullIntos = new v(), e._readableStreamController = t;
+	h(c(r()), () => (t._started = !0, je(t), null), (e) => (Xe(t, e), null));
+}
+function ot(e) {
+	return /* @__PURE__ */ new TypeError(`ReadableStreamBYOBRequest.prototype.${e} can only be used on a ReadableStreamBYOBRequest`);
+}
+function nt(e) {
+	return /* @__PURE__ */ new TypeError(`ReadableByteStreamController.prototype.${e} can only be used on a ReadableByteStreamController`);
+}
+function it(e, t) {
+	if ("byob" !== (e = `${e}`)) throw new TypeError(`${t} '${e}' is not a valid enumeration value for ReadableStreamReaderMode`);
+	return e;
+}
+function at(e) {
+	return new ReadableStreamBYOBReader(e);
+}
+function st(e, t) {
+	e._reader._readIntoRequests.push(t);
+}
+function lt(e) {
+	return e._reader._readIntoRequests.length;
+}
+function ut(e) {
+	const t = e._reader;
+	return void 0 !== t && !!ft(t);
+}
+Object.defineProperties(ReadableByteStreamController.prototype, {
+	close: { enumerable: !0 },
+	enqueue: { enumerable: !0 },
+	error: { enumerable: !0 },
+	byobRequest: { enumerable: !0 },
+	desiredSize: { enumerable: !0 }
+}), o(ReadableByteStreamController.prototype.close, "close"), o(ReadableByteStreamController.prototype.enqueue, "enqueue"), o(ReadableByteStreamController.prototype.error, "error"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(ReadableByteStreamController.prototype, Symbol.toStringTag, {
+	value: "ReadableByteStreamController",
+	configurable: !0
+});
+var ReadableStreamBYOBReader = class {
+	constructor(e) {
+		if (M(e, 1, "ReadableStreamBYOBReader"), H(e, "First parameter"), $r(e)) throw new TypeError("This stream has already been locked for exclusive reading by another reader");
+		if (!Oe(e._readableStreamController)) throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");
+		E(this, e), this._readIntoRequests = new v();
+	}
+	get closed() {
+		return ft(this) ? this._closedPromise : d(_t("closed"));
+	}
+	cancel(e = void 0) {
+		return ft(this) ? void 0 === this._ownerReadableStream ? d(B("cancel")) : W(this, e) : d(_t("cancel"));
+	}
+	read(e, t = {}) {
+		if (!ft(this)) return d(_t("read"));
+		if (!ArrayBuffer.isView(e)) return d(/* @__PURE__ */ new TypeError("view must be an array buffer view"));
+		if (0 === e.byteLength) return d(/* @__PURE__ */ new TypeError("view must have non-zero byteLength"));
+		if (0 === e.buffer.byteLength) return d(/* @__PURE__ */ new TypeError("view's buffer must have non-zero byteLength"));
+		if (de(e.buffer)) return d(/* @__PURE__ */ new TypeError("view's buffer has been detached"));
+		let r;
+		try {
+			r = function(e, t) {
+				var r;
+				return L(e, t), { min: N(null !== (r = null == e ? void 0 : e.min) && void 0 !== r ? r : 1, `${t} has member 'min' that`) };
+			}(t, "options");
+		} catch (e) {
+			return d(e);
+		}
+		const o = r.min;
+		if (0 === o) return d(/* @__PURE__ */ new TypeError("options.min must be greater than 0"));
+		if (function(e) {
+			return Ee(e.constructor);
+		}(e)) {
+			if (o > e.byteLength) return d(/* @__PURE__ */ new RangeError("options.min must be less than or equal to view's byteLength"));
+		} else if (o > e.length) return d(/* @__PURE__ */ new RangeError("options.min must be less than or equal to view's length"));
+		if (void 0 === this._ownerReadableStream) return d(B("read from"));
+		const n = function(e, t, r) {
+			const o = e._ownerReadableStream;
+			return "errored" === o._state || function(e, t, r) {
+				const o = e._controlledReadableByteStream, n = We(t.constructor), { byteLength: i } = t, a = r * n;
+				return !(e._pendingPullIntos.length > 0) && ("closed" === o._state || e._queueTotalSize >= a);
+			}(o._readableStreamController, t, r);
+		}(this, e, o) ? new dt() : new ct();
+		return ht(this, e, o, n), n._promise;
+	}
+	releaseLock() {
+		if (!ft(this)) throw _t("releaseLock");
+		void 0 !== this._ownerReadableStream && function(e) {
+			O(e);
+			bt(e, /* @__PURE__ */ new TypeError("Reader was released"));
+		}(this);
+	}
+};
+Object.defineProperties(ReadableStreamBYOBReader.prototype, {
+	cancel: { enumerable: !0 },
+	read: { enumerable: !0 },
+	releaseLock: { enumerable: !0 },
+	closed: { enumerable: !0 }
+}), o(ReadableStreamBYOBReader.prototype.cancel, "cancel"), o(ReadableStreamBYOBReader.prototype.read, "read"), o(ReadableStreamBYOBReader.prototype.releaseLock, "releaseLock"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(ReadableStreamBYOBReader.prototype, Symbol.toStringTag, {
+	value: "ReadableStreamBYOBReader",
+	configurable: !0
+});
+var ct = class {
+	constructor() {
+		this._promise = u((e, t) => {
+			this._resolvePromise = e, this._rejectPromise = t;
+		});
+	}
+	_chunkSteps(e) {
+		this._resolvePromise({
+			value: e,
+			done: !1
+		});
+	}
+	_closeSteps(e) {
+		this._resolvePromise({
+			value: e,
+			done: !0
+		});
+	}
+	_errorSteps(e) {
+		this._rejectPromise(e);
+	}
+};
+var dt = class {
+	constructor() {
+		this._promise = void 0;
+	}
+	_chunkSteps(e) {
+		this._promise = l({
+			value: e,
+			done: !1
+		});
+	}
+	_closeSteps(e) {
+		this._promise = l({
+			value: e,
+			done: !0
+		});
+	}
+	_errorSteps(e) {
+		this._promise = d(e);
+	}
+};
+function ft(e) {
+	return !!t(e) && !!Object.prototype.hasOwnProperty.call(e, "_readIntoRequests") && e instanceof ReadableStreamBYOBReader;
+}
+function ht(e, t, r, o) {
+	const n = e._ownerReadableStream;
+	n._disturbed = !0, "errored" === n._state ? o._errorSteps(n._storedError) : function(e, t, r, o) {
+		const n = e._controlledReadableByteStream, i = t.constructor, a = We(i), { byteOffset: s, byteLength: l } = t, u = r * a;
+		let c;
+		try {
+			c = ce(t.buffer);
+		} catch (e) {
+			o._errorSteps(e);
+			return;
+		}
+		const d = {
+			buffer: c,
+			bufferByteLength: c.byteLength,
+			byteOffset: s,
+			byteLength: l,
+			bytesFilled: 0,
+			minimumFill: u,
+			elementSize: a,
+			viewConstructor: i,
+			readerType: "byob"
+		};
+		if (e._pendingPullIntos.length > 0) return e._pendingPullIntos.push(d), void st(n, o);
+		if ("closed" === n._state) {
+			const e = new i(d.buffer, d.byteOffset, 0);
+			o._closeSteps(e);
+			return;
+		}
+		if (e._queueTotalSize > 0) {
+			if ($e(e, d)) {
+				const t = De(d);
+				Ye(e), o._chunkSteps(t);
+				return;
+			}
+			if (e._closeRequested) {
+				const t = /* @__PURE__ */ new TypeError("Insufficient bytes to fill elements in the given buffer");
+				Xe(e, t), o._errorSteps(t);
+				return;
+			}
+		}
+		e._pendingPullIntos.push(d), st(n, o), je(e);
+	}(n._readableStreamController, t, r, o);
+}
+function bt(e, t) {
+	const r = e._readIntoRequests;
+	e._readIntoRequests = new v(), r.forEach((e) => {
+		e._errorSteps(t);
+	});
+}
+function _t(e) {
+	return /* @__PURE__ */ new TypeError(`ReadableStreamBYOBReader.prototype.${e} can only be used on a ReadableStreamBYOBReader`);
+}
+function mt(e, t) {
+	const { highWaterMark: r } = e;
+	if (void 0 === r) return t;
+	if (Re(r) || r < 0) throw new RangeError("Invalid highWaterMark");
+	return r;
+}
+function pt(e) {
+	const { size: t } = e;
+	return t || (() => 1);
+}
+function yt(e, t) {
+	L(e, t);
+	const r = null == e ? void 0 : e.highWaterMark, o = null == e ? void 0 : e.size;
+	return {
+		highWaterMark: void 0 === r ? void 0 : x(r),
+		size: void 0 === o ? void 0 : St(o, `${t} has member 'size' that`)
+	};
+}
+function St(e, t) {
+	return I(e, t), (t) => x(e(t));
+}
+function gt(e, t, r) {
+	return I(e, r), (r) => g(e, t, [r]);
+}
+function vt(e, t, r) {
+	return I(e, r), () => g(e, t, []);
+}
+function wt(e, t, r) {
+	return I(e, r), (r) => S(e, t, [r]);
+}
+function Rt(e, t, r) {
+	return I(e, r), (r, o) => g(e, t, [r, o]);
+}
+function Tt(e, t) {
+	if (!qt(e)) throw new TypeError(`${t} is not a WritableStream.`);
+}
+var WritableStream = class {
+	constructor(e = {}, t = {}) {
+		void 0 === e ? e = null : $(e, "First parameter");
+		const r = yt(t, "Second parameter"), o = function(e, t) {
+			L(e, t);
+			const r = null == e ? void 0 : e.abort, o = null == e ? void 0 : e.close, n = null == e ? void 0 : e.start, i = null == e ? void 0 : e.type, a = null == e ? void 0 : e.write;
+			return {
+				abort: void 0 === r ? void 0 : gt(r, e, `${t} has member 'abort' that`),
+				close: void 0 === o ? void 0 : vt(o, e, `${t} has member 'close' that`),
+				start: void 0 === n ? void 0 : wt(n, e, `${t} has member 'start' that`),
+				write: void 0 === a ? void 0 : Rt(a, e, `${t} has member 'write' that`),
+				type: i
+			};
+		}(e, "First parameter");
+		Ct(this);
+		if (void 0 !== o.type) throw new RangeError("Invalid type is specified");
+		const n = pt(r);
+		(function(e, t, r, o) {
+			const n = Object.create(WritableStreamDefaultController.prototype);
+			let i, a, s, l;
+			i = void 0 !== t.start ? () => t.start(n) : () => {};
+			a = void 0 !== t.write ? (e) => t.write(e, n) : () => c(void 0);
+			s = void 0 !== t.close ? () => t.close() : () => c(void 0);
+			l = void 0 !== t.abort ? (e) => t.abort(e) : () => c(void 0);
+			Nt(e, n, i, a, s, l, r, o);
+		})(this, o, mt(r, 1), n);
+	}
+	get locked() {
+		if (!qt(this)) throw Kt("locked");
+		return Et(this);
+	}
+	abort(e = void 0) {
+		return qt(this) ? Et(this) ? d(/* @__PURE__ */ new TypeError("Cannot abort a stream that already has a writer")) : Wt(this, e) : d(Kt("abort"));
+	}
+	close() {
+		return qt(this) ? Et(this) ? d(/* @__PURE__ */ new TypeError("Cannot close a stream that already has a writer")) : At(this) ? d(/* @__PURE__ */ new TypeError("Cannot close an already-closing stream")) : Ot(this) : d(Kt("close"));
+	}
+	getWriter() {
+		if (!qt(this)) throw Kt("getWriter");
+		return Pt(this);
+	}
+};
+function Pt(e) {
+	return new WritableStreamDefaultWriter(e);
+}
+function Ct(e) {
+	e._state = "writable", e._storedError = void 0, e._writer = void 0, e._writableStreamController = void 0, e._writeRequests = new v(), e._inFlightWriteRequest = void 0, e._closeRequest = void 0, e._inFlightCloseRequest = void 0, e._pendingAbortRequest = void 0, e._backpressure = !1;
+}
+function qt(e) {
+	return !!t(e) && !!Object.prototype.hasOwnProperty.call(e, "_writableStreamController") && e instanceof WritableStream;
+}
+function Et(e) {
+	return void 0 !== e._writer;
+}
+function Wt(e, t) {
+	var r;
+	if ("closed" === e._state || "errored" === e._state) return c(void 0);
+	e._writableStreamController._abortReason = t, null === (r = e._writableStreamController._abortController) || void 0 === r || r.abort(t);
+	const o = e._state;
+	if ("closed" === o || "errored" === o) return c(void 0);
+	if (void 0 !== e._pendingAbortRequest) return e._pendingAbortRequest._promise;
+	let n = !1;
+	"erroring" === o && (n = !0, t = void 0);
+	const i = u((r, o) => {
+		e._pendingAbortRequest = {
+			_promise: void 0,
+			_resolve: r,
+			_reject: o,
+			_reason: t,
+			_wasAlreadyErroring: n
+		};
+	});
+	return e._pendingAbortRequest._promise = i, n || jt(e, t), i;
+}
+function Ot(e) {
+	const t = e._state;
+	if ("closed" === t || "errored" === t) return d(/* @__PURE__ */ new TypeError(`The stream (in ${t} state) is not in the writable state and cannot be closed`));
+	const r = u((t, r) => {
+		e._closeRequest = {
+			_resolve: t,
+			_reject: r
+		};
+	}), o = e._writer;
+	var n;
+	return void 0 !== o && e._backpressure && "writable" === t && cr(o), Ce(n = e._writableStreamController, xt, 0), Ut(n), r;
+}
+function Bt(e, t) {
+	"writable" !== e._state ? kt(e) : jt(e, t);
+}
+function jt(e, t) {
+	const r = e._writableStreamController;
+	e._state = "erroring", e._storedError = t;
+	const o = e._writer;
+	void 0 !== o && $t(o, t), !function(e) {
+		if (void 0 === e._inFlightWriteRequest && void 0 === e._inFlightCloseRequest) return !1;
+		return !0;
+	}(e) && r._started && kt(e);
+}
+function kt(e) {
+	e._state = "errored", e._writableStreamController[R]();
+	const t = e._storedError;
+	if (e._writeRequests.forEach((e) => {
+		e._reject(t);
+	}), e._writeRequests = new v(), void 0 === e._pendingAbortRequest) return void zt(e);
+	const r = e._pendingAbortRequest;
+	if (e._pendingAbortRequest = void 0, r._wasAlreadyErroring) return r._reject(t), void zt(e);
+	h(e._writableStreamController[w](r._reason), () => (r._resolve(), zt(e), null), (t) => (r._reject(t), zt(e), null));
+}
+function At(e) {
+	return void 0 !== e._closeRequest || void 0 !== e._inFlightCloseRequest;
+}
+function zt(e) {
+	void 0 !== e._closeRequest && (e._closeRequest._reject(e._storedError), e._closeRequest = void 0);
+	const t = e._writer;
+	void 0 !== t && nr(t, e._storedError);
+}
+function Dt(e, t) {
+	const r = e._writer;
+	void 0 !== r && t !== e._backpressure && (t ? function(e) {
+		ar(e);
+	}(r) : cr(r)), e._backpressure = t;
+}
+Object.defineProperties(WritableStream.prototype, {
+	abort: { enumerable: !0 },
+	close: { enumerable: !0 },
+	getWriter: { enumerable: !0 },
+	locked: { enumerable: !0 }
+}), o(WritableStream.prototype.abort, "abort"), o(WritableStream.prototype.close, "close"), o(WritableStream.prototype.getWriter, "getWriter"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(WritableStream.prototype, Symbol.toStringTag, {
+	value: "WritableStream",
+	configurable: !0
+});
+var WritableStreamDefaultWriter = class {
+	constructor(e) {
+		if (M(e, 1, "WritableStreamDefaultWriter"), Tt(e, "First parameter"), Et(e)) throw new TypeError("This stream has already been locked for exclusive writing by another writer");
+		this._ownerWritableStream = e, e._writer = this;
+		const t = e._state;
+		if ("writable" === t) !At(e) && e._backpressure ? ar(this) : lr(this), rr(this);
+		else if ("erroring" === t) sr(this, e._storedError), rr(this);
+		else if ("closed" === t) lr(this), rr(r = this), ir(r);
+		else {
+			const t = e._storedError;
+			sr(this, t), or(this, t);
+		}
+		var r;
+	}
+	get closed() {
+		return Ft(this) ? this._closedPromise : d(er("closed"));
+	}
+	get desiredSize() {
+		if (!Ft(this)) throw er("desiredSize");
+		if (void 0 === this._ownerWritableStream) throw tr("desiredSize");
+		return function(e) {
+			const t = e._ownerWritableStream, r = t._state;
+			if ("errored" === r || "erroring" === r) return null;
+			if ("closed" === r) return 0;
+			return Vt(t._writableStreamController);
+		}(this);
+	}
+	get ready() {
+		return Ft(this) ? this._readyPromise : d(er("ready"));
+	}
+	abort(e = void 0) {
+		return Ft(this) ? void 0 === this._ownerWritableStream ? d(tr("abort")) : function(e, t) {
+			return Wt(e._ownerWritableStream, t);
+		}(this, e) : d(er("abort"));
+	}
+	close() {
+		if (!Ft(this)) return d(er("close"));
+		const e = this._ownerWritableStream;
+		return void 0 === e ? d(tr("close")) : At(e) ? d(/* @__PURE__ */ new TypeError("Cannot close an already-closing stream")) : Lt(this);
+	}
+	releaseLock() {
+		if (!Ft(this)) throw er("releaseLock");
+		void 0 !== this._ownerWritableStream && Mt(this);
+	}
+	write(e = void 0) {
+		return Ft(this) ? void 0 === this._ownerWritableStream ? d(tr("write to")) : Yt(this, e) : d(er("write"));
+	}
+};
+function Ft(e) {
+	return !!t(e) && !!Object.prototype.hasOwnProperty.call(e, "_ownerWritableStream") && e instanceof WritableStreamDefaultWriter;
+}
+function Lt(e) {
+	return Ot(e._ownerWritableStream);
+}
+function It(e, t) {
+	"pending" === e._closedPromiseState ? nr(e, t) : function(e, t) {
+		or(e, t);
+	}(e, t);
+}
+function $t(e, t) {
+	"pending" === e._readyPromiseState ? ur(e, t) : function(e, t) {
+		sr(e, t);
+	}(e, t);
+}
+function Mt(e) {
+	const t = e._ownerWritableStream, r = /* @__PURE__ */ new TypeError("Writer was released and can no longer be used to monitor the stream's closedness");
+	$t(e, r), It(e, r), t._writer = void 0, e._ownerWritableStream = void 0;
+}
+function Yt(e, t) {
+	const r = e._ownerWritableStream, o = r._writableStreamController, n = function(e, t) {
+		if (void 0 === e._strategySizeAlgorithm) return 1;
+		try {
+			return e._strategySizeAlgorithm(t);
+		} catch (t) {
+			return Gt(e, t), 1;
+		}
+	}(o, t);
+	if (r !== e._ownerWritableStream) return d(tr("write to"));
+	const i = r._state;
+	if ("errored" === i) return d(r._storedError);
+	if (At(r) || "closed" === i) return d(/* @__PURE__ */ new TypeError("The stream is closing or closed and cannot be written to"));
+	if ("erroring" === i) return d(r._storedError);
+	const a = function(e) {
+		return u((t, r) => {
+			const o = {
+				_resolve: t,
+				_reject: r
+			};
+			e._writeRequests.push(o);
+		});
+	}(r);
+	return function(e, t, r) {
+		try {
+			Ce(e, t, r);
+		} catch (t) {
+			Gt(e, t);
+			return;
+		}
+		const o = e._controlledWritableStream;
+		if (!At(o) && "writable" === o._state) Dt(o, Xt(e));
+		Ut(e);
+	}(o, t, n), a;
+}
+Object.defineProperties(WritableStreamDefaultWriter.prototype, {
+	abort: { enumerable: !0 },
+	close: { enumerable: !0 },
+	releaseLock: { enumerable: !0 },
+	write: { enumerable: !0 },
+	closed: { enumerable: !0 },
+	desiredSize: { enumerable: !0 },
+	ready: { enumerable: !0 }
+}), o(WritableStreamDefaultWriter.prototype.abort, "abort"), o(WritableStreamDefaultWriter.prototype.close, "close"), o(WritableStreamDefaultWriter.prototype.releaseLock, "releaseLock"), o(WritableStreamDefaultWriter.prototype.write, "write"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(WritableStreamDefaultWriter.prototype, Symbol.toStringTag, {
+	value: "WritableStreamDefaultWriter",
+	configurable: !0
+});
+const xt = {};
+var WritableStreamDefaultController = class {
+	constructor() {
+		throw new TypeError("Illegal constructor");
+	}
+	get abortReason() {
+		if (!Qt(this)) throw Zt("abortReason");
+		return this._abortReason;
+	}
+	get signal() {
+		if (!Qt(this)) throw Zt("signal");
+		if (void 0 === this._abortController) throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported");
+		return this._abortController.signal;
+	}
+	error(e = void 0) {
+		if (!Qt(this)) throw Zt("error");
+		"writable" === this._controlledWritableStream._state && Jt(this, e);
+	}
+	[w](e) {
+		const t = this._abortAlgorithm(e);
+		return Ht(this), t;
+	}
+	[R]() {
+		qe(this);
+	}
+};
+function Qt(e) {
+	return !!t(e) && !!Object.prototype.hasOwnProperty.call(e, "_controlledWritableStream") && e instanceof WritableStreamDefaultController;
+}
+function Nt(e, t, r, o, n, i, a, s) {
+	t._controlledWritableStream = e, e._writableStreamController = t, t._queue = void 0, t._queueTotalSize = void 0, qe(t), t._abortReason = void 0, t._abortController = function() {
+		if ("function" == typeof AbortController) return new AbortController();
+	}(), t._started = !1, t._strategySizeAlgorithm = s, t._strategyHWM = a, t._writeAlgorithm = o, t._closeAlgorithm = n, t._abortAlgorithm = i;
+	Dt(e, Xt(t));
+	h(c(r()), () => (t._started = !0, Ut(t), null), (r) => (t._started = !0, Bt(e, r), null));
+}
+function Ht(e) {
+	e._writeAlgorithm = void 0, e._closeAlgorithm = void 0, e._abortAlgorithm = void 0, e._strategySizeAlgorithm = void 0;
+}
+function Vt(e) {
+	return e._strategyHWM - e._queueTotalSize;
+}
+function Ut(e) {
+	const t = e._controlledWritableStream;
+	if (!e._started) return;
+	if (void 0 !== t._inFlightWriteRequest) return;
+	if ("erroring" === t._state) return void kt(t);
+	if (0 === e._queue.length) return;
+	const r = e._queue.peek().value;
+	r === xt ? function(e) {
+		const t = e._controlledWritableStream;
+		(function(e) {
+			e._inFlightCloseRequest = e._closeRequest, e._closeRequest = void 0;
+		})(t), Pe(e);
+		const r = e._closeAlgorithm();
+		Ht(e), h(r, () => (function(e) {
+			e._inFlightCloseRequest._resolve(void 0), e._inFlightCloseRequest = void 0, "erroring" === e._state && (e._storedError = void 0, void 0 !== e._pendingAbortRequest && (e._pendingAbortRequest._resolve(), e._pendingAbortRequest = void 0)), e._state = "closed";
+			const t = e._writer;
+			void 0 !== t && ir(t);
+		}(t), null), (e) => (function(e, t) {
+			e._inFlightCloseRequest._reject(t), e._inFlightCloseRequest = void 0, void 0 !== e._pendingAbortRequest && (e._pendingAbortRequest._reject(t), e._pendingAbortRequest = void 0), Bt(e, t);
+		}(t, e), null));
+	}(e) : function(e, t) {
+		const r = e._controlledWritableStream;
+		(function(e) {
+			e._inFlightWriteRequest = e._writeRequests.shift();
+		})(r);
+		h(e._writeAlgorithm(t), () => {
+			(function(e) {
+				e._inFlightWriteRequest._resolve(void 0), e._inFlightWriteRequest = void 0;
+			})(r);
+			const t = r._state;
+			if (Pe(e), !At(r) && "writable" === t) {
+				const t = Xt(e);
+				Dt(r, t);
+			}
+			return Ut(e), null;
+		}, (t) => ("writable" === r._state && Ht(e), function(e, t) {
+			e._inFlightWriteRequest._reject(t), e._inFlightWriteRequest = void 0, Bt(e, t);
+		}(r, t), null));
+	}(e, r);
+}
+function Gt(e, t) {
+	"writable" === e._controlledWritableStream._state && Jt(e, t);
+}
+function Xt(e) {
+	return Vt(e) <= 0;
+}
+function Jt(e, t) {
+	const r = e._controlledWritableStream;
+	Ht(e), jt(r, t);
+}
+function Kt(e) {
+	return /* @__PURE__ */ new TypeError(`WritableStream.prototype.${e} can only be used on a WritableStream`);
+}
+function Zt(e) {
+	return /* @__PURE__ */ new TypeError(`WritableStreamDefaultController.prototype.${e} can only be used on a WritableStreamDefaultController`);
+}
+function er(e) {
+	return /* @__PURE__ */ new TypeError(`WritableStreamDefaultWriter.prototype.${e} can only be used on a WritableStreamDefaultWriter`);
+}
+function tr(e) {
+	return /* @__PURE__ */ new TypeError("Cannot " + e + " a stream using a released writer");
+}
+function rr(e) {
+	e._closedPromise = u((t, r) => {
+		e._closedPromise_resolve = t, e._closedPromise_reject = r, e._closedPromiseState = "pending";
+	});
+}
+function or(e, t) {
+	rr(e), nr(e, t);
+}
+function nr(e, t) {
+	void 0 !== e._closedPromise_reject && (p(e._closedPromise), e._closedPromise_reject(t), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0, e._closedPromiseState = "rejected");
+}
+function ir(e) {
+	void 0 !== e._closedPromise_resolve && (e._closedPromise_resolve(void 0), e._closedPromise_resolve = void 0, e._closedPromise_reject = void 0, e._closedPromiseState = "resolved");
+}
+function ar(e) {
+	e._readyPromise = u((t, r) => {
+		e._readyPromise_resolve = t, e._readyPromise_reject = r;
+	}), e._readyPromiseState = "pending";
+}
+function sr(e, t) {
+	ar(e), ur(e, t);
+}
+function lr(e) {
+	ar(e), cr(e);
+}
+function ur(e, t) {
+	void 0 !== e._readyPromise_reject && (p(e._readyPromise), e._readyPromise_reject(t), e._readyPromise_resolve = void 0, e._readyPromise_reject = void 0, e._readyPromiseState = "rejected");
+}
+function cr(e) {
+	void 0 !== e._readyPromise_resolve && (e._readyPromise_resolve(void 0), e._readyPromise_resolve = void 0, e._readyPromise_reject = void 0, e._readyPromiseState = "fulfilled");
+}
+Object.defineProperties(WritableStreamDefaultController.prototype, {
+	abortReason: { enumerable: !0 },
+	signal: { enumerable: !0 },
+	error: { enumerable: !0 }
+}), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(WritableStreamDefaultController.prototype, Symbol.toStringTag, {
+	value: "WritableStreamDefaultController",
+	configurable: !0
+});
+const dr = "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : "undefined" != typeof global ? global : void 0;
+const fr = function() {
+	const e = null == dr ? void 0 : dr.DOMException;
+	return function(e) {
+		if ("function" != typeof e && "object" != typeof e) return !1;
+		if ("DOMException" !== e.name) return !1;
+		try {
+			return new e(), !0;
+		} catch (e) {
+			return !1;
+		}
+	}(e) ? e : void 0;
+}() || function() {
+	const e = function(e, t) {
+		this.message = e || "", this.name = t || "Error", Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
+	};
+	return o(e, "DOMException"), e.prototype = Object.create(Error.prototype), Object.defineProperty(e.prototype, "constructor", {
+		value: e,
+		writable: !0,
+		configurable: !0
+	}), e;
+}();
+function hr(e, t, r, o, n, i) {
+	const a = V(e), s = Pt(t);
+	e._disturbed = !0;
+	const l = new br(s), _ = new mr(l);
+	return u((m, y) => {
+		let S;
+		if (void 0 !== i) {
+			if (S = () => {
+				const r = void 0 !== i.reason ? i.reason : new fr("Aborted", "AbortError"), a = [];
+				o || a.push(() => "writable" === t._state ? Wt(t, r) : c(void 0)), n || a.push(() => "readable" === e._state ? Mr(e, r) : c(void 0)), T(() => Promise.all(a.map((e) => e())), !0, r);
+			}, i.aborted) return void S();
+			i.addEventListener("abort", S);
+		}
+		function g() {
+			for (; !l._shuttingDown && !t._backpressure && "writable" === t._state && !At(t) && "readable" === e._state && re(a);) te(a, _);
+			if (l._shuttingDown) return c(!0);
+			if (t._backpressure) return f(s._readyPromise, g);
+			const r = new _r(l);
+			return te(a, r), r._promise;
+		}
+		var v, w, R;
+		if (pr(e, a._closedPromise, (e) => (o ? P(!0, e) : T(() => Wt(t, e), !0, e), null)), pr(t, s._closedPromise, (t) => (n ? P(!0, t) : T(() => Mr(e, t), !0, t), null)), v = e, w = a._closedPromise, R = () => (r ? P() : T(() => function(e) {
+			const t = e._ownerWritableStream, r = t._state;
+			return At(t) || "closed" === r ? c(void 0) : "errored" === r ? d(t._storedError) : Lt(e);
+		}(s)), null), "closed" === v._state ? R() : b(w, R), At(t) || "closed" === t._state) {
+			const t = /* @__PURE__ */ new TypeError("the destination writable stream closed before all data could be piped to it");
+			n ? P(!0, t) : T(() => Mr(e, t), !0, t);
+		}
+		function T(e, r, o) {
+			function n() {
+				return h(e(), () => C(r, o), (e) => C(!0, e)), null;
+			}
+			l._shuttingDown || (l._shuttingDown = !0, "writable" !== t._state || At(t) ? n() : b(l._waitForWritesToFinish(), n));
+		}
+		function P(e, r) {
+			l._shuttingDown || (l._shuttingDown = !0, "writable" !== t._state || At(t) ? C(e, r) : b(l._waitForWritesToFinish(), () => C(e, r)));
+		}
+		function C(e, t) {
+			return Mt(s), O(a), void 0 !== i && i.removeEventListener("abort", S), e ? y(t) : m(void 0), null;
+		}
+		p(u((e, t) => {
+			(function r(o) {
+				o ? e() : f(g(), r, t);
+			})(!1);
+		}));
+	});
+}
+var br = class {
+	constructor(e) {
+		this._writer = e, this._shuttingDown = !1, this._currentWrite = c(void 0);
+	}
+	_waitForWritesToFinish() {
+		const e = this._currentWrite;
+		return f(this._currentWrite, () => e !== this._currentWrite ? this._waitForWritesToFinish() : void 0);
+	}
+};
+var _r = class {
+	constructor(e) {
+		this._state = e, this._promise = u((e, t) => {
+			this._resolvePromise = e, this._rejectPromise = t;
+		});
+	}
+	_chunkSteps(t) {
+		this._state._currentWrite = f(Yt(this._state._writer, t), void 0, e), this._resolvePromise(!1);
+	}
+	_closeSteps() {
+		this._resolvePromise(!0);
+	}
+	_errorSteps(e) {
+		this._rejectPromise(e);
+	}
+};
+var mr = class {
+	constructor(e) {
+		this._state = e;
+	}
+	_chunkSteps(t) {
+		this._state._currentWrite = f(Yt(this._state._writer, t), void 0, e);
+	}
+	_closeSteps() {}
+	_errorSteps(e) {}
+};
+function pr(e, t, r) {
+	"errored" === e._state ? r(e._storedError) : _(t, r);
+}
+var ReadableStreamDefaultController = class {
+	constructor() {
+		throw new TypeError("Illegal constructor");
+	}
+	get desiredSize() {
+		if (!yr(this)) throw Er("desiredSize");
+		return Pr(this);
+	}
+	close() {
+		if (!yr(this)) throw Er("close");
+		if (!Cr(this)) throw new TypeError("The stream is not in a state that permits close");
+		wr(this);
+	}
+	enqueue(e = void 0) {
+		if (!yr(this)) throw Er("enqueue");
+		if (!Cr(this)) throw new TypeError("The stream is not in a state that permits enqueue");
+		return Rr(this, e);
+	}
+	error(e = void 0) {
+		if (!yr(this)) throw Er("error");
+		Tr(this, e);
+	}
+	[T](e) {
+		qe(this);
+		const t = this._cancelAlgorithm(e);
+		return vr(this), t;
+	}
+	[P](e) {
+		const t = this._controlledReadableStream;
+		if (this._queue.length > 0) {
+			const r = Pe(this);
+			this._closeRequested && 0 === this._queue.length ? (vr(this), Yr(t)) : Sr(this), e._chunkSteps(r);
+		} else U(t, e), Sr(this);
+	}
+	[C]() {
+		return this._queue.length > 0;
+	}
+	[q]() {}
+};
+function yr(e) {
+	return !!t(e) && !!Object.prototype.hasOwnProperty.call(e, "_controlledReadableStream") && e instanceof ReadableStreamDefaultController;
+}
+function Sr(e) {
+	if (!gr(e)) return;
+	if (e._pulling) return void (e._pullAgain = !0);
+	e._pulling = !0;
+	h(e._pullAlgorithm(), () => (e._pulling = !1, e._pullAgain && (e._pullAgain = !1, Sr(e)), null), (t) => (Tr(e, t), null));
+}
+function gr(e) {
+	const t = e._controlledReadableStream;
+	if (!Cr(e)) return !1;
+	if (!e._started) return !1;
+	if ($r(t) && X(t) > 0) return !0;
+	return Pr(e) > 0;
+}
+function vr(e) {
+	e._pullAlgorithm = void 0, e._cancelAlgorithm = void 0, e._strategySizeAlgorithm = void 0;
+}
+function wr(e) {
+	if (!Cr(e)) return;
+	const t = e._controlledReadableStream;
+	e._closeRequested = !0, 0 === e._queue.length && (vr(e), Yr(t));
+}
+function Rr(e, t) {
+	if (!Cr(e)) return;
+	const r = e._controlledReadableStream;
+	if ($r(r) && X(r) > 0) G(r, t, !1);
+	else {
+		let r;
+		try {
+			r = e._strategySizeAlgorithm(t);
+		} catch (t) {
+			throw Tr(e, t), t;
+		}
+		try {
+			Ce(e, t, r);
+		} catch (t) {
+			throw Tr(e, t), t;
+		}
+	}
+	Sr(e);
+}
+function Tr(e, t) {
+	const r = e._controlledReadableStream;
+	"readable" === r._state && (qe(e), vr(e), xr(r, t));
+}
+function Pr(e) {
+	const t = e._controlledReadableStream._state;
+	return "errored" === t ? null : "closed" === t ? 0 : e._strategyHWM - e._queueTotalSize;
+}
+function Cr(e) {
+	const t = e._controlledReadableStream._state;
+	return !e._closeRequested && "readable" === t;
+}
+function qr(e, t, r, o, n, i, a) {
+	t._controlledReadableStream = e, t._queue = void 0, t._queueTotalSize = void 0, qe(t), t._started = !1, t._closeRequested = !1, t._pullAgain = !1, t._pulling = !1, t._strategySizeAlgorithm = a, t._strategyHWM = i, t._pullAlgorithm = o, t._cancelAlgorithm = n, e._readableStreamController = t;
+	h(c(r()), () => (t._started = !0, Sr(t), null), (e) => (Tr(t, e), null));
+}
+function Er(e) {
+	return /* @__PURE__ */ new TypeError(`ReadableStreamDefaultController.prototype.${e} can only be used on a ReadableStreamDefaultController`);
+}
+function Wr(e, t) {
+	return Oe(e._readableStreamController) ? function(e) {
+		let t, r, o, n, i, a = V(e), s = !1, l = !1, d = !1, f = !1, h = !1;
+		const b = u((e) => {
+			i = e;
+		});
+		function m(e) {
+			_(e._closedPromise, (t) => (e !== a || (Xe(o._readableStreamController, t), Xe(n._readableStreamController, t), f && h || i(void 0)), null));
+		}
+		function p() {
+			ft(a) && (O(a), a = V(e), m(a));
+			te(a, {
+				_chunkSteps: (t) => {
+					y(() => {
+						l = !1, d = !1;
+						const r = t;
+						let a = t;
+						if (!f && !h) try {
+							a = Te(t);
+						} catch (t) {
+							Xe(o._readableStreamController, t), Xe(n._readableStreamController, t), i(Mr(e, t));
+							return;
+						}
+						f || Ge(o._readableStreamController, r), h || Ge(n._readableStreamController, a), s = !1, l ? g() : d && v();
+					});
+				},
+				_closeSteps: () => {
+					s = !1, f || Ue(o._readableStreamController), h || Ue(n._readableStreamController), o._readableStreamController._pendingPullIntos.length > 0 && et(o._readableStreamController, 0), n._readableStreamController._pendingPullIntos.length > 0 && et(n._readableStreamController, 0), f && h || i(void 0);
+				},
+				_errorSteps: () => {
+					s = !1;
+				}
+			});
+		}
+		function S(t, r) {
+			ee(a) && (O(a), a = at(e), m(a));
+			const u = r ? n : o, c = r ? o : n;
+			ht(a, t, 1, {
+				_chunkSteps: (t) => {
+					y(() => {
+						l = !1, d = !1;
+						const o = r ? h : f;
+						if (r ? f : h) o || tt(u._readableStreamController, t);
+						else {
+							let r;
+							try {
+								r = Te(t);
+							} catch (t) {
+								Xe(u._readableStreamController, t), Xe(c._readableStreamController, t), i(Mr(e, t));
+								return;
+							}
+							o || tt(u._readableStreamController, t), Ge(c._readableStreamController, r);
+						}
+						s = !1, l ? g() : d && v();
+					});
+				},
+				_closeSteps: (e) => {
+					s = !1;
+					const t = r ? h : f, o = r ? f : h;
+					t || Ue(u._readableStreamController), o || Ue(c._readableStreamController), void 0 !== e && (t || tt(u._readableStreamController, e), !o && c._readableStreamController._pendingPullIntos.length > 0 && et(c._readableStreamController, 0)), t && o || i(void 0);
+				},
+				_errorSteps: () => {
+					s = !1;
+				}
+			});
+		}
+		function g() {
+			if (s) return l = !0, c(void 0);
+			s = !0;
+			const e = Ke(o._readableStreamController);
+			return null === e ? p() : S(e._view, !1), c(void 0);
+		}
+		function v() {
+			if (s) return d = !0, c(void 0);
+			s = !0;
+			const e = Ke(n._readableStreamController);
+			return null === e ? p() : S(e._view, !0), c(void 0);
+		}
+		function w(o) {
+			if (f = !0, t = o, h) {
+				const n = Mr(e, le([t, r]));
+				i(n);
+			}
+			return b;
+		}
+		function R(o) {
+			if (h = !0, r = o, f) {
+				const n = Mr(e, le([t, r]));
+				i(n);
+			}
+			return b;
+		}
+		function T() {}
+		return o = Fr(T, g, w), n = Fr(T, v, R), m(a), [o, n];
+	}(e) : function(e) {
+		const t = V(e);
+		let r, o, n, i, a, s = !1, l = !1, d = !1, f = !1;
+		const h = u((e) => {
+			a = e;
+		});
+		function b() {
+			if (s) return l = !0, c(void 0);
+			s = !0;
+			return te(t, {
+				_chunkSteps: (e) => {
+					y(() => {
+						l = !1;
+						const t = e, r = e;
+						d || Rr(n._readableStreamController, t), f || Rr(i._readableStreamController, r), s = !1, l && b();
+					});
+				},
+				_closeSteps: () => {
+					s = !1, d || wr(n._readableStreamController), f || wr(i._readableStreamController), d && f || a(void 0);
+				},
+				_errorSteps: () => {
+					s = !1;
+				}
+			}), c(void 0);
+		}
+		function m(t) {
+			if (d = !0, r = t, f) {
+				const n = Mr(e, le([r, o]));
+				a(n);
+			}
+			return h;
+		}
+		function p(t) {
+			if (f = !0, o = t, d) {
+				const n = Mr(e, le([r, o]));
+				a(n);
+			}
+			return h;
+		}
+		function S() {}
+		return n = Dr(S, b, m), i = Dr(S, b, p), _(t._closedPromise, (e) => (Tr(n._readableStreamController, e), Tr(i._readableStreamController, e), d && f || a(void 0), null)), [n, i];
+	}(e);
+}
+function Or(r) {
+	return t(o = r) && void 0 !== o.getReader ? function(r) {
+		let o;
+		function n() {
+			let e;
+			try {
+				e = r.read();
+			} catch (e) {
+				return d(e);
+			}
+			return m(e, (e) => {
+				if (!t(e)) throw new TypeError("The promise returned by the reader.read() method must fulfill with an object");
+				if (e.done) wr(o._readableStreamController);
+				else {
+					const t = e.value;
+					Rr(o._readableStreamController, t);
+				}
+			});
+		}
+		function i(e) {
+			try {
+				return c(r.cancel(e));
+			} catch (e) {
+				return d(e);
+			}
+		}
+		return o = Dr(e, n, i, 0), o;
+	}(r.getReader()) : function(r) {
+		let o;
+		const n = me(r, "async");
+		function i() {
+			let e;
+			try {
+				e = pe(n);
+			} catch (e) {
+				return d(e);
+			}
+			return m(c(e), (e) => {
+				if (!t(e)) throw new TypeError("The promise returned by the iterator.next() method must fulfill with an object");
+				if (e.done) wr(o._readableStreamController);
+				else {
+					const t = e.value;
+					Rr(o._readableStreamController, t);
+				}
+			});
+		}
+		function a(e) {
+			const r = n.iterator;
+			let o;
+			try {
+				o = he(r, "return");
+			} catch (e) {
+				return d(e);
+			}
+			if (void 0 === o) return c(void 0);
+			return m(g(o, r, [e]), (e) => {
+				if (!t(e)) throw new TypeError("The promise returned by the iterator.return() method must fulfill with an object");
+			});
+		}
+		return o = Dr(e, i, a, 0), o;
+	}(r);
+	var o;
+}
+function Br(e, t, r) {
+	return I(e, r), (r) => g(e, t, [r]);
+}
+function jr(e, t, r) {
+	return I(e, r), (r) => g(e, t, [r]);
+}
+function kr(e, t, r) {
+	return I(e, r), (r) => S(e, t, [r]);
+}
+function Ar(e, t) {
+	if ("bytes" !== (e = `${e}`)) throw new TypeError(`${t} '${e}' is not a valid enumeration value for ReadableStreamType`);
+	return e;
+}
+function zr(e, t) {
+	L(e, t);
+	const r = null == e ? void 0 : e.preventAbort, o = null == e ? void 0 : e.preventCancel, n = null == e ? void 0 : e.preventClose, i = null == e ? void 0 : e.signal;
+	return void 0 !== i && function(e, t) {
+		if (!function(e) {
+			if ("object" != typeof e || null === e) return !1;
+			try {
+				return "boolean" == typeof e.aborted;
+			} catch (e) {
+				return !1;
+			}
+		}(e)) throw new TypeError(`${t} is not an AbortSignal.`);
+	}(i, `${t} has member 'signal' that`), {
+		preventAbort: Boolean(r),
+		preventCancel: Boolean(o),
+		preventClose: Boolean(n),
+		signal: i
+	};
+}
+Object.defineProperties(ReadableStreamDefaultController.prototype, {
+	close: { enumerable: !0 },
+	enqueue: { enumerable: !0 },
+	error: { enumerable: !0 },
+	desiredSize: { enumerable: !0 }
+}), o(ReadableStreamDefaultController.prototype.close, "close"), o(ReadableStreamDefaultController.prototype.enqueue, "enqueue"), o(ReadableStreamDefaultController.prototype.error, "error"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(ReadableStreamDefaultController.prototype, Symbol.toStringTag, {
+	value: "ReadableStreamDefaultController",
+	configurable: !0
+});
+var ReadableStream = class {
+	constructor(e = {}, t = {}) {
+		void 0 === e ? e = null : $(e, "First parameter");
+		const r = yt(t, "Second parameter"), o = function(e, t) {
+			L(e, t);
+			const r = e, o = null == r ? void 0 : r.autoAllocateChunkSize, n = null == r ? void 0 : r.cancel, i = null == r ? void 0 : r.pull, a = null == r ? void 0 : r.start, s = null == r ? void 0 : r.type;
+			return {
+				autoAllocateChunkSize: void 0 === o ? void 0 : N(o, `${t} has member 'autoAllocateChunkSize' that`),
+				cancel: void 0 === n ? void 0 : Br(n, r, `${t} has member 'cancel' that`),
+				pull: void 0 === i ? void 0 : jr(i, r, `${t} has member 'pull' that`),
+				start: void 0 === a ? void 0 : kr(a, r, `${t} has member 'start' that`),
+				type: void 0 === s ? void 0 : Ar(s, `${t} has member 'type' that`)
+			};
+		}(e, "First parameter");
+		if (Lr(this), "bytes" === o.type) {
+			if (void 0 !== r.size) throw new RangeError("The strategy for a byte stream cannot have a size function");
+			(function(e, t, r) {
+				const o = Object.create(ReadableByteStreamController.prototype);
+				let n, i, a;
+				n = void 0 !== t.start ? () => t.start(o) : () => {}, i = void 0 !== t.pull ? () => t.pull(o) : () => c(void 0), a = void 0 !== t.cancel ? (e) => t.cancel(e) : () => c(void 0);
+				const s = t.autoAllocateChunkSize;
+				if (0 === s) throw new TypeError("autoAllocateChunkSize must be greater than 0");
+				rt(e, o, n, i, a, r, s);
+			})(this, o, mt(r, 0));
+		} else {
+			const e = pt(r);
+			(function(e, t, r, o) {
+				const n = Object.create(ReadableStreamDefaultController.prototype);
+				let i, a, s;
+				i = void 0 !== t.start ? () => t.start(n) : () => {}, a = void 0 !== t.pull ? () => t.pull(n) : () => c(void 0), s = void 0 !== t.cancel ? (e) => t.cancel(e) : () => c(void 0), qr(e, n, i, a, s, r, o);
+			})(this, o, mt(r, 1), e);
+		}
+	}
+	get locked() {
+		if (!Ir(this)) throw Qr("locked");
+		return $r(this);
+	}
+	cancel(e = void 0) {
+		return Ir(this) ? $r(this) ? d(/* @__PURE__ */ new TypeError("Cannot cancel a stream that already has a reader")) : Mr(this, e) : d(Qr("cancel"));
+	}
+	getReader(e = void 0) {
+		if (!Ir(this)) throw Qr("getReader");
+		return void 0 === function(e, t) {
+			L(e, t);
+			const r = null == e ? void 0 : e.mode;
+			return { mode: void 0 === r ? void 0 : it(r, `${t} has member 'mode' that`) };
+		}(e, "First parameter").mode ? V(this) : at(this);
+	}
+	pipeThrough(e, t = {}) {
+		if (!Ir(this)) throw Qr("pipeThrough");
+		M(e, 1, "pipeThrough");
+		const r = function(e, t) {
+			L(e, t);
+			const r = null == e ? void 0 : e.readable;
+			Y(r, "readable", "ReadableWritablePair"), H(r, `${t} has member 'readable' that`);
+			const o = null == e ? void 0 : e.writable;
+			return Y(o, "writable", "ReadableWritablePair"), Tt(o, `${t} has member 'writable' that`), {
+				readable: r,
+				writable: o
+			};
+		}(e, "First parameter"), o = zr(t, "Second parameter");
+		if ($r(this)) throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");
+		if (Et(r.writable)) throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");
+		return p(hr(this, r.writable, o.preventClose, o.preventAbort, o.preventCancel, o.signal)), r.readable;
+	}
+	pipeTo(e, t = {}) {
+		if (!Ir(this)) return d(Qr("pipeTo"));
+		if (void 0 === e) return d("Parameter 1 is required in 'pipeTo'.");
+		if (!qt(e)) return d(/* @__PURE__ */ new TypeError("ReadableStream.prototype.pipeTo's first argument must be a WritableStream"));
+		let r;
+		try {
+			r = zr(t, "Second parameter");
+		} catch (e) {
+			return d(e);
+		}
+		return $r(this) ? d(/* @__PURE__ */ new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream")) : Et(e) ? d(/* @__PURE__ */ new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream")) : hr(this, e, r.preventClose, r.preventAbort, r.preventCancel, r.signal);
+	}
+	tee() {
+		if (!Ir(this)) throw Qr("tee");
+		return le(Wr(this));
+	}
+	values(e = void 0) {
+		if (!Ir(this)) throw Qr("values");
+		return function(e, t) {
+			const o = new ye(V(e), t), n = Object.create(ge);
+			return n._asyncIteratorImpl = o, n;
+		}(this, function(e, t) {
+			L(e, t);
+			const r = null == e ? void 0 : e.preventCancel;
+			return { preventCancel: Boolean(r) };
+		}(e, "First parameter").preventCancel);
+	}
+	[_e](e) {
+		return this.values(e);
+	}
+	static from(e) {
+		return Or(e);
+	}
+};
+function Dr(e, t, r, o = 1, n = () => 1) {
+	const i = Object.create(ReadableStream.prototype);
+	Lr(i);
+	return qr(i, Object.create(ReadableStreamDefaultController.prototype), e, t, r, o, n), i;
+}
+function Fr(e, t, r) {
+	const o = Object.create(ReadableStream.prototype);
+	Lr(o);
+	return rt(o, Object.create(ReadableByteStreamController.prototype), e, t, r, 0, void 0), o;
+}
+function Lr(e) {
+	e._state = "readable", e._reader = void 0, e._storedError = void 0, e._disturbed = !1;
+}
+function Ir(e) {
+	return !!t(e) && !!Object.prototype.hasOwnProperty.call(e, "_readableStreamController") && e instanceof ReadableStream;
+}
+function $r(e) {
+	return void 0 !== e._reader;
+}
+function Mr(t, r) {
+	if (t._disturbed = !0, "closed" === t._state) return c(void 0);
+	if ("errored" === t._state) return d(t._storedError);
+	Yr(t);
+	const o = t._reader;
+	if (void 0 !== o && ft(o)) {
+		const e = o._readIntoRequests;
+		o._readIntoRequests = new v(), e.forEach((e) => {
+			e._closeSteps(void 0);
+		});
+	}
+	return m(t._readableStreamController[T](r), e);
+}
+function Yr(e) {
+	e._state = "closed";
+	const t = e._reader;
+	if (void 0 !== t && (z(t), ee(t))) {
+		const e = t._readRequests;
+		t._readRequests = new v(), e.forEach((e) => {
+			e._closeSteps();
+		});
+	}
+}
+function xr(e, t) {
+	e._state = "errored", e._storedError = t;
+	const r = e._reader;
+	void 0 !== r && (A(r, t), ee(r) ? oe(r, t) : bt(r, t));
+}
+function Qr(e) {
+	return /* @__PURE__ */ new TypeError(`ReadableStream.prototype.${e} can only be used on a ReadableStream`);
+}
+function Nr(e, t) {
+	L(e, t);
+	const r = null == e ? void 0 : e.highWaterMark;
+	return Y(r, "highWaterMark", "QueuingStrategyInit"), { highWaterMark: x(r) };
+}
+Object.defineProperties(ReadableStream, { from: { enumerable: !0 } }), Object.defineProperties(ReadableStream.prototype, {
+	cancel: { enumerable: !0 },
+	getReader: { enumerable: !0 },
+	pipeThrough: { enumerable: !0 },
+	pipeTo: { enumerable: !0 },
+	tee: { enumerable: !0 },
+	values: { enumerable: !0 },
+	locked: { enumerable: !0 }
+}), o(ReadableStream.from, "from"), o(ReadableStream.prototype.cancel, "cancel"), o(ReadableStream.prototype.getReader, "getReader"), o(ReadableStream.prototype.pipeThrough, "pipeThrough"), o(ReadableStream.prototype.pipeTo, "pipeTo"), o(ReadableStream.prototype.tee, "tee"), o(ReadableStream.prototype.values, "values"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(ReadableStream.prototype, Symbol.toStringTag, {
+	value: "ReadableStream",
+	configurable: !0
+}), Object.defineProperty(ReadableStream.prototype, _e, {
+	value: ReadableStream.prototype.values,
+	writable: !0,
+	configurable: !0
+});
+const Hr = (e) => e.byteLength;
+o(Hr, "size");
+var ByteLengthQueuingStrategy = class {
+	constructor(e) {
+		M(e, 1, "ByteLengthQueuingStrategy"), e = Nr(e, "First parameter"), this._byteLengthQueuingStrategyHighWaterMark = e.highWaterMark;
+	}
+	get highWaterMark() {
+		if (!Ur(this)) throw Vr("highWaterMark");
+		return this._byteLengthQueuingStrategyHighWaterMark;
+	}
+	get size() {
+		if (!Ur(this)) throw Vr("size");
+		return Hr;
+	}
+};
+function Vr(e) {
+	return /* @__PURE__ */ new TypeError(`ByteLengthQueuingStrategy.prototype.${e} can only be used on a ByteLengthQueuingStrategy`);
+}
+function Ur(e) {
+	return !!t(e) && !!Object.prototype.hasOwnProperty.call(e, "_byteLengthQueuingStrategyHighWaterMark") && e instanceof ByteLengthQueuingStrategy;
+}
+Object.defineProperties(ByteLengthQueuingStrategy.prototype, {
+	highWaterMark: { enumerable: !0 },
+	size: { enumerable: !0 }
+}), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(ByteLengthQueuingStrategy.prototype, Symbol.toStringTag, {
+	value: "ByteLengthQueuingStrategy",
+	configurable: !0
+});
+const Gr = () => 1;
+o(Gr, "size");
+var CountQueuingStrategy = class {
+	constructor(e) {
+		M(e, 1, "CountQueuingStrategy"), e = Nr(e, "First parameter"), this._countQueuingStrategyHighWaterMark = e.highWaterMark;
+	}
+	get highWaterMark() {
+		if (!Jr(this)) throw Xr("highWaterMark");
+		return this._countQueuingStrategyHighWaterMark;
+	}
+	get size() {
+		if (!Jr(this)) throw Xr("size");
+		return Gr;
+	}
+};
+function Xr(e) {
+	return /* @__PURE__ */ new TypeError(`CountQueuingStrategy.prototype.${e} can only be used on a CountQueuingStrategy`);
+}
+function Jr(e) {
+	return !!t(e) && !!Object.prototype.hasOwnProperty.call(e, "_countQueuingStrategyHighWaterMark") && e instanceof CountQueuingStrategy;
+}
+function Kr(e, t, r) {
+	return I(e, r), (r) => g(e, t, [r]);
+}
+function Zr(e, t, r) {
+	return I(e, r), (r) => S(e, t, [r]);
+}
+function eo(e, t, r) {
+	return I(e, r), (r, o) => g(e, t, [r, o]);
+}
+function to(e, t, r) {
+	return I(e, r), (r) => g(e, t, [r]);
+}
+Object.defineProperties(CountQueuingStrategy.prototype, {
+	highWaterMark: { enumerable: !0 },
+	size: { enumerable: !0 }
+}), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(CountQueuingStrategy.prototype, Symbol.toStringTag, {
+	value: "CountQueuingStrategy",
+	configurable: !0
+});
+var TransformStream = class {
+	constructor(e = {}, t = {}, r = {}) {
+		void 0 === e && (e = null);
+		const o = yt(t, "Second parameter"), n = yt(r, "Third parameter"), i = function(e, t) {
+			L(e, t);
+			const r = null == e ? void 0 : e.cancel, o = null == e ? void 0 : e.flush, n = null == e ? void 0 : e.readableType, i = null == e ? void 0 : e.start, a = null == e ? void 0 : e.transform, s = null == e ? void 0 : e.writableType;
+			return {
+				cancel: void 0 === r ? void 0 : to(r, e, `${t} has member 'cancel' that`),
+				flush: void 0 === o ? void 0 : Kr(o, e, `${t} has member 'flush' that`),
+				readableType: n,
+				start: void 0 === i ? void 0 : Zr(i, e, `${t} has member 'start' that`),
+				transform: void 0 === a ? void 0 : eo(a, e, `${t} has member 'transform' that`),
+				writableType: s
+			};
+		}(e, "First parameter");
+		if (void 0 !== i.readableType) throw new RangeError("Invalid readableType specified");
+		if (void 0 !== i.writableType) throw new RangeError("Invalid writableType specified");
+		const a = mt(n, 0), s = pt(n), l = mt(o, 1), f = pt(o);
+		let b;
+		(function(e, t, r, o, n, i) {
+			function a() {
+				return t;
+			}
+			function s(t) {
+				return function(e, t) {
+					const r = e._transformStreamController;
+					if (e._backpressure) return m(e._backpressureChangePromise, () => {
+						const o = e._writable;
+						if ("erroring" === o._state) throw o._storedError;
+						return co(r, t);
+					});
+					return co(r, t);
+				}(e, t);
+			}
+			function l(t) {
+				return function(e, t) {
+					const r = e._transformStreamController;
+					if (void 0 !== r._finishPromise) return r._finishPromise;
+					const o = e._readable;
+					r._finishPromise = u((e, t) => {
+						r._finishPromise_resolve = e, r._finishPromise_reject = t;
+					});
+					const n = r._cancelAlgorithm(t);
+					return lo(r), h(n, () => ("errored" === o._state ? bo(r, o._storedError) : (Tr(o._readableStreamController, t), ho(r)), null), (e) => (Tr(o._readableStreamController, e), bo(r, e), null)), r._finishPromise;
+				}(e, t);
+			}
+			function c() {
+				return function(e) {
+					const t = e._transformStreamController;
+					if (void 0 !== t._finishPromise) return t._finishPromise;
+					const r = e._readable;
+					t._finishPromise = u((e, r) => {
+						t._finishPromise_resolve = e, t._finishPromise_reject = r;
+					});
+					const o = t._flushAlgorithm();
+					return lo(t), h(o, () => ("errored" === r._state ? bo(t, r._storedError) : (wr(r._readableStreamController), ho(t)), null), (e) => (Tr(r._readableStreamController, e), bo(t, e), null)), t._finishPromise;
+				}(e);
+			}
+			function d() {
+				return function(e) {
+					return ao(e, !1), e._backpressureChangePromise;
+				}(e);
+			}
+			function f(t) {
+				return function(e, t) {
+					const r = e._transformStreamController;
+					if (void 0 !== r._finishPromise) return r._finishPromise;
+					const o = e._writable;
+					r._finishPromise = u((e, t) => {
+						r._finishPromise_resolve = e, r._finishPromise_reject = t;
+					});
+					const n = r._cancelAlgorithm(t);
+					return lo(r), h(n, () => ("errored" === o._state ? bo(r, o._storedError) : (Gt(o._writableStreamController, t), io(e), ho(r)), null), (t) => (Gt(o._writableStreamController, t), io(e), bo(r, t), null)), r._finishPromise;
+				}(e, t);
+			}
+			e._writable = function(e, t, r, o, n = 1, i = () => 1) {
+				const a = Object.create(WritableStream.prototype);
+				return Ct(a), Nt(a, Object.create(WritableStreamDefaultController.prototype), e, t, r, o, n, i), a;
+			}(a, s, c, l, r, o), e._readable = Dr(a, d, f, n, i), e._backpressure = void 0, e._backpressureChangePromise = void 0, e._backpressureChangePromise_resolve = void 0, ao(e, !0), e._transformStreamController = void 0;
+		})(this, u((e) => {
+			b = e;
+		}), l, f, a, s), function(e, t) {
+			const r = Object.create(TransformStreamDefaultController.prototype);
+			let o, n, i;
+			o = void 0 !== t.transform ? (e) => t.transform(e, r) : (e) => {
+				try {
+					return uo(r, e), c(void 0);
+				} catch (e) {
+					return d(e);
+				}
+			};
+			n = void 0 !== t.flush ? () => t.flush(r) : () => c(void 0);
+			i = void 0 !== t.cancel ? (e) => t.cancel(e) : () => c(void 0);
+			(function(e, t, r, o, n) {
+				t._controlledTransformStream = e, e._transformStreamController = t, t._transformAlgorithm = r, t._flushAlgorithm = o, t._cancelAlgorithm = n, t._finishPromise = void 0, t._finishPromise_resolve = void 0, t._finishPromise_reject = void 0;
+			})(e, r, o, n, i);
+		}(this, i), void 0 !== i.start ? b(i.start(this._transformStreamController)) : b(void 0);
+	}
+	get readable() {
+		if (!ro(this)) throw _o("readable");
+		return this._readable;
+	}
+	get writable() {
+		if (!ro(this)) throw _o("writable");
+		return this._writable;
+	}
+};
+function ro(e) {
+	return !!t(e) && !!Object.prototype.hasOwnProperty.call(e, "_transformStreamController") && e instanceof TransformStream;
+}
+function oo(e, t) {
+	Tr(e._readable._readableStreamController, t), no(e, t);
+}
+function no(e, t) {
+	lo(e._transformStreamController), Gt(e._writable._writableStreamController, t), io(e);
+}
+function io(e) {
+	e._backpressure && ao(e, !1);
+}
+function ao(e, t) {
+	void 0 !== e._backpressureChangePromise && e._backpressureChangePromise_resolve(), e._backpressureChangePromise = u((t) => {
+		e._backpressureChangePromise_resolve = t;
+	}), e._backpressure = t;
+}
+Object.defineProperties(TransformStream.prototype, {
+	readable: { enumerable: !0 },
+	writable: { enumerable: !0 }
+}), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(TransformStream.prototype, Symbol.toStringTag, {
+	value: "TransformStream",
+	configurable: !0
+});
+var TransformStreamDefaultController = class {
+	constructor() {
+		throw new TypeError("Illegal constructor");
+	}
+	get desiredSize() {
+		if (!so(this)) throw fo("desiredSize");
+		return Pr(this._controlledTransformStream._readable._readableStreamController);
+	}
+	enqueue(e = void 0) {
+		if (!so(this)) throw fo("enqueue");
+		uo(this, e);
+	}
+	error(e = void 0) {
+		if (!so(this)) throw fo("error");
+		var t = e;
+		oo(this._controlledTransformStream, t);
+	}
+	terminate() {
+		if (!so(this)) throw fo("terminate");
+		(function(e) {
+			const t = e._controlledTransformStream;
+			wr(t._readable._readableStreamController);
+			no(t, /* @__PURE__ */ new TypeError("TransformStream terminated"));
+		})(this);
+	}
+};
+function so(e) {
+	return !!t(e) && !!Object.prototype.hasOwnProperty.call(e, "_controlledTransformStream") && e instanceof TransformStreamDefaultController;
+}
+function lo(e) {
+	e._transformAlgorithm = void 0, e._flushAlgorithm = void 0, e._cancelAlgorithm = void 0;
+}
+function uo(e, t) {
+	const r = e._controlledTransformStream, o = r._readable._readableStreamController;
+	if (!Cr(o)) throw new TypeError("Readable side is not in a state that permits enqueue");
+	try {
+		Rr(o, t);
+	} catch (e) {
+		throw no(r, e), r._readable._storedError;
+	}
+	(function(e) {
+		return !gr(e);
+	})(o) !== r._backpressure && ao(r, !0);
+}
+function co(e, t) {
+	return m(e._transformAlgorithm(t), void 0, (t) => {
+		throw oo(e._controlledTransformStream, t), t;
+	});
+}
+function fo(e) {
+	return /* @__PURE__ */ new TypeError(`TransformStreamDefaultController.prototype.${e} can only be used on a TransformStreamDefaultController`);
+}
+function ho(e) {
+	void 0 !== e._finishPromise_resolve && (e._finishPromise_resolve(), e._finishPromise_resolve = void 0, e._finishPromise_reject = void 0);
+}
+function bo(e, t) {
+	void 0 !== e._finishPromise_reject && (p(e._finishPromise), e._finishPromise_reject(t), e._finishPromise_resolve = void 0, e._finishPromise_reject = void 0);
+}
+function _o(e) {
+	return /* @__PURE__ */ new TypeError(`TransformStream.prototype.${e} can only be used on a TransformStream`);
+}
+Object.defineProperties(TransformStreamDefaultController.prototype, {
+	enqueue: { enumerable: !0 },
+	error: { enumerable: !0 },
+	terminate: { enumerable: !0 },
+	desiredSize: { enumerable: !0 }
+}), o(TransformStreamDefaultController.prototype.enqueue, "enqueue"), o(TransformStreamDefaultController.prototype.error, "error"), o(TransformStreamDefaultController.prototype.terminate, "terminate"), "symbol" == typeof Symbol.toStringTag && Object.defineProperty(TransformStreamDefaultController.prototype, Symbol.toStringTag, {
+	value: "TransformStreamDefaultController",
+	configurable: !0
+});
+//#endregion
+//#region node_modules/.pnpm/koajax@3.3.1_typescript@6.0.3/node_modules/koajax/dist/index.esm.js
+function $parcel$export(e, n, v, s) {
+	Object.defineProperty(e, n, {
+		get: v,
+		set: s,
+		enumerable: true,
+		configurable: true
+	});
+}
+$parcel$export({}, "Stack", function() {
+	return $eef213ff4197108b$export$694e0d28c7ffc90c;
+});
+const { push: $eef213ff4197108b$var$push } = Array.prototype;
+var $eef213ff4197108b$export$694e0d28c7ffc90c = class {
+	use(...middlewares) {
+		$eef213ff4197108b$var$push.apply(this, middlewares);
+		return this;
+	}
+	execute(context, depth = 0) {
+		const middleware = this[depth];
+		if (middleware instanceof Function) return middleware(context, this.execute.bind(this, context, ++depth));
+	}
+	mount(condition, stack) {
+		return this.use((context, next) => condition(context) ? stack.execute(context) : next());
+	}
+	constructor() {
+		this.length = 0;
+	}
+};
+var $0fe1f1400993ba8a$exports = {};
+$parcel$export($0fe1f1400993ba8a$exports, "BodyRequestMethods", function() {
+	return $0fe1f1400993ba8a$export$4125cfe7e08e2040;
+});
+$parcel$export($0fe1f1400993ba8a$exports, "HTTPError", function() {
+	return $0fe1f1400993ba8a$export$aa9d629c530f62a7;
+});
+$parcel$export($0fe1f1400993ba8a$exports, "headerParser", function() {
+	return $0fe1f1400993ba8a$export$b725a69477e4d33f;
+});
+$parcel$export($0fe1f1400993ba8a$exports, "parseHeaders", function() {
+	return $0fe1f1400993ba8a$export$eea2c1c5e1a37e50;
+});
+$parcel$export($0fe1f1400993ba8a$exports, "parseBody", function() {
+	return $0fe1f1400993ba8a$export$3b629cd0ff482602;
+});
+$parcel$export($0fe1f1400993ba8a$exports, "FILE_TYPE_MAGIC_NUMBER_SIZE", function() {
+	return $0fe1f1400993ba8a$export$153cac11fce574d;
+});
+$parcel$export($0fe1f1400993ba8a$exports, "defaultHTTPRuntime", function() {
+	return $0fe1f1400993ba8a$export$80e06a8ed038dcf8;
+});
+$parcel$export($0fe1f1400993ba8a$exports, "HTTPToolkit", function() {
+	return $0fe1f1400993ba8a$export$7370b3fc922cf1e6;
+});
+$parcel$export($0fe1f1400993ba8a$exports, "requestXHR", function() {
+	return $0fe1f1400993ba8a$export$4f2a8c8c11a6373a;
+});
+$parcel$export($0fe1f1400993ba8a$exports, "requestFetch", function() {
+	return $0fe1f1400993ba8a$export$bda27a3e49197b9;
+});
+$parcel$export($0fe1f1400993ba8a$exports, "parseResponse", function() {
+	return $0fe1f1400993ba8a$export$ba14d9a5a581e827;
+});
+$parcel$export($0fe1f1400993ba8a$exports, "parseFetchBody", function() {
+	return $0fe1f1400993ba8a$export$b7b86d31099674dc;
+});
+$parcel$export($0fe1f1400993ba8a$exports, "rawRequest", function() {
+	return $0fe1f1400993ba8a$export$3052fa16c23a17ef;
+});
+$parcel$export($0fe1f1400993ba8a$exports, "requestHead", function() {
+	return $0fe1f1400993ba8a$export$199f266664335871;
+});
+$parcel$export($0fe1f1400993ba8a$exports, "request", function() {
+	return $0fe1f1400993ba8a$export$b5fe3f66a567bec0;
+});
+var $22de11b45b0eeb97$exports = {};
+$parcel$export($22de11b45b0eeb97$exports, "FileMethod", function() {
+	return $22de11b45b0eeb97$export$226b21d2db5eaf9f;
+});
+$parcel$export($22de11b45b0eeb97$exports, "defaultDataRuntime", function() {
+	return $22de11b45b0eeb97$export$f7195e83247c5fe1;
+});
+$parcel$export($22de11b45b0eeb97$exports, "DataToolkit", function() {
+	return $22de11b45b0eeb97$export$bc241bb96b6158a8;
+});
+$parcel$export($22de11b45b0eeb97$exports, "polyfillProgressEvent", function() {
+	return $22de11b45b0eeb97$export$5e6a03ce7b01784;
+});
+$parcel$export($22de11b45b0eeb97$exports, "parseDocument", function() {
+	return $22de11b45b0eeb97$export$b6a9369736b19f4d;
+});
+$parcel$export($22de11b45b0eeb97$exports, "makeFormData", function() {
+	return $22de11b45b0eeb97$export$2c28ab2e118e73f1;
+});
+$parcel$export($22de11b45b0eeb97$exports, "serializeNode", function() {
+	return $22de11b45b0eeb97$export$a0beee2e55fb5dd1;
+});
+$parcel$export($22de11b45b0eeb97$exports, "serialize", function() {
+	return $22de11b45b0eeb97$export$dfdc1655ccc5b9cb;
+});
+$parcel$export($22de11b45b0eeb97$exports, "takeBytes", function() {
+	return $22de11b45b0eeb97$export$45c4469e58b7b0ca;
+});
+$parcel$export($22de11b45b0eeb97$exports, "readBytes", function() {
+	return $22de11b45b0eeb97$export$f9f241124ee3198e;
+});
+$parcel$export($22de11b45b0eeb97$exports, "makeStream", function() {
+	return $22de11b45b0eeb97$export$4b366c43f3cabead;
+});
+$parcel$export($22de11b45b0eeb97$exports, "streamFromProgress", function() {
+	return $22de11b45b0eeb97$export$f8162fcba31fa547;
+});
+$parcel$export($22de11b45b0eeb97$exports, "emitStreamProgress", function() {
+	return $22de11b45b0eeb97$export$cebfdbc318a33abe;
+});
+$parcel$export($22de11b45b0eeb97$exports, "readAs", function() {
+	return $22de11b45b0eeb97$export$e209cbb66c5b18c;
+});
+$parcel$export($22de11b45b0eeb97$exports, "encodeBase64", function() {
+	return $22de11b45b0eeb97$export$8fb536984ec8b4d7;
+});
+var $22de11b45b0eeb97$export$226b21d2db5eaf9f = /*#__PURE__*/ function(FileMethod) {
+	FileMethod["text"] = "readAsText";
+	FileMethod["dataURL"] = "readAsDataURL";
+	FileMethod["binaryString"] = "readAsBinaryString";
+	FileMethod["arrayBuffer"] = "readAsArrayBuffer";
+	return FileMethod;
+}({});
+const $22de11b45b0eeb97$var$DataURI = /^data:(.+?\/(.+?))?(;base64)?,([\s\S]+)/;
+const $22de11b45b0eeb97$export$f7195e83247c5fe1 = {
+	DOMParser: globalThis.DOMParser,
+	Node: globalThis.Node,
+	Document: globalThis.Document,
+	HTMLElement: globalThis.HTMLElement,
+	SVGElement: globalThis.SVGElement,
+	FormData: globalThis.FormData,
+	URLSearchParams: globalThis.URLSearchParams,
+	Blob: globalThis.Blob,
+	FileReader: globalThis.FileReader,
+	Event: globalThis.Event,
+	ProgressEvent: globalThis.ProgressEvent,
+	ReadableStream
+};
+var $22de11b45b0eeb97$export$bc241bb96b6158a8 = class {
+	constructor(runtime = $22de11b45b0eeb97$export$f7195e83247c5fe1) {
+		this.runtime = runtime;
+		this.polyfillProgressEvent = () => globalThis.ProgressEvent ||= class ProgressEvent extends this.runtime.Event {
+			constructor(type, { lengthComputable, total, loaded, ...meta } = {}) {
+				super(type, meta);
+				this.lengthComputable = lengthComputable;
+				this.total = total;
+				this.loaded = loaded;
+			}
+		};
+		this.parseDocument = async (text, contentType = "") => {
+			const { DOMParser } = this.runtime;
+			const [type] = contentType?.split(";") || [];
+			return new DOMParser().parseFromString(text, type || "text/html");
+		};
+		this.makeFormData = (data) => {
+			const { FormData } = this.runtime;
+			const formData = new FormData();
+			for (const [key, value] of Object.entries(data)) {
+				const list = typeof value !== "string" && (0, web_utility.likeArray)(value) ? value : [value];
+				for (const item of Array.from(list)) if (item != null) {
+					if (typeof item === "object") formData.append(key, item, item.name);
+					else formData.append(key, item);
+				}
+			}
+			return formData;
+		};
+		this.serializeNode = (root) => {
+			const { URLSearchParams, FormData, Document, HTMLElement, SVGElement } = this.runtime;
+			var contentType;
+			if (!(root instanceof HTMLFormElement)) return {
+				contentType: root instanceof SVGElement ? "image/svg" : root instanceof Document || root instanceof HTMLElement ? "text/html" : "application/xml",
+				data: (0, web_utility.stringifyDOM)(root)
+			};
+			if (root.querySelector("input[type=\"file\"][name]")) return {
+				contentType: "multipart/form-data",
+				data: new FormData(root)
+			};
+			const data = (0, web_utility.formToJSON)(root);
+			switch (contentType = root.enctype) {
+				case "text/plain": return {
+					contentType,
+					data: Object.entries(data).map(([name, value]) => `${name}=${value}`).join("\n")
+				};
+				case "application/x-www-form-urlencoded": return {
+					contentType,
+					data: new URLSearchParams(data)
+				};
+				default: return {
+					contentType: "application/json",
+					data: JSON.stringify(data)
+				};
+			}
+		};
+		this.serialize = (data, contentType) => {
+			const { Node, URLSearchParams, FormData, Blob, ReadableStream } = this.runtime;
+			const [type] = contentType?.split(";") || [];
+			switch (type) {
+				case "application/x-www-form-urlencoded": return {
+					contentType,
+					data: new URLSearchParams(data)
+				};
+				case "multipart/form-data": return { data: this.makeFormData(data) };
+				case "application/json": return {
+					contentType,
+					data: JSON.stringify(data)
+				};
+				case "text/html":
+				case "application/xml":
+				case "image/svg": return {
+					contentType,
+					data: (0, web_utility.stringifyDOM)(data)
+				};
+			}
+			if (type) return {
+				data,
+				contentType
+			};
+			try {
+				if (data instanceof URLSearchParams) return {
+					contentType: "application/x-www-form-urlencoded",
+					data
+				};
+			} catch {}
+			try {
+				if (data instanceof FormData) return { data };
+			} catch {}
+			try {
+				if (data instanceof Node) return this.serializeNode(data);
+			} catch {}
+			try {
+				if ((0, web_utility.isTypedArray)(data) || data instanceof ArrayBuffer || data instanceof DataView || data instanceof Blob || data instanceof ReadableStream) return {
+					contentType: "application/octet-stream",
+					data
+				};
+			} catch {}
+			try {
+				return {
+					contentType: "application/json",
+					data: JSON.stringify(data)
+				};
+			} catch {}
+			throw new Error("Unserialized Object needs a specific Content-Type");
+		};
+		this.readBytes = async (stream, limit = Infinity) => {
+			const { Blob } = this.runtime;
+			return new Blob(await Array.fromAsync(this.takeBytes(stream, limit))).arrayBuffer();
+		};
+		this.makeStream = (...chunks) => {
+			const { Blob } = this.runtime;
+			return new Blob(chunks).stream();
+		};
+		this.streamFromProgress = (target) => (0, web_utility.createAsyncIterator)(({ next, complete, error }) => {
+			const handleProgress = ({ loaded, total }) => {
+				next({
+					loaded,
+					total
+				});
+				if (loaded >= total) complete();
+			};
+			target.addEventListener("progress", handleProgress);
+			target.addEventListener("error", error);
+			return () => {
+				target.removeEventListener("progress", handleProgress);
+				target.removeEventListener("error", error);
+			};
+		});
+		this.emitStreamProgress = (stream, total, eventTarget) => {
+			const { ProgressEvent } = this.runtime;
+			return async function* () {
+				var loaded = 0;
+				for await (const chunk of stream) {
+					yield chunk;
+					loaded += chunk.byteLength;
+					const event = new ProgressEvent("progress", {
+						lengthComputable: isNaN(total),
+						loaded,
+						total
+					});
+					eventTarget.dispatchEvent(event);
+				}
+			}();
+		};
+		this.readAs = (file, method, encoding) => {
+			const { FileReader } = this.runtime;
+			const reader = new FileReader();
+			const result = new Promise((resolve, reject) => {
+				reader.onerror = reject;
+				reader.onload = () => resolve(reader.result);
+				reader[$22de11b45b0eeb97$export$226b21d2db5eaf9f[method]](file, encoding);
+			});
+			return {
+				progress: this.streamFromProgress(reader),
+				result
+			};
+		};
+		this.encodeBase64 = async (raw) => {
+			const { Blob } = this.runtime;
+			if (raw instanceof Blob) {
+				const text = await this.readAs(raw, "dataURL").result;
+				return ($22de11b45b0eeb97$var$DataURI.exec(text) || "")[4];
+			}
+			const text = encodeURIComponent(raw).replace(/%([0-9A-F]{2})/g, (_, p1) => String.fromCharCode(+("0x" + p1)));
+			return btoa(text);
+		};
+		if (runtime.Event) this.runtime.ProgressEvent = this.polyfillProgressEvent();
+	}
+	async *takeBytes(stream, limit = Infinity) {
+		let total = 0;
+		for await (const chunk of stream) {
+			const remaining = limit - total;
+			if (chunk.byteLength > remaining) {
+				yield chunk.slice(0, remaining);
+				break;
+			}
+			yield new Uint8Array(chunk);
+			total += chunk.byteLength;
+			if (total >= limit) break;
+		}
+	}
+};
+const { polyfillProgressEvent: $22de11b45b0eeb97$export$5e6a03ce7b01784, parseDocument: $22de11b45b0eeb97$export$b6a9369736b19f4d, makeFormData: $22de11b45b0eeb97$export$2c28ab2e118e73f1, serializeNode: $22de11b45b0eeb97$export$a0beee2e55fb5dd1, serialize: $22de11b45b0eeb97$export$dfdc1655ccc5b9cb, takeBytes: $22de11b45b0eeb97$export$45c4469e58b7b0ca, readBytes: $22de11b45b0eeb97$export$f9f241124ee3198e, makeStream: $22de11b45b0eeb97$export$4b366c43f3cabead, streamFromProgress: $22de11b45b0eeb97$export$f8162fcba31fa547, emitStreamProgress: $22de11b45b0eeb97$export$cebfdbc318a33abe, readAs: $22de11b45b0eeb97$export$e209cbb66c5b18c, encodeBase64: $22de11b45b0eeb97$export$8fb536984ec8b4d7 } = new $22de11b45b0eeb97$export$bc241bb96b6158a8();
+var $0fe1f1400993ba8a$export$4125cfe7e08e2040 = /*#__PURE__*/ function(BodyRequestMethods) {
+	BodyRequestMethods["POST"] = "POST";
+	BodyRequestMethods["PUT"] = "PUT";
+	BodyRequestMethods["PATCH"] = "PATCH";
+	BodyRequestMethods["DELETE"] = "DELETE";
+	return BodyRequestMethods;
+}({});
+var $0fe1f1400993ba8a$export$aa9d629c530f62a7 = class extends URIError {
+	constructor(message, request, response) {
+		super(message), this.request = request, this.response = response;
+	}
+};
+const $0fe1f1400993ba8a$export$b725a69477e4d33f = { Link: (value) => Object.fromEntries(Array.from(value.matchAll(/<(\S+?)>; rel="(\w+)"(?:; title="(.*?)")?/g), ([_, URI, rel, title]) => [rel, {
+	rel,
+	URI,
+	title
+}])) };
+const $0fe1f1400993ba8a$export$eea2c1c5e1a37e50 = (raw) => Object.fromEntries(Array.from(raw.trim().matchAll(/^([\w-]+):\s*(.*)/gm), ([_, key, value]) => {
+	key = key.replace(/(^[a-z]|-[a-z])/g, (char) => char.toUpperCase());
+	return [key, $0fe1f1400993ba8a$export$b725a69477e4d33f[key]?.(value) ?? value];
+}));
+function $0fe1f1400993ba8a$export$3b629cd0ff482602(raw, contentType) {
+	if (contentType.includes("json")) return (0, web_utility.parseJSON)(raw);
+	if (contentType.match(/html|xml/)) try {
+		return this.parseDocument(raw, contentType);
+	} catch {}
+	if (contentType.includes("text")) return raw;
+	return new TextEncoder().encode(raw).buffer;
+}
+const $0fe1f1400993ba8a$export$153cac11fce574d = 4100;
+const $0fe1f1400993ba8a$export$80e06a8ed038dcf8 = {
+	...$22de11b45b0eeb97$export$f7195e83247c5fe1,
+	EventTarget: globalThis.EventTarget,
+	XMLHttpRequest: globalThis.XMLHttpRequest,
+	Headers: globalThis.Headers,
+	fetch: globalThis.fetch
+};
+var $0fe1f1400993ba8a$export$7370b3fc922cf1e6 = class extends $22de11b45b0eeb97$export$bc241bb96b6158a8 {
+	constructor(runtime = $0fe1f1400993ba8a$export$80e06a8ed038dcf8) {
+		super(runtime), this.runtime = runtime, this.requestXHR = ({ method = "GET", path, headers = {}, body, signal, ...rest }) => {
+			const { XMLHttpRequest, Headers, Blob, ReadableStream } = this.runtime;
+			const request = new XMLHttpRequest();
+			const header = new Headers(headers);
+			const bodyPromise = body instanceof ReadableStream ? Array.fromAsync(body).then((parts) => new Blob(parts)) : Promise.resolve(body);
+			const abort = () => request.abort();
+			signal?.addEventListener("abort", abort);
+			const response = new Promise((resolve, reject) => {
+				request.onreadystatechange = () => {
+					const { readyState, status, statusText, responseType } = request;
+					if (readyState !== 4 || !status && !signal?.aborted) return;
+					resolve({
+						status,
+						statusText,
+						headers: $0fe1f1400993ba8a$export$eea2c1c5e1a37e50(request.getAllResponseHeaders()),
+						body: responseType && responseType !== "text" ? request.response : request.responseText
+					});
+				};
+				request.onerror = request.ontimeout = reject;
+				const [MIMEType] = header.get("Accept")?.split(",") || [rest.responseType === "document" ? "application/xhtml+xml" : rest.responseType === "json" ? "application/json" : ""];
+				if (MIMEType) request.overrideMimeType(MIMEType);
+				request.open(method, path + "");
+				for (const [key, value] of header) request.setRequestHeader(key, value);
+				Object.assign(request, rest);
+				bodyPromise.then((body) => request.send(body));
+			}).then(({ body, ...meta }) => {
+				signal?.throwIfAborted();
+				const contentType = request.getResponseHeader("Content-Type") || "";
+				if (typeof body === "string" && !contentType.includes("text")) body = $0fe1f1400993ba8a$export$3b629cd0ff482602(body, contentType);
+				return {
+					...meta,
+					body
+				};
+			});
+			response.finally(() => signal?.removeEventListener("abort", abort));
+			return {
+				response,
+				upload: this.streamFromProgress(request.upload),
+				download: this.streamFromProgress(request)
+			};
+		}, this.requestFetch = ({ path, method, headers, withCredentials, body, signal, timeout, responseType }) => {
+			const { EventTarget, Headers, ReadableStream, fetch } = this.runtime;
+			const signals = [signal, timeout && AbortSignal.timeout(timeout)].filter(Boolean);
+			headers = headers instanceof Headers ? Object.fromEntries(headers.entries()) : headers instanceof Array ? Object.fromEntries(headers) : headers;
+			headers = responseType === "text" ? {
+				...headers,
+				Accept: "text/plain"
+			} : responseType === "json" ? {
+				...headers,
+				Accept: "application/json"
+			} : responseType === "document" ? {
+				...headers,
+				Accept: "text/html, application/xhtml+xml, application/xml"
+			} : responseType === "arraybuffer" || responseType === "blob" ? {
+				...headers,
+				Accept: "application/octet-stream"
+			} : headers;
+			const isStream = body instanceof ReadableStream;
+			var upload;
+			if (isStream) {
+				const uploadProgress = new EventTarget();
+				body = ReadableStream.from(this.emitStreamProgress(body, +headers["Content-Length"], uploadProgress));
+				upload = this.streamFromProgress(uploadProgress);
+			}
+			const downloadProgress = new EventTarget();
+			const response = fetch(path + "", {
+				method,
+				headers,
+				credentials: withCredentials ? "include" : "omit",
+				body,
+				signal: signals[0] && AbortSignal.any(signals),
+				duplex: isStream ? "half" : void 0
+			}).then((response) => this.parseResponse(response, responseType, downloadProgress));
+			const download = this.streamFromProgress(downloadProgress);
+			return {
+				response,
+				upload,
+				download
+			};
+		}, this.parseResponse = async ({ status, statusText, headers, body }, responseType, downloadProgress) => {
+			const { ReadableStream } = this.runtime;
+			const contentType = headers.get("Content-Type") || "";
+			const header = $0fe1f1400993ba8a$export$eea2c1c5e1a37e50([...headers].map(([key, value]) => `${key}: ${value}`).join("\n"));
+			if (status === 204 || !body) return {
+				status,
+				statusText,
+				headers: header,
+				body: void 0
+			};
+			const stream = ReadableStream.from(this.emitStreamProgress(ReadableStream.from(body), +headers.get("Content-Length"), downloadProgress));
+			return {
+				status,
+				statusText,
+				headers: header,
+				body: await this.parseFetchBody(stream, contentType, responseType)
+			};
+		}, this.parseFetchBody = async (stream, contentType, responseType) => {
+			const { Blob } = this.runtime;
+			const blob = new Blob(await Array.fromAsync(stream), { type: contentType });
+			if (responseType === "blob") return blob;
+			if (responseType === "arraybuffer") return blob.arrayBuffer();
+			const text = await blob.text();
+			if (responseType === "text") return text;
+			return $0fe1f1400993ba8a$export$3b629cd0ff482602(text, contentType);
+		}, this.rawRequest = typeof this.runtime.XMLHttpRequest === "function" ? this.requestXHR : this.requestFetch, this.requestHead = async ({ path, headers, withCredentials, timeout, signal }) => {
+			const { Headers, fetch } = this.runtime;
+			const normalizedHeaders = !headers ? {} : headers instanceof Headers ? Object.fromEntries(headers) : Array.isArray(headers) ? Object.fromEntries(headers) : headers;
+			const signals = [signal, timeout && AbortSignal.timeout(timeout)].filter(Boolean);
+			const fetchOptions = {
+				credentials: withCredentials ? "include" : "omit",
+				signal: signals[1] ? AbortSignal.any(signals) : signals[0]
+			};
+			const toHeaders = (raw) => $0fe1f1400993ba8a$export$eea2c1c5e1a37e50([...raw].map(([k, v]) => `${k}: ${v}`).join("\n"));
+			try {
+				const response = await fetch(path + "", {
+					method: "HEAD",
+					...fetchOptions,
+					headers: normalizedHeaders
+				});
+				if (response.ok) return { headers: toHeaders(response.headers) };
+			} catch {}
+			try {
+				const response = await fetch(path + "", {
+					...fetchOptions,
+					headers: {
+						...normalizedHeaders,
+						Range: `bytes=0-4099`
+					}
+				});
+				if (!response.ok) throw new Error(`${response.status} ${response.statusText}`);
+				return {
+					headers: toHeaders(response.headers),
+					body: await response.arrayBuffer()
+				};
+			} catch {}
+			const response = await fetch(path, {
+				...fetchOptions,
+				headers: normalizedHeaders
+			});
+			const body = await this.readBytes(ReadableStream.from(response.body), $0fe1f1400993ba8a$export$153cac11fce574d);
+			return {
+				headers: toHeaders(response.headers),
+				body
+			};
+		}, this.request = (option) => {
+			if (option.method !== "HEAD") return this.rawRequest(option);
+			return {
+				response: this.requestHead(option).then(({ headers, body }) => ({
+					status: 204,
+					statusText: "No Content",
+					headers,
+					body
+				})),
+				download: async function* () {}()
+			};
+		};
+	}
+};
+const { requestXHR: $0fe1f1400993ba8a$export$4f2a8c8c11a6373a, requestFetch: $0fe1f1400993ba8a$export$bda27a3e49197b9, parseResponse: $0fe1f1400993ba8a$export$ba14d9a5a581e827, parseFetchBody: $0fe1f1400993ba8a$export$b7b86d31099674dc, rawRequest: $0fe1f1400993ba8a$export$3052fa16c23a17ef, requestHead: $0fe1f1400993ba8a$export$199f266664335871, request: $0fe1f1400993ba8a$export$b5fe3f66a567bec0 } = new $0fe1f1400993ba8a$export$7370b3fc922cf1e6();
+$parcel$export({}, "HTTPClient", function() {
+	return $cbd22d3323bef9ca$export$45cf759b359d3d24;
+});
+const { splice: $cbd22d3323bef9ca$var$splice } = Array.prototype;
+var $cbd22d3323bef9ca$export$45cf759b359d3d24 = class extends $eef213ff4197108b$export$694e0d28c7ffc90c {
+	constructor({ baseURI = globalThis.document?.baseURI, baseRequest = $0fe1f1400993ba8a$export$b5fe3f66a567bec0, ...options } = {}) {
+		super(), this.defaultWare = async ({ request, response }, next) => {
+			const { method = "GET", headers = {}, body } = request;
+			if (method in $0fe1f1400993ba8a$export$4125cfe7e08e2040 && body && typeof body === "object") {
+				const { contentType, data } = $22de11b45b0eeb97$export$dfdc1655ccc5b9cb(body, headers["Content-Type"]);
+				if (contentType) headers["Content-Type"] = contentType;
+				request.body = data;
+			}
+			await next();
+			if (response.status > 299) throw new $0fe1f1400993ba8a$export$aa9d629c530f62a7(response.statusText, request, response);
+		};
+		this.baseURI = baseURI;
+		this.baseRequest = baseRequest;
+		this.options = options;
+		super.use(this.defaultWare);
+		super.use(async ({ request: data, response }) => {
+			data.path = new URL(data.path, this.baseURI) + "";
+			Object.assign(response, await this.baseRequest({
+				...options,
+				...data
+			}).response);
+		});
+	}
+	use(...middlewares) {
+		$cbd22d3323bef9ca$var$splice.call(this, -2, 0, ...middlewares);
+		return this;
+	}
+	async request(data) {
+		const context = {
+			request: {
+				...data,
+				headers: { ...data.headers }
+			},
+			response: {}
+		};
+		await this.execute(context);
+		return context.response;
+	}
+	async head(path, headers, options) {
+		const { headers: data } = await this.request({
+			method: "HEAD",
+			path,
+			headers,
+			...options
+		});
+		return data;
+	}
+	get(path, headers, options) {
+		return this.request({
+			method: "GET",
+			path,
+			headers,
+			...options
+		});
+	}
+	post(path, body, headers, options) {
+		return this.request({
+			method: "POST",
+			path,
+			headers,
+			body,
+			...options
+		});
+	}
+	put(path, body, headers, options) {
+		return this.request({
+			method: "PUT",
+			path,
+			headers,
+			body,
+			...options
+		});
+	}
+	patch(path, body, headers, options) {
+		return this.request({
+			method: "PATCH",
+			path,
+			headers,
+			body,
+			...options
+		});
+	}
+	delete(path, body, headers, options) {
+		return this.request({
+			method: "DELETE",
+			path,
+			headers,
+			body,
+			...options
+		});
+	}
+	async *download(path, { headers, chunkSize = 1024 ** 2, range: [start = 0, end = Infinity] = [], ...options } = {}) {
+		const { "Content-Length": length } = await this.head(path, headers, options);
+		const total = +length;
+		if (end === Infinity) end = total;
+		for (let i = start, j = i - 1 + chunkSize; i < end; i = j + 1, j += chunkSize) {
+			const { status, body } = await this.get(path, {
+				...headers,
+				Range: `bytes=${i}-${j}`
+			}, options);
+			if (status !== 206) {
+				yield {
+					total,
+					loaded: total,
+					percent: 100,
+					buffer: body
+				};
+				break;
+			}
+			const loaded = i + body.byteLength;
+			yield {
+				total,
+				loaded,
+				percent: +(loaded / total * 100).toFixed(2),
+				buffer: body
+			};
+		}
+	}
+};
+//#endregion
+//#region source/SSR/middleware/local.ts
+async function errorLogger(context, next) {
+	try {
+		return await next();
+	} catch (error) {
+		console.error(error);
+		if (error instanceof $0fe1f1400993ba8a$export$aa9d629c530f62a7) {
+			const { status } = error.response;
+			if (status === 404) return {
+				notFound: true,
+				props: {}
+			};
+		}
+		throw error;
+	}
+}
+async function router(context, next) {
+	const options = await next() || {}, { resolvedUrl, params, query, locales } = context;
+	return {
+		...options,
+		props: {
+			..."props" in options ? options.props : {},
+			route: JSON.parse(JSON.stringify({
+				resolvedUrl,
+				params,
+				query,
+				locales
+			}))
+		}
+	};
+}
+function jwtVerifier(tokenKey = "token", secretKey = "JWT_SECRET", options = {}) {
+	return async ({ req: { url, cookies } }, next) => {
+		const token = cookies[tokenKey] || "", secret = process.env[secretKey] || "";
+		let jwtPayload;
+		try {
+			jwtPayload = (0, jsonwebtoken.verify)(token, secret, options);
+		} catch (error) {
+			console.error(url, error);
+		}
+		const data = await next();
+		if ("props" in data && jwtPayload) data.props["jwtPayload"] = jwtPayload;
+		return data;
+	};
+}
+const serverRenderCache = {};
+function cache(oneInterval = 30 * web_utility.Second, allInterval = web_utility.Day) {
+	function cleanCache() {
+		for (const [URI, { expiredAt = 0 }] of Object.entries(serverRenderCache)) if (Date.now() - expiredAt > allInterval) delete serverRenderCache[URI];
+	}
+	return (async (context, next) => {
+		const { resolvedUrl, req } = context;
+		const cache = serverRenderCache[resolvedUrl] ||= {}, noCache = req.headers["cache-control"] === "no-cache", title = `[SSR cache] ${resolvedUrl}`;
+		const { data, expiredAt = 0 } = cache;
+		if ((!data || expiredAt < Date.now() || noCache) && !cache.buffer) {
+			console.time(title);
+			cache.buffer = next().then((data) => {
+				cache.data = data;
+				cache.expiredAt = Date.now() + oneInterval;
+				console.log(cache);
+				return data;
+			}).finally(() => {
+				delete cache.buffer;
+				cleanCache();
+				console.timeEnd(title);
+			});
+		}
+		return data || cache.buffer;
+	});
+}
+//#endregion
+//#region source/utility.ts
+const { NODE_ENV, VERCEL_ENV = NODE_ENV, VERCEL_URL, VERCEL_PROJECT_PRODUCTION_URL } = process.env;
+const RemoteDomain = VERCEL_ENV === "production" ? VERCEL_PROJECT_PRODUCTION_URL : VERCEL_URL;
+const CurrentHost = RemoteDomain ? `https://${RemoteDomain}` : "http://localhost:3000";
+//#endregion
+//#region source/SSR/middleware/remote.ts
+function oauth2Signer({ signInURL, accessToken, userProfile, tokenKey = "token" }) {
+	return async ({ req: { url, headers, cookies }, query, res }, next) => {
+		const token = cookies[tokenKey] || query[tokenKey];
+		const pageURL = new URL(url || "/", headers["origin"] || CurrentHost);
+		if (query.code) {
+			const token = await accessToken(query), { searchParams } = pageURL;
+			try {
+				res.setHeader("Set-Cookie", `${tokenKey}=${token}; Path=/`);
+			} catch {
+				searchParams.set(tokenKey, token);
+			}
+			searchParams.delete("code");
+			if (searchParams.get("state") === "") searchParams.delete("state");
+			return {
+				redirect: {
+					destination: pageURL + "",
+					permanent: false
+				},
+				props: {}
+			};
+		}
+		if (token) {
+			const user = await userProfile?.(token + ""), data = await next();
+			const props = "props" in data ? {
+				...data.props,
+				token,
+				user
+			} : {};
+			return {
+				...data,
+				props
+			};
+		}
+		return {
+			redirect: {
+				destination: signInURL(pageURL + ""),
+				permanent: false
+			},
+			props: {}
+		};
+	};
+}
+function githubOAuth2({ rootBaseURL = "https://github.com", apiBaseURL = "https://api.github.com", client_id, client_secret, scopes, allow_signup = true }) {
+	return oauth2Signer({
+		signInURL: (redirect_uri) => `https://github.com/login/oauth/authorize?${(0, web_utility.buildURLData)({
+			client_id,
+			scope: scopes?.join(" "),
+			allow_signup,
+			redirect_uri
+		})}`,
+		accessToken: async ({ code }) => {
+			const { error, access_token } = await (await fetch(new URL("login/oauth/access_token", rootBaseURL), {
+				method: "POST",
+				headers: {
+					Accept: "application/json",
+					"Content-Type": "application/json"
+				},
+				body: JSON.stringify({
+					client_id,
+					client_secret,
+					code
+				})
+			})).json();
+			if (error) throw new URIError(error);
+			return access_token;
+		},
+		userProfile: async (token) => {
+			const response = await fetch(new URL("user", apiBaseURL), { headers: {
+				Authorization: `Bearer ${token}`,
+				Accept: "application/json"
+			} });
+			if (response.status < 300) return response.json();
+			throw new URIError("Invalid GitHub access token");
+		}
+	});
+}
+//#endregion
+//#region source/SSR/shim.ts
+/**
+* @see {@link https://www.propelauth.com/post/getting-url-in-next-server-components}
+*/
+function patchHeaders(request) {
+	const resolvedUrl = request.nextUrl + "", { locale, defaultLocale = "", domainLocale } = request.nextUrl, headers = new Headers(request.headers);
+	const locales = domainLocale?.locales?.join(",") || locale;
+	headers.set("x-resolved-url", resolvedUrl);
+	headers.set("x-locale", locale);
+	headers.set("x-locales", locales);
+	headers.set("x-default-locale", defaultLocale);
+	return headers;
+}
+const withMiddleware = (getServerSideProps, serverComponent) => async ({ params, searchParams }) => {
+	const { headers, cookies, draftMode } = await import("next/headers");
+	const resolvedParams = await params, resolvedSearchParams = await searchParams, header = await headers(), cookie = await cookies(), { isEnabled } = await draftMode();
+	const url = header.get("x-resolved-url") || "", locale = header.get("x-locale") || "", locales = header.get("x-locales")?.split(",") || [], defaultLocale = header.get("x-default-locale") || "";
+	const result = await getServerSideProps({
+		req: {
+			url,
+			headers: Object.fromEntries([...header]),
+			cookies: Object.fromEntries(cookie.getAll().map(({ name, value }) => [name, value]))
+		},
+		res: {},
+		params: resolvedParams,
+		query: resolvedSearchParams,
+		preview: false,
+		previewData: {},
+		draftMode: isEnabled,
+		resolvedUrl: url,
+		locale,
+		locales,
+		defaultLocale
+	});
+	if ("redirect" in result) {
+		const { redirect, permanentRedirect } = await import("next/navigation");
+		const isPermanent = "statusCode" in result.redirect ? result.redirect.statusCode === 308 : "permanent" in result.redirect && result.redirect.permanent;
+		const { destination } = result.redirect;
+		if (isPermanent) permanentRedirect(destination);
+		else redirect(destination);
+	}
+	if ("props" in result) return serverComponent({
+		params,
+		searchParams,
+		...await result.props
+	});
+};
+//#endregion
+exports.CurrentHost = CurrentHost;
+exports.RemoteDomain = RemoteDomain;
+exports.cache = cache;
+exports.compose = compose;
+exports.createKoaRouter = createKoaRouter;
+exports.errorLogger = errorLogger;
+exports.githubOAuth2 = githubOAuth2;
+exports.jwtVerifier = jwtVerifier;
+exports.oauth2Signer = oauth2Signer;
+exports.pageApiRouteOf = pageApiRouteOf;
+exports.patchHeaders = patchHeaders;
+exports.router = router;
+exports.withKoa = withKoa;
+exports.withKoaRouter = withKoaRouter;
+exports.withMiddleware = withMiddleware;