https://app.sundaysky.com/client/vendor~index~newNavigation~Accoun…ISystemPromptManager~C~f6d7pve6.Df2s7yft.js

1
2!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="05712183-3e0c-5867-9604-61ae680444f1")}catch(e){}}();
3import { a as __toCommonJS, i as __require, n as __esmMin, o as __toESM, r as __exportAll, t as __commonJSMin } from "./rolldown-runtime.D1cXj70v.js";
4import { ft as require_browser$15 } from "./vendor~index~newNavigation~AccountTierManagementPage~AdminContainer~AISystemPromptManager~C~h0mf93xb.B-8UGg7U.js";
5//#region node_modules/base64-js/index.js
6var require_base64_js = /* @__PURE__ */ __commonJSMin(((exports) => {
7	exports.byteLength = byteLength;
8	exports.toByteArray = toByteArray;
9	exports.fromByteArray = fromByteArray;
10	var lookup = [];
11	var revLookup = [];
12	var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
13	var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
14	for (var i = 0, len = code.length; i < len; ++i) {
15		lookup[i] = code[i];
16		revLookup[code.charCodeAt(i)] = i;
17	}
18	revLookup["-".charCodeAt(0)] = 62;
19	revLookup["_".charCodeAt(0)] = 63;
20	function getLens(b64) {
21		var len = b64.length;
22		if (len % 4 > 0) throw new Error("Invalid string. Length must be a multiple of 4");
23		var validLen = b64.indexOf("=");
24		if (validLen === -1) validLen = len;
25		var placeHoldersLen = validLen === len ? 0 : 4 - validLen % 4;
26		return [validLen, placeHoldersLen];
27	}
28	function byteLength(b64) {
29		var lens = getLens(b64);
30		var validLen = lens[0];
31		var placeHoldersLen = lens[1];
32		return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
33	}
34	function _byteLength(b64, validLen, placeHoldersLen) {
35		return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
36	}
37	function toByteArray(b64) {
38		var tmp;
39		var lens = getLens(b64);
40		var validLen = lens[0];
41		var placeHoldersLen = lens[1];
42		var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
43		var curByte = 0;
44		var len = placeHoldersLen > 0 ? validLen - 4 : validLen;
45		var i;
46		for (i = 0; i < len; i += 4) {
47			tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];
48			arr[curByte++] = tmp >> 16 & 255;
49			arr[curByte++] = tmp >> 8 & 255;
50			arr[curByte++] = tmp & 255;
51		}
52		if (placeHoldersLen === 2) {
53			tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;
54			arr[curByte++] = tmp & 255;
55		}
56		if (placeHoldersLen === 1) {
57			tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2;
58			arr[curByte++] = tmp >> 8 & 255;
59			arr[curByte++] = tmp & 255;
60		}
61		return arr;
62	}
63	function tripletToBase64(num) {
64		return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
65	}
66	function encodeChunk(uint8, start, end) {
67		var tmp;
68		var output = [];
69		for (var i = start; i < end; i += 3) {
70			tmp = (uint8[i] << 16 & 16711680) + (uint8[i + 1] << 8 & 65280) + (uint8[i + 2] & 255);
71			output.push(tripletToBase64(tmp));
72		}
73		return output.join("");
74	}
75	function fromByteArray(uint8) {
76		var tmp;
77		var len = uint8.length;
78		var extraBytes = len % 3;
79		var parts = [];
80		var maxChunkLength = 16383;
81		for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
82		if (extraBytes === 1) {
83			tmp = uint8[len - 1];
84			parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
85		} else if (extraBytes === 2) {
86			tmp = (uint8[len - 2] << 8) + uint8[len - 1];
87			parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "=");
88		}
89		return parts.join("");
90	}
91}));
92//#endregion
93//#region node_modules/buffer/node_modules/ieee754/index.js
94var require_ieee754 = /* @__PURE__ */ __commonJSMin(((exports) => {
95	/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
96	exports.read = function(buffer, offset, isLE, mLen, nBytes) {
97		var e, m;
98		var eLen = nBytes * 8 - mLen - 1;
99		var eMax = (1 << eLen) - 1;
100		var eBias = eMax >> 1;
101		var nBits = -7;
102		var i = isLE ? nBytes - 1 : 0;
103		var d = isLE ? -1 : 1;
104		var s = buffer[offset + i];
105		i += d;
106		e = s & (1 << -nBits) - 1;
107		s >>= -nBits;
108		nBits += eLen;
109		for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);
110		m = e & (1 << -nBits) - 1;
111		e >>= -nBits;
112		nBits += mLen;
113		for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);
114		if (e === 0) e = 1 - eBias;
115		else if (e === eMax) return m ? NaN : (s ? -1 : 1) * Infinity;
116		else {
117			m = m + Math.pow(2, mLen);
118			e = e - eBias;
119		}
120		return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
121	};
122	exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
123		var e, m, c;
124		var eLen = nBytes * 8 - mLen - 1;
125		var eMax = (1 << eLen) - 1;
126		var eBias = eMax >> 1;
127		var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
128		var i = isLE ? 0 : nBytes - 1;
129		var d = isLE ? 1 : -1;
130		var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
131		value = Math.abs(value);
132		if (isNaN(value) || value === Infinity) {
133			m = isNaN(value) ? 1 : 0;
134			e = eMax;
135		} else {
136			e = Math.floor(Math.log(value) / Math.LN2);
137			if (value * (c = Math.pow(2, -e)) < 1) {
138				e--;
139				c *= 2;
140			}
141			if (e + eBias >= 1) value += rt / c;
142			else value += rt * Math.pow(2, 1 - eBias);
143			if (value * c >= 2) {
144				e++;
145				c /= 2;
146			}
147			if (e + eBias >= eMax) {
148				m = 0;
149				e = eMax;
150			} else if (e + eBias >= 1) {
151				m = (value * c - 1) * Math.pow(2, mLen);
152				e = e + eBias;
153			} else {
154				m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
155				e = 0;
156			}
157		}
158		for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8);
159		e = e << mLen | m;
160		eLen += mLen;
161		for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8);
162		buffer[offset + i - d] |= s * 128;
163	};
164}));
165//#endregion
166//#region node_modules/buffer/index.js
167/*!
168* The buffer module from node.js, for the browser.
169*
170* @author   Feross Aboukhadijeh <https://feross.org>
171* @license  MIT
172*/
173var require_buffer$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
174	var base64 = require_base64_js();
175	var ieee754 = require_ieee754();
176	var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
177	exports.Buffer = Buffer;
178	exports.SlowBuffer = SlowBuffer;
179	exports.INSPECT_MAX_BYTES = 50;
180	var K_MAX_LENGTH = 2147483647;
181	exports.kMaxLength = K_MAX_LENGTH;
182	/**
183	* If `Buffer.TYPED_ARRAY_SUPPORT`:
184	*   === true    Use Uint8Array implementation (fastest)
185	*   === false   Print warning and recommend using `buffer` v4.x which has an Object
186	*               implementation (most compatible, even IE6)
187	*
188	* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
189	* Opera 11.6+, iOS 4.2+.
190	*
191	* We report that the browser does not support typed arrays if the are not subclassable
192	* using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
193	* (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
194	* for __proto__ and has a buggy typed array implementation.
195	*/
196	Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport();
197	if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
198	function typedArraySupport() {
199		try {
200			const arr = /* @__PURE__ */ new Uint8Array(1);
201			const proto = { foo: function() {
202				return 42;
203			} };
204			Object.setPrototypeOf(proto, Uint8Array.prototype);
205			Object.setPrototypeOf(arr, proto);
206			return arr.foo() === 42;
207		} catch (e) {
208			return false;
209		}
210	}
211	Object.defineProperty(Buffer.prototype, "parent", {
212		enumerable: true,
213		get: function() {
214			if (!Buffer.isBuffer(this)) return void 0;
215			return this.buffer;
216		}
217	});
218	Object.defineProperty(Buffer.prototype, "offset", {
219		enumerable: true,
220		get: function() {
221			if (!Buffer.isBuffer(this)) return void 0;
222			return this.byteOffset;
223		}
224	});
225	function createBuffer(length) {
226		if (length > K_MAX_LENGTH) throw new RangeError("The value \"" + length + "\" is invali

226d for option \"size\"");
227		const buf = new Uint8Array(length);
228		Object.setPrototypeOf(buf, Buffer.prototype);
229		return buf;
230	}
231	/**
232	* The Buffer constructor returns instances of `Uint8Array` that have their
233	* prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
234	* `Uint8Array`, so the returned instances will have all the node `Buffer` methods
235	* and the `Uint8Array` methods. Square bracket notation works as expected -- it
236	* returns a single octet.
237	*
238	* The `Uint8Array` prototype remains unmodified.
239	*/
240	function Buffer(arg, encodingOrOffset, length) {
241		if (typeof arg === "number") {
242			if (typeof encodingOrOffset === "string") throw new TypeError("The \"string\" argument must be of type string. Received type number");
243			return allocUnsafe(arg);
244		}
245		return from(arg, encodingOrOffset, length);
246	}
247	Buffer.poolSize = 8192;
248	function from(value, encodingOrOffset, length) {
249		if (typeof value === "string") return fromString(value, encodingOrOffset);
250		if (ArrayBuffer.isView(value)) return fromArrayView(value);
251		if (value == null) throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
252		if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) return fromArrayBuffer(value, encodingOrOffset, length);
253		if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) return fromArrayBuffer(value, encodingOrOffset, length);
254		if (typeof value === "number") throw new TypeError("The \"value\" argument must not be of type number. Received type number");
255		const valueOf = value.valueOf && value.valueOf();
256		if (valueOf != null && valueOf !== value) return Buffer.from(valueOf, encodingOrOffset, length);
257		const b = fromObject(value);
258		if (b) return b;
259		if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") return Buffer.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
260		throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
261	}
262	/**
263	* Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
264	* if value is a number.
265	* Buffer.from(str[, encoding])
266	* Buffer.from(array)
267	* Buffer.from(buffer)
268	* Buffer.from(arrayBuffer[, byteOffset[, length]])
269	**/
270	Buffer.from = function(value, encodingOrOffset, length) {
271		return from(value, encodingOrOffset, length);
272	};
273	Object.setPrototypeOf(Buffer.prototype, Uint8Array.prototype);
274	Object.setPrototypeOf(Buffer, Uint8Array);
275	function assertSize(size) {
276		if (typeof size !== "number") throw new TypeError("\"size\" argument must be of type number");
277		else if (size < 0) throw new RangeError("The value \"" + size + "\" is invalid for option \"size\"");
278	}
279	function alloc(size, fill, encoding) {
280		assertSize(size);
281		if (size <= 0) return createBuffer(size);
282		if (fill !== void 0) return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
283		return createBuffer(size);
284	}
285	/**
286	* Creates a new filled Buffer instance.
287	* alloc(size[, fill[, encoding]])
288	**/
289	Buffer.alloc = function(size, fill, encoding) {
290		return alloc(size, fill, encoding);
291	};
292	function allocUnsafe(size) {
293		assertSize(size);
294		return createBuffer(size < 0 ? 0 : checked(size) | 0);
295	}
296	/**
297	* Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
298	* */
299	Buffer.allocUnsafe = function(size) {
300		return allocUnsafe(size);
301	};
302	/**
303	* Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
304	*/
305	Buffer.allocUnsafeSlow = function(size) {
306		return allocUnsafe(size);
307	};
308	function fromString(string, encoding) {
309		if (typeof encoding !== "string" || encoding === "") encoding = "utf8";
310		if (!Buffer.isEncoding(encoding)) throw new TypeError("Unknown encoding: " + encoding);
311		const length = byteLength(string, encoding) | 0;
312		let buf = createBuffer(length);
313		const actual = buf.write(string, encoding);
314		if (actual !== length) buf = buf.slice(0, actual);
315		return buf;
316	}
317	function fromArrayLike(array) {
318		const length = array.length < 0 ? 0 : checked(array.length) | 0;
319		const buf = createBuffer(length);
320		for (let i = 0; i < length; i += 1) buf[i] = array[i] & 255;
321		return buf;
322	}
323	function fromArrayView(arrayView) {
324		if (isInstance(arrayView, Uint8Array)) {
325			const copy = new Uint8Array(arrayView);
326			return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
327		}
328		return fromArrayLike(arrayView);
329	}
330	function fromArrayBuffer(array, byteOffset, length) {
331		if (byteOffset < 0 || array.byteLength < byteOffset) throw new RangeError("\"offset\" is outside of buffer bounds");
332		if (array.byteLength < byteOffset + (length || 0)) throw new RangeError("\"length\" is outside of buffer bounds");
333		let buf;
334		if (byteOffset === void 0 && length === void 0) buf = new Uint8Array(array);
335		else if (length === void 0) buf = new Uint8Array(array, byteOffset);
336		else buf = new Uint8Array(array, byteOffset, length);
337		Object.setPrototypeOf(buf, Buffer.prototype);
338		return buf;
339	}
340	function fromObject(obj) {
341		if (Buffer.isBuffer(obj)) {
342			const len = checked(obj.length) | 0;
343			const buf = createBuffer(len);
344			if (buf.length === 0) return buf;
345			obj.copy(buf, 0, 0, len);
346			return buf;
347		}
348		if (obj.length !== void 0) {
349			if (typeof obj.length !== "number" || numberIsNaN(obj.length)) return createBuffer(0);
350			return fromArrayLike(obj);
351		}
352		if (obj.type === "Buffer" && Array.isArray(obj.data)) return fromArrayLike(obj.data);
353	}
354	function checked(length) {
355		if (length >= K_MAX_LENGTH) throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
356		return length | 0;
357	}
358	function SlowBuffer(length) {
359		if (+length != length) length = 0;
360		return Buffer.alloc(+length);
361	}
362	Buffer.isBuffer = function isBuffer(b) {
363		return b != null && b._isBuffer === true && b !== Buffer.prototype;
364	};
365	Buffer.compare = function compare(a, b) {
366		if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength);
367		if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength);
368		if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) throw new TypeError("The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array");
369		if (a === b) return 0;
370		let x = a.length;
371		let y = b.length;
372		for (let i = 0, len = Math.min(x, y); i < len; ++i) if (a[i] !== b[i]) {
373			x = a[i];
374			y = b[i];
375			break;
376		}
377		if (x < y) return -1;
378		if (y < x) return 1;
379		return 0;
380	};
381	Buffer.isEncoding = function isEncoding(encoding) {
382		switch (String(encoding).toLowerCase()) {
383			case "hex":
384			case "utf8":
385			case "utf-8":
386			case "ascii":
387			case "latin1":
388			case "binary":
389			case "base64":
390			case "ucs2":
391			case "ucs-2":
392			case "utf16le":
393			case "utf-16le": return true;
394			default: return false;
395		}
396	};
397	Buffer.concat = function concat(list, length) {
398		if (!Array.isArray(list)) throw new TypeError("\"list\" argument must be an Array of Buffers");
399		if (list.length === 0) return Buffer.alloc(0);
400		let i;
401		if (length === void 0) {
402			length = 0;
403			for (i = 0; i < list.length; ++i) length += list[i].length;
404		}
405		const buffer = Buffer.allocUnsafe(length);
406		let pos = 0;
407		for (i = 0; i < list.length; ++i) {
408			let buf = list[i];
409			if (isInstance(buf, Uint8Array)) if (pos + buf.length > buffer.length) {
410				if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf);
411				buf.copy(buffer, pos);
412			} else Uint8Array.prototype.set.call(buffer, buf, pos);
413			else if (!Buffer.isBuffer(buf)) throw new TypeError("\"list\" argument must be an Array of Buffers");
414			else buf.copy(buffer, pos);
415			pos += buf.length;
416		}
417		return buffer;
418	};
419	function byteLength(string, encoding) {
420		if (Buffer.isBuffer(string)) return string.length;
421		if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) return string.byteLength;
422		if (typeof string !== "string") throw new TypeError("The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. Received type " + typeof string);
423		const len = string.length;
424		const mustMatch = arguments.length > 2 && arguments[2] === true;
425		if (!mustMatch && len === 0) return 0;
426		let loweredCase = false;
427		for (;;) switch (encoding) {
428			case "ascii":
429			case "latin1":
430			case "binary": return len;
431			case "utf8":
432			case "utf-8": return utf8ToBytes(string).length;
433			case "ucs2":
434			case "ucs-2":
435			case "utf16le":
436			case "utf-16le": return len * 2;
437			case "hex": return len >>> 1;
438			case "base64": return base64ToBytes(string).length;
439			default:
440				if (loweredCase) return mustMatch ? -1 : utf8ToBytes(string).length;
441				encoding = ("" + encoding).toLowerCase();
442				loweredCase = true;
443		}
444	}
445	Buffer.byteLength = byteLength;
446	function slowToString(encoding, start, end) {
447		let loweredCase = false;
448		if (start === void 0 || start < 0) start = 0;
449		if (start > this.length) return "";
450		if (end === void 0 || end > this.length) end = this.length;
451		if (end <= 0) return "";
452		end >>>= 0;
453		start >>>= 0;
454		if (end <= start) return "";
455		if (!encoding) encoding = "utf8";
456		while (true) switch (encoding) {
457			case "hex": return hexSlice(this, start, end);
458			case "utf8":
459			case "utf-8": return utf8Slice(this, start, end);
460			case "ascii": return asciiSlice(this, start, end);
461			case "latin1":
462			case "binary": return latin1Slice(this, start, end);
463			case "base64": return base64Slice(this, start, end);
464			case "ucs2":
465			case "ucs-2":
466			case "utf16le":
467			case "utf-16le": return utf16leSlice(this, start, end);
468			default:
469				if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
470				encoding = (encoding + "").toLowerCase();
471				loweredCase = true;
472		}
473	}
474	Buffer.prototype._isBuffer = true;
475	function swap(b, n, m) {
476		const i = b[n];
477		b[n] = b[m];
478		b[m] = i;
479	}
480	Buffer.prototype.swap16 = function swap16() {
481		const len = this.length;
482		if (len % 2 !== 0) throw new RangeError("Buffer size must be a multiple of 16-bits");
483		for (let i = 0; i < len; i += 2) swap(this, i, i + 1);
484		return this;
485	};
486	Buffer.prototype.swap32 = function swap32() {
487		const len = this.length;
488		if (len % 4 !== 0) throw new RangeError("Buffer size must be a multiple of 32-bits");
489		for (let i = 0; i < len; i += 4) {
490			swap(this, i, i + 3);
491			swap(this, i + 1, i + 2);
492		}
493		return this;
494	};
495	Buffer.prototype.swap64 = function swap64() {
496		const len = this.length;
497		if (len % 8 !== 0) throw new RangeError("Buffer size must be a multiple of 64-bits");
498		for (let i = 0; i < len; i += 8) {
499			swap(this, i, i + 7);
500			swap(this, i + 1, i + 6);
501			swap(this, i + 2, i + 5);
502			swap(this, i + 3, i + 4);
503		}
504		return this;
505	};
506	Buffer.prototype.toString = function toString() {
507		const length = this.length;
508		if (length === 0) return "";
509		if (arguments.length === 0) return utf8Slice(this, 0, length);
510		return slowToString.apply(this, arguments);
511	};
512	Buffer.prototype.toLocaleString = Buffer.prototype.toString;
513	Buffer.prototype.equals = function equals(b) {
514		if (!Buffer.isBuffer(b)) throw new TypeError("Argument must be a Buffer");
515		if (this === b) return true;
516		return Buffer.compare(this, b) === 0;
517	};
518	Buffer.prototype.inspect = function inspect() {
519		let str = "";
520		const max = exports.INSPECT_MAX_BYTES;
521		str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
522		if (this.length > max) str += " ... ";
523		return "<Buffer " + str + ">";
524	};
525	if (customInspectSymbol) Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect;
526	Buffer.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
527		if (isInstance(target, Uint8Array)) target = Buffer.from(target, target.offset, target.byteLength);
528		if (!Buffer.isBuffer(target)) throw new TypeError("The \"target\" argument must be one of type Buffer or Uint8Array. Received type " + typeof target);
529		if (start === void 0) start = 0;
530		if (end === void 0) end = target ? target.length : 0;
531		if (thisStart === void 0) thisStart = 0;
532		if (thisEnd === void 0) thisEnd = this.length;
533		if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) throw new RangeError("out of range index");
534		if (thisStart >= thisEnd && start >= end) return 0;
535		if (thisStart >= thisEnd) return -1;
536		if (start >= end) return 1;
537		start >>>= 0;
538		end >>>= 0;
539		thisStart >>>= 0;
540		thisEnd >>>= 0;
541		if (this === target) return 0;
542		let x = thisEnd - thisStart;
543		let y = end - start;
544		const len = Math.min(x, y);
545		const thisCopy = this.slice(thisStart, thisEnd);
546		const targetCopy = target.slice(start, end);
547		for (let i = 0; i < len; ++i) if (thisCopy[i] !== targetCopy[i]) {
548			x = thisCopy[i];
549			y = targetCopy[i];
550			break;
551		}
552		if (x < y) return -1;
553		if (y < x) return 1;
554		return 0;
555	};
556	function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
557		if (buffer.length === 0) return -1;
558		if (typeof byteOffset === "string") {
559			encoding = byteOffset;
560			byteOffset = 0;
561		} else if (byteOffset > 2147483647) byteOffset = 2147483647;
562		else if (byteOffset < -2147483648) byteOffset = -2147483648;
563		byteOffset = +byteOffset;
564		if (numberIsNaN(byteOffset)) byteOffset = dir ? 0 : buffer.length - 1;
565		if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
566		if (byteOffset >= buffer.length) if (dir) return -1;
567		else byteOffset = buffer.length - 1;
568		else if (byteOffset < 0) if (dir) byteOffset = 0;
569		else return -1;
570		if (typeof val === "string") val = Buffer.from(val, encoding);
571		if (Buffer.isBuffer(val)) {
572			if (val.length === 0) return -1;
573			return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
574		} else if (typeof val === "number") {
575			val = val & 255;
576			if (typeof Uint8Array.prototype.indexOf === "function") if (dir) return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
577			else return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
578			return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
579		}
580		throw new TypeError("val must be string, number or Buffer");
581	}
582	function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
583		let indexSize = 1;
584		let arrLength = arr.length;
585		let valLength = val.length;
586		if (encoding !== void 0) {
587			encoding = String(encoding).toLowerCase();
588			if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
589				if (arr.length < 2 || val.length < 2) return -1;
590				indexSize = 2;
591				arrLength /= 2;
592				valLength /= 2;
593				byteOffset /= 2;
594			}
595		}
596		function read(buf, i) {
597			if (indexSize === 1) return buf[i];
598			else return buf.readUInt16BE(i * indexSize);
599		}
600		let i;
601		if (dir) {
602			let foundIndex = -1;
603			for (i = byteOffset; i < arrLength; i++) if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
604				if (foundIndex === -1) foundIndex = i;
605				if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;
606			} else {
607				if (foundIndex !== -1) i -= i - foundIndex;
608				foundIndex = -1;
609			}
610		} else {
611			if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
612			for (i = byteOffset; i >= 0; i--) {
613				let found = true;
614				for (let j = 0; j < valLength; j++) if (read(arr, i + j) !== read(val, j)) {
615					found = false;
616					break;
617				}
618				if (found) return i;
619			}
620		}
621		return -1;
622	}
623	Buffer.prototype.includes = function includes(val, byteOffset, encoding) {
624		return this.indexOf(val, byteOffset, encoding) !== -1;
625	};
626	Buffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
627		return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
628	};
629	Buffer.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
630		return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
631	};
632	function hexWrite(buf, string, offset, length) {
633		offset = Number(offset) || 0;
634		const remaining = buf.length - offset;
635		if (!length) length = remaining;
636		else {
637			length = Number(length);
638			if (length > remaining) length = remaining;
639		}
640		const strLen = string.length;
641		if (length > strLen / 2) length = strLen / 2;
642		let i;
643		for (i = 0; i < length; ++i) {
644			const parsed = parseInt(string.substr(i * 2, 2), 16);
645			if (numberIsNaN(parsed)) return i;
646			buf[offset + i] = parsed;
647		}
648		return i;
649	}
650	function utf8Write(buf, string, offset, length) {
651		return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
652	}
653	function asciiWrite(buf, string, offset, length) {
654		return blitBuffer(asciiToBytes(string), buf, offset, length);
655	}
656	function base64Write(buf, string, offset, length) {
657		return blitBuffer(base64ToBytes(string), buf, offset, length);
658	}
659	function ucs2Write(buf, string, offset, length) {
660		return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
661	}
662	Buffer.prototype.write = function write(string, offset, length, encoding) {
663		if (offset === void 0) {
664			encoding = "utf8";
665			length = this.length;
666			offset = 0;
667		} else if (length === void 0 && typeof offset === "string") {
668			encoding = offset;
669			length = this.length;
670			offset = 0;
671		} else if (isFinite(offset)) {
672			offset = offset >>> 0;
673			if (isFinite(length)) {
674				length = length >>> 0;
675				if (encoding === void 0) encoding = "utf8";
676			} else {
677				encoding = length;
678				length = void 0;
679			}
680		} else throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
681		const remaining = this.length - offset;
682		if (length === void 0 || length > remaining) length = remaining;
683		if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) throw new RangeError("Attempt to write outside buffer bounds");
684		if (!encoding) encoding = "utf8";
685		let loweredCase = false;
686		for (;;) switch (encoding) {
687			case "hex": return hexWrite(this, string, offset, length);
688			case "utf8":
689			case "utf-8": return utf8Write(this, string, offset, length);
690			case "ascii":
691			case "latin1":
692			case "binary": return asciiWrite(this, string, offset, length);
693			case "base64": return base64Write(this, string, offset, length);
694			case "ucs2":
695			case "ucs-2":
696			case "utf16le":
697			case "utf-16le": return ucs2Write(this, string, offset, length);
698			default:
699				if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
700				encoding = ("" + encoding).toLowerCase();
701				loweredCase = true;
702		}
703	};
704	Buffer.prototype.toJSON = function toJSON() {
705		return {
706			type: "Buffer",
707			data: Array.prototype.slice.call(this._arr || this, 0)
708		};
709	};
710	function base64Slice(buf, start, end) {
711		if (start === 0 && end === buf.length) return base64.fromByteArray(buf);
712		else return base64.fromByteArray(buf.slice(start, end));
713	}
714	function utf8Slice(buf, start, end) {
715		end = Math.min(buf.length, end);
716		const res = [];
717		let i = start;
718		while (i < end) {
719			const firstByte = buf[i];
720			let codePoint = null;
721			let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
722			if (i + bytesPerSequence <= end) {
723				let secondByte, thirdByte, fourthByte, tempCodePoint;
724				switch (bytesPerSequence) {
725					case 1:
726						if (firstByte < 128) codePoint = firstByte;
727						break;
728					case 2:
729						secondByte = buf[i + 1];
730						if ((secondByte & 192) === 128) {
731							tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
732							if (tempCodePoint > 127) codePoint = tempCodePoint;
733						}
734						break;
735					case 3:
736						secondByte = buf[i + 1];
737						thirdByte = buf[i + 2];
738						if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
739							tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
740							if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) codePoint = tempCodePoint;
741						}
742						break;
743					case 4:
744						secondByte = buf[i + 1];
745						thirdByte = buf[i + 2];
746						fourthByte = buf[i + 3];
747						if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
748							tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
749							if (tempCodePoint > 65535 && tempCodePoint < 1114112) codePoint = tempCodePoint;
750						}
751				}
752			}
753			if (codePoint === null) {
754				codePoint = 65533;
755				bytesPerSequence = 1;
756			} else if (codePoint > 65535) {
757				codePoint -= 65536;
758				res.push(codePoint >>> 10 & 1023 | 55296);
759				codePoint = 56320 | codePoint & 1023;
760			}
761			res.push(codePoint);
762			i += bytesPerSequence;
763		}
764		return decodeCodePointsArray(res);
765	}
766	var MAX_ARGUMENTS_LENGTH = 4096;
767	function decodeCodePointsArray(codePoints) {
768		const len = codePoints.length;
769		if (len <= MAX_ARGUMENTS_LENGTH) return String.fromCharCode.apply(String, codePoints);
770		let res = "";
771		let i = 0;
772		while (i < len) res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
773		return res;
774	}
775	function asciiSlice(buf, start, end) {
776		let ret = "";
777		end = Math.min(buf.length, end);
778		for (let i = start; i < end; ++i) ret += String.fromCharCode(buf[i] & 127);
779		return ret;
780	}
781	function latin1Slice(buf, start, end) {
782		let ret = "";
783		end = Math.min(buf.length, end);
784		for (let i = start; i < end; ++i) ret += String.fromCharCode(buf[i]);
785		return ret;
786	}
787	function hexSlice(buf, start, end) {
788		const len = buf.length;
789		if (!start || start < 0) start = 0;
790		if (!end || end < 0 || end > len) end = len;
791		let out = "";
792		for (let i = start; i < end; ++i) out += hexSliceLookupTable[buf[i]];
793		return out;
794	}
795	function utf16leSlice(buf, start, end) {
796		const bytes = buf.slice(start, end);
797		let res = "";
798		for (let i = 0; i < bytes.length - 1; i += 2) res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
799		return res;
800	}
801	Buffer.prototype.slice = function slice(start, end) {
802		const len = this.length;
803		start = ~~start;
804		end = end === void 0 ? len : ~~end;
805		if (start < 0) {
806			start += len;
807			if (start < 0) start = 0;
808		} else if (start > len) start = len;
809		if (end < 0) {
810			end += len;
811			if (end < 0) end = 0;
812		} else if (end > len) end = len;
813		if (end < start) end = start;
814		const newBuf = this.subarray(start, end);
815		Object.setPrototypeOf(newBuf, Buffer.prototype);
816		return newBuf;
817	};
818	function checkOffset(offset, ext, length) {
819		if (offset % 1 !== 0 || offset < 0) throw new RangeError("offset is not uint");
820		if (offset + ext > length) throw new RangeError("Trying to access beyond buffer length");
821	}
822	Buffer.prototype.readUintLE = Buffer.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {
823		offset = offset >>> 0;
824		byteLength = byteLength >>> 0;
825		if (!noAssert) checkOffset(offset, byteLength, this.length);
826		let val = this[offset];
827		let mul = 1;
828		let i = 0;
829		while (++i < byteLength && (mul *= 256)) val += this[offset + i] * mul;
830		return val;
831	};
832	Buffer.prototype.readUintBE = Buffer.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) {
833		offset = offset >>> 0;
834		byteLength = byteLength >>> 0;
835		if (!noAssert) checkOffset(offset, byteLength, this.length);
836		let val = this[offset + --byteLength];
837		let mul = 1;
838		while (byteLength > 0 && (mul *= 256)) val += this[offset + --byteLength] * mul;
839		return val;
840	};
841	Buffer.prototype.readUint8 = Buffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {
842		offset = offset >>> 0;
843		if (!noAssert) checkOffset(offset, 1, this.length);
844		return this[offset];
845	};
846	Buffer.prototype.readUint16LE = Buffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
847		offset = offset >>> 0;
848		if (!noAssert) checkOffset(offset, 2, this.length);
849		return this[offset] | this[offset + 1] << 8;
850	};
851	Buffer.prototype.readUint16BE = Buffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
852		offset = offset >>> 0;
853		if (!noAssert) checkOffset(offset, 2, this.length);
854		return this[offset] << 8 | this[offset + 1];
855	};
856	Buffer.prototype.readUint32LE = Buffer.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
857		offset = offset >>> 0;
858		if (!noAssert) checkOffset(offset, 4, this.length);
859		return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
860	};
861	Buffer.prototype.readUint32BE = Buffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
862		offset = offset >>> 0;
863		if (!noAssert) checkOffset(offset, 4, this.length);
864		return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
865	};
866	Buffer.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) {
867		offset = offset >>> 0;
868		validateNumber(offset, "offset");
869		const first = this[offset];
870		const last = this[offset + 7];
871		if (first === void 0 || last === void 0) boundsError(offset, this.length - 8);
872		const lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24;
873		const hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24;
874		return BigInt(lo) + (BigInt(hi) << BigInt(32));
875	});
876	Buffer.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) {
877		offset = offset >>> 0;
878		validateNumber(offset, "offset");
879		const first = this[offset];
880		const last = this[offset + 7];
881		if (first === void 0 || last === void 0) boundsError(offset, this.length - 8);
882		const hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
883		const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last;
884		return (BigInt(hi) << BigInt(32)) + BigInt(lo);
885	});
886	Buffer.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {
887		offset = offset >>> 0;
888		byteLength = byteLength >>> 0;
889		if (!noAssert) checkOffset(offset, byteLength, this.length);
890		let val = this[offset];
891		let mul = 1;
892		let i = 0;
893		while (++i < byteLength && (mul *= 256)) val += this[offset + i] * mul;
894		mul *= 128;
895		if (val >= mul) val -= Math.pow(2, 8 * byteLength);
896		return val;
897	};
898	Buffer.prototype.readIntBE = function readIntBE(offset, byteLength, noAssert) {
899		offset = offset >>> 0;
900		byteLength = byteLength >>> 0;
901		if (!noAssert) checkOffset(offset, byteLength, this.length);
902		let i = byteLength;
903		let mul = 1;
904		let val = this[offset + --i];
905		while (i > 0 && (mul *= 256)) val += this[offset + --i] * mul;
906		mul *= 128;
907		if (val >= mul) val -= Math.pow(2, 8 * byteLength);
908		return val;
909	};
910	Buffer.prototype.readInt8 = function readInt8(offset, noAssert) {
911		offset = offset >>> 0;
912		if (!noAssert) checkOffset(offset, 1, this.length);
913		if (!(this[offset] & 128)) return this[offset];
914		return (255 - this[offset] + 1) * -1;
915	};
916	Buffer.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
917		offset = offset >>> 0;
918		if (!noAssert) checkOffset(offset, 2, this.length);
919		const val = this[offset] | this[offset + 1] << 8;
920		return val & 32768 ? val | 4294901760 : val;
921	};
922	Buffer.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
923		offset = offset >>> 0;
924		if (!noAssert) checkOffset(offset, 2, this.length);
925		const val = this[offset + 1] | this[offset] << 8;
926		return val & 32768 ? val | 4294901760 : val;
927	};
928	Buffer.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
929		offset = offset >>> 0;
930		if (!noAssert) checkOffset(offset, 4, this.length);
931		return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
932	};
933	Buffer.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
934		offset = offset >>> 0;
935		if (!noAssert) checkOffset(offset, 4, this.length);
936		return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
937	};
938	Buffer.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) {
939		offset = offset >>> 0;
940		validateNumber(offset, "offset");
941		const first = this[offset];
942		const last = this[offset + 7];
943		if (first === void 0 || last === void 0) boundsError(offset, this.length - 8);
944		const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last << 24);
945		return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24);
946	});
947	Buffer.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) {
948		offset = offset >>> 0;
949		validateNumber(offset, "offset");
950		const first = this[offset];
951		const last = this[offset + 7];
952		if (first === void 0 || last === void 0) boundsError(offset, this.length - 8);
953		const val = (first << 24) + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
954		return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last);
955	});
956	Buffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
957		offset = offset >>> 0;
958		if (!noAssert) checkOffset(offset, 4, this.length);
959		return ieee754.read(this, offset, true, 23, 4);
960	};
961	Buffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
962		offset = offset >>> 0;
963		if (!noAssert) checkOffset(offset, 4, this.length);
964		return ieee754.read(this, offset, false, 23, 4);
965	};
966	Buffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
967		offset = offset >>> 0;
968		if (!noAssert) checkOffset(offset, 8, this.length);
969		return ieee754.read(this, offset, true, 52, 8);
970	};
971	Buffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
972		offset = offset >>> 0;
973		if (!noAssert) checkOffset(offset, 8, this.length);
974		return ieee754.read(this, offset, false, 52, 8);
975	};
976	function checkInt(buf, value, offset, ext, max, min) {
977		if (!Buffer.isBuffer(buf)) throw new TypeError("\"buffer\" argument must be a Buffer instance");
978		if (value > max || value < min) throw new RangeError("\"value\" argument is out of bounds");
979		if (offset + ext > buf.length) throw new RangeError("Index out of range");
980	}
981	Buffer.prototype.writeUintLE = Buffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {
982		value = +value;
983		offset = offset >>> 0;
984		byteLength = byteLength >>> 0;
985		if (!noAssert) {
986			const maxBytes = Math.pow(2, 8 * byteLength) - 1;
987			checkInt(this, value, offset, byteLength, maxBytes, 0);
988		}
989		let mul = 1;
990		let i = 0;
991		this[offset] = value & 255;
992		while (++i < byteLength && (mul *= 256)) this[offset + i] = value / mul & 255;
993		return offset + byteLength;
994	};
995	Buffer.prototype.writeUintBE = Buffer.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) {
996		value = +value;
997		offset = offset >>> 0;
998		byteLength = byteLength >>> 0;
999		if (!noAssert) {
1000			const maxBytes = Math.pow(2, 8 * byteLength) - 1;
1001			checkInt(this, value, offset, byteLength, maxBytes, 0);
1002		}
1003		let i = byteLength - 1;
1004		let mul = 1;
1005		this[offset + i] = value & 255;
1006		while (--i >= 0 && (mul *= 256)) this[offset + i] = value / mul & 255;
1007		return offset + byteLength;
1008	};
1009	Buffer.prototype.writeUint8 = Buffer.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
1010		value = +value;
1011		offset = offset >>> 0;
1012		if (!noAssert) checkInt(this, value, offset, 1, 255, 0);
1013		this[offset] = value & 255;
1014		return offset + 1;
1015	};
1016	Buffer.prototype.writeUint16LE = Buffer.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
1017		value = +value;
1018		offset = offset >>> 0;
1019		if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
1020		this[offset] = value & 255;
1021		this[offset + 1] = value >>> 8;
1022		return offset + 2;
1023	};
1024	Buffer.prototype.writeUint16BE = Buffer.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
1025		value = +value;
1026		offset = offset >>> 0;
1027		if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
1028		this[offset] = value >>> 8;
1029		this[offset + 1] = value & 255;
1030		return offset + 2;
1031	};
1032	Buffer.prototype.writeUint32LE = Buffer.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
1033		value = +value;
1034		offset = offset >>> 0;
1035		if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
1036		this[offset + 3] = value >>> 24;
1037		this[offset + 2] = value >>> 16;
1038		this[offset + 1] = value >>> 8;
1039		this[offset] = value & 255;
1040		return offset + 4;
1041	};
1042	Buffer.prototype.writeUint32BE = Buffer.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
1043		value = +value;
1044		offset = offset >>> 0;
1045		if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
1046		this[offset] = value >>> 24;
1047		this[offset + 1] = value >>> 16;
1048		this[offset + 2] = value >>> 8;
1049		this[offset + 3] = value & 255;
1050		return offset + 4;
1051	};
1052	function wrtBigUInt64LE(buf, value, offset, min, max) {
1053		checkIntBI(value, min, max, buf, offset, 7);
1054		let lo = Number(value & BigInt(4294967295));
1055		buf[offset++] = lo;
1056		lo = lo >> 8;
1057		buf[offset++] = lo;
1058		lo = lo >> 8;
1059		buf[offset++] = lo;
1060		lo = lo >> 8;
1061		buf[offset++] = lo;
1062		let hi = Number(value >> BigInt(32) & BigInt(4294967295));
1063		buf[offset++] = hi;
1064		hi = hi >> 8;
1065		buf[offset++] = hi;
1066		hi = hi >> 8;
1067		buf[offset++] = hi;
1068		hi = hi >> 8;
1069		buf[offset++] = hi;
1070		return offset;
1071	}
1072	function wrtBigUInt64BE(buf, value, offset, min, max) {
1073		checkIntBI(value, min, max, buf, offset, 7);
1074		let lo = Number(value & BigInt(4294967295));
1075		buf[offset + 7] = lo;
1076		lo = lo >> 8;
1077		buf[offset + 6] = lo;
1078		lo = lo >> 8;
1079		buf[offset + 5] = lo;
1080		lo = lo >> 8;
1081		buf[offset + 4] = lo;
1082		let hi = Number(value >> BigInt(32) & BigInt(4294967295));
1083		buf[offset + 3] = hi;
1084		hi = hi >> 8;
1085		buf[offset + 2] = hi;
1086		hi = hi >> 8;
1087		buf[offset + 1] = hi;
1088		hi = hi >> 8;
1089		buf[offset] = hi;
1090		return offset + 8;
1091	}
1092	Buffer.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
1093		return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
1094	});
1095	Buffer.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
1096		return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
1097	});
1098	Buffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {
1099		value = +value;
1100		offset = offset >>> 0;
1101		if (!noAssert) {
1102			const limit = Math.pow(2, 8 * byteLength - 1);
1103			checkInt(this, value, offset, byteLength, limit - 1, -limit);
1104		}
1105		let i = 0;
1106		let mul = 1;
1107		let sub = 0;
1108		this[offset] = value & 255;
1109		while (++i < byteLength && (mul *= 256)) {
1110			if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) sub = 1;
1111			this[offset + i] = (value / mul >> 0) - sub & 255;
1112		}
1113		return offset + byteLength;
1114	};
1115	Buffer.prototype.writeIntBE = function writeIntBE(value, offset, byteLength, noAssert) {
1116		value = +value;
1117		offset = offset >>> 0;
1118		if (!noAssert) {
1119			const limit = Math.pow(2, 8 * byteLength - 1);
1120			checkInt(this, value, offset, byteLength, limit - 1, -limit);
1121		}
1122		let i = byteLength - 1;
1123		let mul = 1;
1124		let sub = 0;
1125		this[offset + i] = value & 255;
1126		while (--i >= 0 && (mul *= 256)) {
1127			if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) sub = 1;
1128			this[offset + i] = (value / mul >> 0) - sub & 255;
1129		}
1130		return offset + byteLength;
1131	};
1132	Buffer.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
1133		value = +value;
1134		offset = offset >>> 0;
1135		if (!noAssert) checkInt(this, value, offset, 1, 127, -128);
1136		if (value < 0) value = 255 + value + 1;
1137		this[offset] = value & 255;
1138		return offset + 1;
1139	};
1140	Buffer.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
1141		value = +value;
1142		offset = offset >>> 0;
1143		if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
1144		this[offset] = value & 255;
1145		this[offset + 1] = value >>> 8;
1146		return offset + 2;
1147	};
1148	Buffer.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
1149		value = +value;
1150		offset = offset >>> 0;
1151		if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
1152		this[offset] = value >>> 8;
1153		this[offset + 1] = value & 255;
1154		return offset + 2;
1155	};
1156	Buffer.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
1157		value = +value;
1158		offset = offset >>> 0;
1159		if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
1160		this[offset] = value & 255;
1161		this[offset + 1] = value >>> 8;
1162		this[offset + 2] = value >>> 16;
1163		this[offset + 3] = value >>> 24;
1164		return offset + 4;
1165	};
1166	Buffer.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
1167		value = +value;
1168		offset = offset >>> 0;
1169		if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
1170		if (value < 0) value = 4294967295 + value + 1;
1171		this[offset] = value >>> 24;
1172		this[offset + 1] = value >>> 16;
1173		this[offset + 2] = value >>> 8;
1174		this[offset + 3] = value & 255;
1175		return offset + 4;
1176	};
1177	Buffer.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
1178		return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
1179	});
1180	Buffer.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) {
1181		return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
1182	});
1183	function checkIEEE754(buf, value, offset, ext, max, min) {
1184		if (offset + ext > buf.length) throw new RangeError("Index out of range");
1185		if (offset < 0) throw new RangeError("Index out of range");
1186	}
1187	function writeFloat(buf, value, offset, littleEndian, noAssert) {
1188		value = +value;
1189		offset = offset >>> 0;
1190		if (!noAssert) checkIEEE754(buf, value, offset, 4, 34028234663852886e22, -34028234663852886e22);
1191		ieee754.write(buf, value, offset, littleEndian, 23, 4);
1192		return offset + 4;
1193	}
1194	Buffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
1195		return writeFloat(this, value, offset, true, noAssert);
1196	};
1197	Buffer.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
1198		return writeFloat(this, value, offset, false, noAssert);
1199	};
1200	function writeDouble(buf, value, offset, littleEndian, noAssert) {
1201		value = +value;
1202		offset = offset >>> 0;
1203		if (!noAssert) checkIEEE754(buf, value, offset, 8, 17976931348623157e292, -17976931348623157e292);
1204		ieee754.write(buf, value, offset, littleEndian, 52, 8);
1205		return offset + 8;
1206	}
1207	Buffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
1208		return writeDouble(this, value, offset, true, noAssert);
1209	};
1210	Buffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
1211		return writeDouble(this, value, offset, false, noAssert);
1212	};
1213	Buffer.prototype.copy = function copy(target, targetStart, start, end) {
1214		if (!Buffer.isBuffer(target)) throw new TypeError("argument should be a Buffer");
1215		if (!start) start = 0;
1216		if (!end && end !== 0) end = this.length;
1217		if (targetStart >= target.length) targetStart = target.length;
1218		if (!targetStart) targetStart = 0;
1219		if (end > 0 && end < start) end = start;
1220		if (end === start) return 0;
1221		if (target.length === 0 || this.length === 0) return 0;
1222		if (targetStart < 0) throw new RangeError("targetStart out of bounds");
1223		if (start < 0 || start >= this.length) throw new RangeError("Index out of range");
1224		if (end < 0) throw new RangeError("sourceEnd out of bounds");
1225		if (end > this.length) end = this.length;
1226		if (target.length - targetStart < end - start) end = target.length - targetStart + start;
1227		const len = end - start;
1228		if (this === target && typeof Uint8Array.prototype.copyWithin === "function") this.copyWithin(targetStart, start, end);
1229		else Uint8Array.prototype.set.call(target, this.subarray(start, end), targetStart);
1230		return len;
1231	};
1232	Buffer.prototype.fill = function fill(val, start, end, encoding) {
1233		if (typeof val === "string") {
1234			if (typeof start === "string") {
1235				encoding = start;
1236				start = 0;
1237				end = this.length;
1238			} else if (typeof end === "string") {
1239				encoding = end;
1240				end = this.length;
1241			}
1242			if (encoding !== void 0 && typeof encoding !== "string") throw new TypeError("encoding must be a string");
1243			if (typeof encoding === "string" && !Buffer.isEncoding(encoding)) throw new TypeError("Unknown encoding: " + encoding);
1244			if (val.length === 1) {
1245				const code = val.charCodeAt(0);
1246				if (encoding === "utf8" && code < 128 || encoding === "latin1") val = code;
1247			}
1248		} else if (typeof val === "number") val = val & 255;
1249		else if (typeof val === "boolean") val = Number(val);
1250		if (start < 0 || this.length < start || this.length < end) throw new RangeError("Out of range index");
1251		if (end <= start) return this;
1252		start = start >>> 0;
1253		end = end === void 0 ? this.length : end >>> 0;
1254		if (!val) val = 0;
1255		let i;
1256		if (typeof val === "number") for (i = start; i < end; ++i) this[i] = val;
1257		else {
1258			const bytes = Buffer.isBuffer(val) ? val : Buffer.from(val, encoding);
1259			const len = bytes.length;
1260			if (len === 0) throw new TypeError("The value \"" + val + "\" is invalid for argument \"value\"");
1261			for (i = 0; i < end - start; ++i) this[i + start] = bytes[i % len];
1262		}
1263		return this;
1264	};
1265	var errors = {};
1266	function E(sym, getMessage, Base) {
1267		errors[sym] = class NodeError extends Base {
1268			constructor() {
1269				super();
1270				Object.defineProperty(this, "message", {
1271					value: getMessage.apply(this, arguments),
1272					writable: true,
1273					configurable: true
1274				});
1275				this.name = `${this.name} [${sym}]`;
1276				this.stack;
1277				delete this.name;
1278			}
1279			get code() {
1280				return sym;
1281			}
1282			set code(value) {
1283				Object.defineProperty(this, "code", {
1284					configurable: true,
1285					enumerable: true,
1286					value,
1287					writable: true
1288				});
1289			}
1290			toString() {
1291				return `${this.name} [${sym}]: ${this.message}`;
1292			}
1293		};
1294	}
1295	E("ERR_BUFFER_OUT_OF_BOUNDS", function(name) {
1296		if (name) return `${name} is outside of buffer bounds`;
1297		return "Attempt to access memory outside buffer bounds";
1298	}, RangeError);
1299	E("ERR_INVALID_ARG_TYPE", function(name, actual) {
1300		return `The "${name}" argument must be of type number. Received type ${typeof actual}`;
1301	}, TypeError);
1302	E("ERR_OUT_OF_RANGE", function(str, range, input) {
1303		let msg = `The value of "${str}" is out of range.`;
1304		let received = input;
1305		if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) received = addNumericalSeparator(String(input));
1306		else if (typeof input === "bigint") {
1307			received = String(input);
1308			if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) received = addNumericalSeparator(received);
1309			received += "n";
1310		}
1311		msg += ` It must be ${range}. Received ${received}`;
1312		return msg;
1313	}, RangeError);
1314	function addNumericalSeparator(val) {
1315		let res = "";
1316		let i = val.length;
1317		const start = val[0] === "-" ? 1 : 0;
1318		for (; i >= start + 4; i -= 3) res = `_${val.slice(i - 3, i)}${res}`;
1319		return `${val.slice(0, i)}${res}`;
1320	}
1321	function checkBounds(buf, offset, byteLength) {
1322		validateNumber(offset, "offset");
1323		if (buf[offset] === void 0 || buf[offset + byteLength] === void 0) boundsError(offset, buf.length - (byteLength + 1));
1324	}
1325	function checkIntBI(value, min, max, buf, offset, byteLength) {
1326		if (value > max || value < min) {
1327			const n = typeof min === "bigint" ? "n" : "";
1328			let range;
1329			if (byteLength > 3) if (min === 0 || min === BigInt(0)) range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`;
1330			else range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength + 1) * 8 - 1}${n}`;
1331			else range = `>= ${min}${n} and <= ${max}${n}`;
1332			throw new errors.ERR_OUT_OF_RANGE("value", range, value);
1333		}
1334		checkBounds(buf, offset, byteLength);
1335	}
1336	function validateNumber(value, name) {
1337		if (typeof value !== "number") throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value);
1338	}
1339	function boundsError(value, length, type) {
1340		if (Math.floor(value) !== value) {
1341			validateNumber(value, type);
1342			throw new errors.ERR_OUT_OF_RANGE(type || "offset", "an integer", value);
1343		}
1344		if (length < 0) throw new errors.ERR_BUFFER_OUT_OF_BOUNDS();
1345		throw new errors.ERR_OUT_OF_RANGE(type || "offset", `>= ${type ? 1 : 0} and <= ${length}`, value);
1346	}
1347	var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
1348	function base64clean(str) {
1349		str = str.split("=")[0];
1350		str = str.trim().replace(INVALID_BASE64_RE, "");
1351		if (str.length < 2) return "";
1352		while (str.length % 4 !== 0) str = str + "=";
1353		return str;
1354	}
1355	function utf8ToBytes(string, units) {
1356		units = units || Infinity;
1357		let codePoint;
1358		const length = string.length;
1359		let leadSurrogate = null;
1360		const bytes = [];
1361		for (let i = 0; i < length; ++i) {
1362			codePoint = string.charCodeAt(i);
1363			if (codePoint > 55295 && codePoint < 57344) {
1364				if (!leadSurrogate) {
1365					if (codePoint > 56319) {
1366						if ((units -= 3) > -1) bytes.push(239, 191, 189);
1367						continue;
1368					} else if (i + 1 === length) {
1369						if ((units -= 3) > -1) bytes.push(239, 191, 189);
1370						continue;
1371					}
1372					leadSurrogate = codePoint;
1373					continue;
1374				}
1375				if (codePoint < 56320) {
1376					if ((units -= 3) > -1) bytes.push(239, 191, 189);
1377					leadSurrogate = codePoint;
1378					continue;
1379				}
1380				codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
1381			} else if (leadSurrogate) {
1382				if ((units -= 3) > -1) bytes.push(239, 191, 189);
1383			}
1384			leadSurrogate = null;
1385			if (codePoint < 128) {
1386				if ((units -= 1) < 0) break;
1387				bytes.push(codePoint);
1388			} else if (codePoint < 2048) {
1389				if ((units -= 2) < 0) break;
1390				bytes.push(codePoint >>

1889			else ownKeys(Object(source)).forEach(function(key) {
1890				Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
1891			});
1892		}
1893		return target;
1894	}
1895	function _defineProperty(obj, key, value) {
1896		if (key in obj) Object.defineProperty(obj, key, {
1897			value,
1898			enumerable: true,
1899			configurable: true,
1900			writable: true
1901		});
1902		else obj[key] = value;
1903		return obj;
1904	}
1905	function _classCallCheck(instance, Constructor) {
1906		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
1907	}
1908	function _defineProperties(target, props) {
1909		for (var i = 0; i < props.length; i++) {
1910			var descriptor = props[i];
1911			descriptor.enumerable = descriptor.enumerable || false;
1912			descriptor.configurable = true;
1913			if ("value" in descriptor) descriptor.writable = true;
1914			Object.defineProperty(target, descriptor.key, descriptor);
1915		}
1916	}
1917	function _createClass(Constructor, protoProps, staticProps) {
1918		if (protoProps) _defineProperties(Constructor.prototype, protoProps);
1919		if (staticProps) _defineProperties(Constructor, staticProps);
1920		return Constructor;
1921	}
1922	var Buffer = require_buffer$1().Buffer;
1923	var inspect = require___vite_browser_external().inspect;
1924	var custom = inspect && inspect.custom || "inspect";
1925	function copyBuffer(src, target, offset) {
1926		Buffer.prototype.copy.call(src, target, offset);
1927	}
1928	module.exports = /*#__PURE__*/ function() {
1929		function BufferList() {
1930			_classCallCheck(this, BufferList);
1931			this.head = null;
1932			this.tail = null;
1933			this.length = 0;
1934		}
1935		_createClass(BufferList, [
1936			{
1937				key: "push",
1938				value: function push(v) {
1939					var entry = {
1940						data: v,
1941						next: null
1942					};
1943					if (this.length > 0) this.tail.next = entry;
1944					else this.head = entry;
1945					this.tail = entry;
1946					++this.length;
1947				}
1948			},
1949			{
1950				key: "unshift",
1951				value: function unshift(v) {
1952					var entry = {
1953						data: v,
1954						next: this.head
1955					};
1956					if (this.length === 0) this.tail = entry;
1957					this.head = entry;
1958					++this.length;
1959				}
1960			},
1961			{
1962				key: "shift",
1963				value: function shift() {
1964					if (this.length === 0) return;
1965					var ret = this.head.data;
1966					if (this.length === 1) this.head = this.tail = null;
1967					else this.head = this.head.next;
1968					--this.length;
1969					return ret;
1970				}
1971			},
1972			{
1973				key: "clear",
1974				value: function clear() {
1975					this.head = this.tail = null;
1976					this.length = 0;
1977				}
1978			},
1979			{
1980				key: "join",
1981				value: function join(s) {
1982					if (this.length === 0) return "";
1983					var p = this.head;
1984					var ret = "" + p.data;
1985					while (p = p.next) ret += s + p.data;
1986					return ret;
1987				}
1988			},
1989			{
1990				key: "concat",
1991				value: function concat(n) {
1992					if (this.length === 0) return Buffer.alloc(0);
1993					var ret = Buffer.allocUnsafe(n >>> 0);
1994					var p = this.head;
1995					var i = 0;
1996					while (p) {
1997						copyBuffer(p.data, ret, i);
1998						i += p.data.length;
1999						p = p.next;
2000					}
2001					return ret;
2002				}
2003			},
2004			{
2005				key: "consume",
2006				value: function consume(n, hasStrings) {
2007					var ret;
2008					if (n < this.head.data.length) {
2009						ret = this.head.data.slice(0, n);
2010						this.head.data = this.head.data.slice(n);
2011					} else if (n === this.head.data.length) ret = this.shift();
2012					else ret = hasStrings ? this._getString(n) : this._getBuffer(n);
2013					return ret;
2014				}
2015			},
2016			{
2017				key: "first",
2018				value: function first() {
2019					return this.head.data;
2020				}
2021			},
2022			{
2023				key: "_getString",
2024				value: function _getString(n) {
2025					var p = this.head;
2026					var c = 1;
2027					var ret = p.data;
2028					n -= ret.length;
2029					while (p = p.next) {
2030						var str = p.data;
2031						var nb = n > str.length ? str.length : n;
2032						if (nb === str.length) ret += str;
2033						else ret += str.slice(0, n);
2034						n -= nb;
2035						if (n === 0) {
2036							if (nb === str.length) {
2037								++c;
2038								if (p.next) this.head = p.next;
2039								else this.head = this.tail = null;
2040							} else {
2041								this.head = p;
2042								p.data = str.slice(nb);
2043							}
2044							break;
2045						}
2046						++c;
2047					}
2048					this.length -= c;
2049					return ret;
2050				}
2051			},
2052			{
2053				key: "_getBuffer",
2054				value: function _getBuffer(n) {
2055					var ret = Buffer.allocUnsafe(n);
2056					var p = this.head;
2057					var c = 1;
2058					p.data.copy(ret);
2059					n -= p.data.length;
2060					while (p = p.next) {
2061						var buf = p.data;
2062						var nb = n > buf.length ? buf.length : n;
2063						buf.copy(ret, ret.length - n, 0, nb);
2064						n -= nb;
2065						if (n === 0) {
2066							if (nb === buf.length) {
2067								++c;
2068								if (p.next) this.head = p.next;
2069								else this.head = this.tail = null;
2070							} else {
2071								this.head = p;
2072								p.data = buf.slice(nb);
2073							}
2074							break;
2075						}
2076						++c;
2077					}
2078					this.length -= c;
2079					return ret;
2080				}
2081			},
2082			{
2083				key: custom,
2084				value: function value(_, options) {
2085					return inspect(this, _objectSpread({}, options, {
2086						depth: 0,
2087						customInspect: false
2088					}));
2089				}
2090			}
2091		]);
2092		return BufferList;
2093	}();
2094}));
2095//#endregion
2096//#region node_modules/hash-base/node_modules/readable-stream/lib/internal/streams/destroy.js
2097var require_destroy$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2098	var process = require_browser$15();
2099	function destroy(err, cb) {
2100		var _this = this;
2101		var readableDestroyed = this._readableState && this._readableState.destroyed;
2102		var writableDestroyed = this._writableState && this._writableState.destroyed;
2103		if (readableDestroyed || writableDestroyed) {
2104			if (cb) cb(err);
2105			else if (err) {
2106				if (!this._writableState) process.nextTick(emitErrorNT, this, err);
2107				else if (!this._writableState.errorEmitted) {
2108					this._writableState.errorEmitted = true;
2109					process.nextTick(emitErrorNT, this, err);
2110				}
2111			}
2112			return this;
2113		}
2114		if (this._readableState) this._readableState.destroyed = true;
2115		if (this._writableState) this._writableState.destroyed = true;
2116		this._destroy(err || null, function(err) {
2117			if (!cb && err) if (!_this._writableState) process.nextTick(emitErrorAndCloseNT, _this, err);
2118			else if (!_this._writableState.errorEmitted) {
2119				_this._writableState.errorEmitted = true;
2120				process.nextTick(emitErrorAndCloseNT, _this, err);
2121			} else process.nextTick(emitCloseNT, _this);
2122			else if (cb) {
2123				process.nextTick(emitCloseNT, _this);
2124				cb(err);
2125			} else process.nextTick(emitCloseNT, _this);
2126		});
2127		return this;
2128	}
2129	function emitErrorAndCloseNT(self, err) {
2130		emitErrorNT(self, err);
2131		emitCloseNT(self);
2132	}
2133	function emitCloseNT(self) {
2134		if (self._writableState && !self._writableState.emitClose) return;
2135		if (self._readableState && !self._readableState.emitClose) return;
2136		self.emit("close");
2137	}
2138	function undestroy() {
2139		if (this._readableState) {
2140			this._readableState.destroyed = false;
2141			this._readableState.reading = false;
2142			this._readableState.ended = false;
2143			this._readableState.endEmitted = false;
2144		}
2145		if (this._writableState) {
2146			this._writableState.destroyed = false;
2147			this._writableState.ended = false;
2148			this._writableState.ending = false;
2149			this._writableState.finalCalled = false;
2150			this._writableState.prefinished = false;
2151			this._writableState.finished = false;
2152			this._writableState.errorEmitted = false;
2153		}
2154	}
2155	function emitErrorNT(self, err) {
2156		self.emit("error", err);
2157	}
2158	function errorOrDestroy(stream, err) {
2159		var rState = stream._readableState;
2160		var wState = stream._writableState;
2161		if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);
2162		else stream.emit("error", err);
2163	}
2164	module.exports = {
2165		destroy,
2166		undestroy,
2167		errorOrDestroy
2168	};
2169}));
2170//#endregion
2171//#region node_modules/hash-base/node_modules/readable-stream/errors-browser.js
2172var require_errors_browser$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2173	function _inheritsLoose(subClass, superClass) {
2174		subClass.prototype = Object.create(superClass.prototype);
2175		subClass.prototype.constructor = subClass;
2176		subClass.__proto__ = superClass;
2177	}
2178	var codes = {};
2179	function createErrorType(code, message, Base) {
2180		if (!Base) Base = Error;
2181		function getMessage(arg1, arg2, arg3) {
2182			if (typeof message === "string") return message;
2183			else return message(arg1, arg2, arg3);
2184		}
2185		var NodeError = /*#__PURE__*/ function(_Base) {
2186			_inheritsLoose(NodeError, _Base);
2187			function NodeError(arg1, arg2, arg3) {
2188				return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;
2189			}
2190			return NodeError;
2191		}(Base);
2192		NodeError.prototype.name = Base.name;
2193		NodeError.prototype.code = code;
2194		codes[code] = NodeError;
2195	}
2196	function oneOf(expected, thing) {
2197		if (Array.isArray(expected)) {
2198			var len = expected.length;
2199			expected = expected.map(function(i) {
2200				return String(i);
2201			});
2202			if (len > 2) return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(", "), ", or ") + expected[len - 1];
2203			else if (len === 2) return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]);
2204			else return "of ".concat(thing, " ").concat(expected[0]);
2205		} else return "of ".concat(thing, " ").concat(String(expected));
2206	}
2207	function startsWith(str, search, pos) {
2208		return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
2209	}
2210	function endsWith(str, search, this_len) {
2211		if (this_len === void 0 || this_len > str.length) this_len = str.length;
2212		return str.substring(this_len - search.length, this_len) === search;
2213	}
2214	function includes(str, search, start) {
2215		if (typeof start !== "number") start = 0;
2216		if (start + search.length > str.length) return false;
2217		else return str.indexOf(search, start) !== -1;
2218	}
2219	createErrorType("ERR_INVALID_OPT_VALUE", function(name, value) {
2220		return "The value \"" + value + "\" is invalid for option \"" + name + "\"";
2221	}, TypeError);
2222	createErrorType("ERR_INVALID_ARG_TYPE", function(name, expected, actual) {
2223		var determiner;
2224		if (typeof expected === "string" && startsWith(expected, "not ")) {
2225			determiner = "must not be";
2226			expected = expected.replace(/^not /, "");
2227		} else determiner = "must be";
2228		var msg;
2229		if (endsWith(name, " argument")) msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, "type"));
2230		else {
2231			var type = includes(name, ".") ? "property" : "argument";
2232			msg = "The \"".concat(name, "\" ").concat(type, " ").concat(determiner, " ").concat(oneOf(expected, "type"));
2233		}
2234		msg += ". Received type ".concat(typeof actual);
2235		return msg;
2236	}, TypeError);
2237	createErrorType("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF");
2238	createErrorType("ERR_METHOD_NOT_IMPLEMENTED", function(name) {
2239		return "The " + name + " method is not implemented";
2240	});
2241	createErrorType("ERR_STREAM_PREMATURE_CLOSE", "Premature close");
2242	createErrorType("ERR_STREAM_DESTROYED", function(name) {
2243		return "Cannot call " + name + " after a stream was destroyed";
2244	});
2245	createErrorType("ERR_MULTIPLE_CALLBACK", "Callback called multiple times");
2246	createErrorType("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable");
2247	createErrorType("ERR_STREAM_WRITE_AFTER_END", "write after end");
2248	createErrorType("ERR_STREAM_NULL_VALUES", "May not write null values to stream", TypeError);
2249	createErrorType("ERR_UNKNOWN_ENCODING", function(arg) {
2250		return "Unknown encoding: " + arg;
2251	}, TypeError);
2252	createErrorType("ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event");
2253	module.exports.codes = codes;
2254}));
2255//#endregion
2256//#region node_modules/hash-base/node_modules/readable-stream/lib/internal/streams/state.js
2257var require_state$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2258	var ERR_INVALID_OPT_VALUE = require_errors_browser$1().codes.ERR_INVALID_OPT_VALUE;
2259	function highWaterMarkFrom(options, isDuplex, duplexKey) {
2260		return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
2261	}
2262	function getHighWaterMark(state, options, duplexKey, isDuplex) {
2263		var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
2264		if (hwm != null) {
2265			if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) throw new ERR_INVALID_OPT_VALUE(isDuplex ? duplexKey : "highWaterMark", hwm);
2266			return Math.floor(hwm);
2267		}
2268		return state.objectMode ? 16 : 16 * 1024;
2269	}
2270	module.exports = { getHighWaterMark };
2271}));
2272//#endregion
2273//#region node_modules/util-deprecate/browser.js
2274var require_browser$11 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2275	/**
2276	* Module exports.
2277	*/
2278	module.exports = deprecate;
2279	/**
2280	* Mark that a method should not be used.
2281	* Returns a modified function which warns once by default.
2282	*
2283	* If `localStorage.noDeprecation = true` is set, then it is a no-op.
2284	*
2285	* If `localStorage.throwDeprecation = true` is set, then deprecated functions
2286	* will throw an Error when invoked.
2287	*
2288	* If `localStorage.traceDeprecation = true` is set, then deprecated functions
2289	* will invoke `console.trace()` instead of `console.error()`.
2290	*
2291	* @param {Function} fn - the function to deprecate
2292	* @param {String} msg - the string to print to the console when `fn` is invoked
2293	* @returns {Function} a new "deprecated" version of `fn`
2294	* @api public
2295	*/
2296	function deprecate(fn, msg) {
2297		if (config("noDeprecation")) return fn;
2298		var warned = false;
2299		function deprecated() {
2300			if (!warned) {
2301				if (config("throwDeprecation")) throw new Error(msg);
2302				else if (config("traceDeprecation")) console.trace(msg);
2303				else console.warn(msg);
2304				warned = true;
2305			}
2306			return fn.apply(this, arguments);
2307		}
2308		return deprecated;
2309	}
2310	/**
2311	* Checks `localStorage` for boolean values for the given `name`.
2312	*
2313	* @param {String} name
2314	* @returns {Boolean}
2315	* @api private
2316	*/
2317	function config(name) {
2318		try {
2319			if (!globalThis.localStorage) return false;

2320		} catch (_) {
2321			return false;
2322		}
2323		var val = globalThis.localStorage[name];
2324		if (null == val) return false;
2325		return String(val).toLowerCase() === "true";
2326	}
2327}));
2328//#endregion
2329//#region node_modules/hash-base/node_modules/readable-stream/lib/_stream_writable.js
2330var require__stream_writable$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2331	var process = require_browser$15();
2332	module.exports = Writable;
2333	function CorkedRequest(state) {
2334		var _this = this;
2335		this.next = null;
2336		this.entry = null;
2337		this.finish = function() {
2338			onCorkedFinish(_this, state);
2339		};
2340	}
2341	var Duplex;
2342	Writable.WritableState = WritableState;
2343	var internalUtil = { deprecate: require_browser$11() };
2344	var Stream = require_stream_browser$2();
2345	var Buffer = require_buffer$1().Buffer;
2346	var OurUint8Array = globalThis.Uint8Array || function() {};
2347	function _uint8ArrayToBuffer(chunk) {
2348		return Buffer.from(chunk);
2349	}
2350	function _isUint8Array(obj) {
2351		return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
2352	}
2353	var destroyImpl = require_destroy$2();
2354	var getHighWaterMark = require_state$1().getHighWaterMark;
2355	var _require$codes = require_errors_browser$1().codes;
2356	var ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE;
2357	var ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED;
2358	var ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK;
2359	var ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE;
2360	var ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
2361	var ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES;
2362	var ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END;
2363	var ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;
2364	var errorOrDestroy = destroyImpl.errorOrDestroy;
2365	require_inherits_browser()(Writable, Stream);
2366	function nop() {}
2367	function WritableState(options, stream, isDuplex) {
2368		Duplex = Duplex || require__stream_duplex$2();
2369		options = options || {};
2370		if (typeof isDuplex !== "boolean") isDuplex = stream instanceof Duplex;
2371		this.objectMode = !!options.objectMode;
2372		if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
2373		this.highWaterMark = getHighWaterMark(this, options, "writableHighWaterMark", isDuplex);
2374		this.finalCalled = false;
2375		this.needDrain = false;
2376		this.ending = false;
2377		this.ended = false;
2378		this.finished = false;
2379		this.destroyed = false;
2380		var noDecode = options.decodeStrings === false;
2381		this.decodeStrings = !noDecode;
2382		this.defaultEncoding = options.defaultEncoding || "utf8";
2383		this.length = 0;
2384		this.writing = false;
2385		this.corked = 0;
2386		this.sync = true;
2387		this.bufferProcessing = false;
2388		this.onwrite = function(er) {
2389			onwrite(stream, er);
2390		};
2391		this.writecb = null;
2392		this.writelen = 0;
2393		this.bufferedRequest = null;
2394		this.lastBufferedRequest = null;
2395		this.pendingcb = 0;
2396		this.prefinished = false;
2397		this.errorEmitted = false;
2398		this.emitClose = options.emitClose !== false;
2399		this.autoDestroy = !!options.autoDestroy;
2400		this.bufferedRequestCount = 0;
2401		this.corkedRequestsFree = new CorkedRequest(this);
2402	}
2403	WritableState.prototype.getBuffer = function getBuffer() {
2404		var current = this.bufferedRequest;
2405		var out = [];
2406		while (current) {
2407			out.push(current);
2408			current = current.next;
2409		}
2410		return out;
2411	};
2412	(function() {
2413		try {
2414			Object.defineProperty(WritableState.prototype, "buffer", { get: internalUtil.deprecate(function writableStateBufferGetter() {
2415				return this.getBuffer();
2416			}, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003") });
2417		} catch (_) {}
2418	})();
2419	var realHasInstance;
2420	if (typeof Symbol === "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === "function") {
2421		realHasInstance = Function.prototype[Symbol.hasInstance];
2422		Object.defineProperty(Writable, Symbol.hasInstance, { value: function value(object) {
2423			if (realHasInstance.call(this, object)) return true;
2424			if (this !== Writable) return false;
2425			return object && object._writableState instanceof WritableState;
2426		} });
2427	} else realHasInstance = function realHasInstance(object) {
2428		return object instanceof this;
2429	};

2430	function Writable(options) {
2431		Duplex = Duplex || require__stream_duplex$2();
2432		var isDuplex = this instanceof Duplex;
2433		if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);
2434		this._writableState = new WritableState(options, this, isDuplex);
2435		this.writable = true;
2436		if (options) {
2437			if (typeof options.write === "function") this._write = options.write;
2438			if (typeof options.writev === "function") this._writev = options.writev;
2439			if (typeof options.destroy === "function") this._destroy = options.destroy;
2440			if (typeof options.final === "function") this._final = options.final;
2441		}
2442		Stream.call(this);
2443	}
2444	Writable.prototype.pipe = function() {
2445		errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());
2446	};
2447	function writeAfterEnd(stream, cb) {
2448		var er = new ERR_STREAM_WRITE_AFTER_END();
2449		errorOrDestroy(stream, er);
2450		process.nextTick(cb, er);
2451	}
2452	function validChunk(stream, state, chunk, cb) {
2453		var er;
2454		if (chunk === null) er = new ERR_STREAM_NULL_VALUES();
2455		else if (typeof chunk !== "string" && !state.objectMode) er = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer"], chunk);
2456		if (er) {
2457			errorOrDestroy(stream, er);
2458			process.nextTick(cb, er);
2459			return false;
2460		}
2461		return true;
2462	}
2463	Writable.prototype.write = function(chunk, encoding, cb) {
2464		var state = this._writableState;
2465		var ret = false;
2466		var isBuf = !state.objectMode && _isUint8Array(chunk);
2467		if (isBuf && !Buffer.isBuffer(chunk)) chunk = _uint8ArrayToBuffer(chunk);
2468		if (typeof encoding === "function") {
2469			cb = encoding;
2470			encoding = null;
2471		}
2472		if (isBuf) encoding = "buffer";
2473		else if (!encoding) encoding = state.defaultEncoding;
2474		if (typeof cb !== "function") cb = nop;
2475		if (state.ending) writeAfterEnd(this, cb);
2476		else if (isBuf || validChunk(this, state, chunk, cb)) {
2477			state.pendingcb++;
2478			ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
2479		}
2480		return ret;
2481	};
2482	Writable.prototype.cork = function() {
2483		this._writableState.corked++;
2484	};
2485	Writable.prototype.uncork = function() {
2486		var state = this._writableState;
2487		if (state.corked) {
2488			state.corked--;
2489			if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
2490		}
2491	};
2492	Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
2493		if (typeof encoding === "string") encoding = encoding.toLowerCase();
2494		if (!([
2495			"hex",
2496			"utf8",
2497			"utf-8",
2498			"ascii",
2499			"binary",
2500			"base64",
2501			"ucs2",
2502			"ucs-2",
2503			"utf16le",
2504			"utf-16le",
2505			"raw"
2506		].indexOf((encoding + "").toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);
2507		this._writableState.defaultEncoding = encoding;
2508		return this;
2509	};
2510	Object.defineProperty(Writable.prototype, "writableBuffer", {
2511		enumerable: false,
2512		get: function get() {
2513			return this._writableState && this._writableState.getBuffer();
2514		}
2515	});
2516	function decodeChunk(state, chunk, encoding) {
2517		if (!state.objectMode && state.decodeStrings !== false && typeof chunk === "string") chunk = Buffer.from(chunk, encoding);
2518		return chunk;
2519	}
2520	Object.defineProperty(Writable.prototype, "writableHighWaterMark", {
2521		enumerable: false,
2522		get: function get() {
2523			return this._writableState.highWaterMark;
2524		}
2525	});
2526	function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
2527		if (!isBuf) {
2528			var newChunk = decodeChunk(state, chunk, encoding);
2529			if (chunk !== newChunk) {
2530				isBuf = true;
2531				encoding = "buffer";
2532				chunk = newChunk;
2533			}
2534		}
2535		var len = state.objectMode ? 1 : chunk.length;
2536		state.length += len;
2537		var ret = state.length < state.highWaterMark;
2538		if (!ret) state.needDrain = true;
2539		if (state.writing || state.corked) {
2540			var last = state.lastBufferedRequest;
2541			state.lastBufferedRequest = {
2542				chunk,
2543				encoding,
2544				isBuf,
2545				callback: cb,
2546				next: null
2547			};
2548			if (last) last.next = state.lastBufferedRequest;
2549			else state.bufferedRequest = state.lastBufferedRequest;
2550			state.bufferedRequestCount += 1;
2551		} else doWrite(stream, state, false, len, chunk, encoding, cb);
2552		return ret;
2553	}
2554	function doWrite(stream, state, writev, len, chunk, encoding, cb) {
2555		state.writelen = len;
2556		state.writecb = cb;
2557		state.writing = true;
2558		state.sync = true;
2559		if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED("write"));
2560		else if (writev) stream._writev(chunk, state.onwrite);
2561		else stream._write(chunk, encoding, state.onwrite);
2562		state.sync = false;
2563	}
2564	function onwriteError(stream, state, sync, er, cb) {
2565		--state.pendingcb;
2566		if (sync) {
2567			process.nextTick(cb, er);
2568			process.nextTick(finishMaybe, stream, state);
2569			stream._writableState.errorEmitted = true;
2570			errorOrDestroy(stream, er);
2571		} else {
2572			cb(er);
2573			stream._writableState.errorEmitted = true;
2574			errorOrDestroy(stream, er);
2575			finishMaybe(stream, state);
2576		}
2577	}
2578	function onwriteStateUpdate(state) {
2579		state.writing = false;
2580		state.writecb = null;
2581		state.length -= state.writelen;
2582		state.writelen = 0;
2583	}
2584	function onwrite(stream, er) {
2585		var state = stream._writableState;
2586		var sync = state.sync;
2587		var cb = state.writecb;
2588		if (typeof cb !== "function") throw new ERR_MULTIPLE_CALLBACK();
2589		onwriteStateUpdate(state);
2590		if (er) onwriteError(stream, state, sync, er, cb);
2591		else {
2592			var finished = needFinish(state) || stream.destroyed;
2593			if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(stream, state);
2594			if (sync) process.nextTick(afterWrite, stream, state, finished, cb);
2595			else afterWrite(stream, state, finished, cb);
2596		}
2597	}
2598	function afterWrite(stream, state, finished, cb) {
2599		if (!finished) onwriteDrain(stream, state);
2600		state.pendingcb--;
2601		cb();
2602		finishMaybe(stream, state);
2603	}
2604	function onwriteDrain(stream, state) {
2605		if (state.length === 0 && state.needDrain) {
2606			state.needDrain = false;

2607			stream.emit("drain");
2608		}
2609	}
2610	function clearBuffer(stream, state) {
2611		state.bufferProcessing = true;
2612		var entry = state.bufferedRequest;
2613		if (stream._writev && entry && entry.next) {
2614			var l = state.bufferedRequestCount;
2615			var buffer = new Array(l);
2616			var holder = state.corkedRequestsFree;
2617			holder.entry = entry;
2618			var count = 0;
2619			var allBuffers = true;
2620			while (entry) {
2621				buffer[count] = entry;
2622				if (!entry.isBuf) allBuffers = false;
2623				entry = entry.next;
2624				count += 1;
2625			}
2626			buffer.allBuffers = allBuffers;
2627			doWrite(stream, state, true, state.length, buffer, "", holder.finish);
2628			state.pendingcb++;
2629			state.lastBufferedRequest = null;
2630			if (holder.next) {
2631				state.corkedRequestsFree = holder.next;
2632				holder.next = null;
2633			} else state.corkedRequestsFree = new CorkedRequest(state);
2634			state.bufferedRequestCount = 0;
2635		} else {
2636			while (entry) {
2637				var chunk = entry.chunk;
2638				var encoding = entry.encoding;
2639				var cb = entry.callback;
2640				doWrite(stream, state, false, state.objectMode ? 1 : chunk.length, chunk, encoding, cb);
2641				entry = entry.next;
2642				state.bufferedRequestCount--;
2643				if (state.writing) break;
2644			}
2645			if (entry === null) state.lastBufferedRequest = null;
2646		}
2647		state.bufferedRequest = entry;
2648		state.bufferProcessing = false;
2649	}
2650	Writable.prototype._write = function(chunk, encoding, cb) {
2651		cb(new ERR_METHOD_NOT_IMPLEMENTED("_write()"));
2652	};
2653	Writable.prototype._writev = null;
2654	Writable.prototype.end = function(chunk, encoding, cb) {
2655		var state = this._writableState;
2656		if (typeof chunk === "function") {
2657			cb = chunk;
2658			chunk = null;
2659			encoding = null;
2660		} else if (typeof encoding === "function") {
2661			cb = encoding;
2662			encoding = null;
2663		}
2664		if (chunk !== null && chunk !== void 0) this.write(chunk, encoding);
2665		if (state.corked) {
2666			state.corked = 1;
2667			this.uncork();
2668		}
2669		if (!state.ending) endWritable(this, state, cb);
2670		return this;
2671	};
2672	Object.defineProperty(Writable.prototype, "writableLength", {
2673		enumerable: false,
2674		get: function get() {
2675			return this._writableState.length;
2676		}
2677	});
2678	function needFinish(state) {
2679		return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
2680	}
2681	function callFinal(stream, state) {
2682		stream._final(function(err) {
2683			state.pendingcb--;
2684			if (err) errorOrDestroy(stream, err);
2685			state.prefinished = true;
2686			stream.emit("prefinish");
2687			finishMaybe(stream, state);
2688		});
2689	}
2690	function prefinish(stream, state) {
2691		if (!state.prefinished && !state.finalCalled) if (typeof stream._final === "function" && !state.destroyed) {
2692			state.pendingcb++;
2693			state.finalCalled = true;
2694			process.nextTick(callFinal, stream, state);
2695		} else {
2696			state.prefinished = true;
2697			stream.emit("prefinish");
2698		}
2699	}
2700	function finishMaybe(stream, state) {
2701		var need = needFinish(state);
2702		if (need) {
2703			prefinish(stream, state);
2704			if (state.pendingcb === 0) {
2705				state.finished = true;
2706				stream.emit("finish");
2707				if (state.autoDestroy) {
2708					var rState = stream._readableState;
2709					if (!rState || rState.autoDestroy && rState.endEmitted) stream.destroy();
2710				}
2711			}
2712		}
2713		return need;
2714	}
2715	function endWritable(stream, state, cb) {
2716		state.ending = true;
2717		finishMaybe(stream, state);
2718		if (cb) if (state.finished) process.nextTick(cb);
2719		else stream.once("finish", cb);
2720		state.ended = true;
2721		stream.writable = false;
2722	}
2723	function onCorkedFinish(corkReq, state, err) {
2724		var entry = corkReq.entry;
2725		corkReq.entry = null;
2726		while (entry) {
2727			var cb = entry.callback;
2728			state.pendingcb--;
2729			cb(err);
2730			entry = entry.next;
2731		}
2732		state.corkedRequestsFree.next = corkReq;
2733	}
2734	Object.defineProperty(Writable.prototype, "destroyed", {
2735		enumerable: false,
2736		get: function get() {
2737			if (this._writableState === void 0) return false;
2738			return this._writableState.destroyed;
2739		},
2740		set: function set(value) {
2741			if (!this._writableState) return;
2742			this._writableState.destroyed = value;
2743		}
2744	});
2745	Writable.prototype.destroy = destroyImpl.destroy;
2746	Writable.prototype._undestroy = destroyImpl.undestroy;
2747	Writable.prototype._destroy = function(err, cb) {
2748		cb(err);
2749	};
2750}));
2751//#endregion
2752//#region node_modules/hash-base/node_modules/readable-stream/lib/_stream_duplex.js
2753var require__stream_duplex$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2754	var process = require_browser$15();
2755	var objectKeys = Object.keys || function(obj) {
2756		var keys = [];
2757		for (var key in obj) keys.push(key);
2758		return keys;
2759	};
2760	module.exports = Duplex;
2761	var Readable = require__stream_readable$2();
2762	var Writable = require__stream_writable$2();
2763	require_inherits_browser()(Duplex, Readable);
2764	var keys = objectKeys(Writable.prototype);
2765	for (var v = 0; v < keys.length; v++) {
2766		var method = keys[v];
2767		if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
2768	}
2769	function Duplex(options) {
2770		if (!(this instanceof Duplex)) return new Duplex(options);
2771		Readable.call(this, options);
2772		Writable.call(this, options);
2773		this.allowHalfOpen = true;
2774		if (options) {
2775			if (options.readable === false) this.readable = false;