@kasperpeulen/vitest-plugin-nextjs 0.0.0-alpha.0 → 0.1.0-alpha.0

package/dist/node/string_decoder.js

@@ -0,0 +1,276 @@
+import * as m from "buffer";
+//#region \0rolldown/runtime.js
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+//#endregion
+//#region \0require-as-import:buffer
+var require__require_as_import_buffer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = m.default;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/safe-buffer@5.2.1/node_modules/safe-buffer/index.js
+var require_safe_buffer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var buffer = require__require_as_import_buffer();
+	var Buffer = buffer.Buffer;
+	function copyProps(src, dst) {
+		for (var key in src) dst[key] = src[key];
+	}
+	if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) module.exports = buffer;
+	else {
+		copyProps(buffer, exports);
+		exports.Buffer = SafeBuffer;
+	}
+	function SafeBuffer(arg, encodingOrOffset, length) {
+		return Buffer(arg, encodingOrOffset, length);
+	}
+	SafeBuffer.prototype = Object.create(Buffer.prototype);
+	copyProps(Buffer, SafeBuffer);
+	SafeBuffer.from = function(arg, encodingOrOffset, length) {
+		if (typeof arg === "number") throw new TypeError("Argument must not be a number");
+		return Buffer(arg, encodingOrOffset, length);
+	};
+	SafeBuffer.alloc = function(size, fill, encoding) {
+		if (typeof size !== "number") throw new TypeError("Argument must be a number");
+		var buf = Buffer(size);
+		if (fill !== void 0) {
+			if (typeof encoding === "string") buf.fill(fill, encoding);
+			else buf.fill(fill);
+		} else buf.fill(0);
+		return buf;
+	};
+	SafeBuffer.allocUnsafe = function(size) {
+		if (typeof size !== "number") throw new TypeError("Argument must be a number");
+		return Buffer(size);
+	};
+	SafeBuffer.allocUnsafeSlow = function(size) {
+		if (typeof size !== "number") throw new TypeError("Argument must be a number");
+		return buffer.SlowBuffer(size);
+	};
+}));
+//#endregion
+//#region src/node/string_decoder.ts
+var import_string_decoder = (/* @__PURE__ */ __commonJSMin(((exports) => {
+	var Buffer = require_safe_buffer().Buffer;
+	var isEncoding = Buffer.isEncoding || function(encoding) {
+		encoding = "" + encoding;
+		switch (encoding && encoding.toLowerCase()) {
+			case "hex":
+			case "utf8":
+			case "utf-8":
+			case "ascii":
+			case "binary":
+			case "base64":
+			case "ucs2":
+			case "ucs-2":
+			case "utf16le":
+			case "utf-16le":
+			case "raw": return true;
+			default: return false;
+		}
+	};
+	function _normalizeEncoding(enc) {
+		if (!enc) return "utf8";
+		var retried;
+		while (true) switch (enc) {
+			case "utf8":
+			case "utf-8": return "utf8";
+			case "ucs2":
+			case "ucs-2":
+			case "utf16le":
+			case "utf-16le": return "utf16le";
+			case "latin1":
+			case "binary": return "latin1";
+			case "base64":
+			case "ascii":
+			case "hex": return enc;
+			default:
+				if (retried) return;
+				enc = ("" + enc).toLowerCase();
+				retried = true;
+		}
+	}
+	function normalizeEncoding(enc) {
+		var nenc = _normalizeEncoding(enc);
+		if (typeof nenc !== "string" && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error("Unknown encoding: " + enc);
+		return nenc || enc;
+	}
+	exports.StringDecoder = StringDecoder;
+	function StringDecoder(encoding) {
+		this.encoding = normalizeEncoding(encoding);
+		var nb;
+		switch (this.encoding) {
+			case "utf16le":
+				this.text = utf16Text;
+				this.end = utf16End;
+				nb = 4;
+				break;
+			case "utf8":
+				this.fillLast = utf8FillLast;
+				nb = 4;
+				break;
+			case "base64":
+				this.text = base64Text;
+				this.end = base64End;
+				nb = 3;
+				break;
+			default:
+				this.write = simpleWrite;
+				this.end = simpleEnd;
+				return;
+		}
+		this.lastNeed = 0;
+		this.lastTotal = 0;
+		this.lastChar = Buffer.allocUnsafe(nb);
+	}
+	StringDecoder.prototype.write = function(buf) {
+		if (buf.length === 0) return "";
+		var r;
+		var i;
+		if (this.lastNeed) {
+			r = this.fillLast(buf);
+			if (r === void 0) return "";
+			i = this.lastNeed;
+			this.lastNeed = 0;
+		} else i = 0;
+		if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
+		return r || "";
+	};
+	StringDecoder.prototype.end = utf8End;
+	StringDecoder.prototype.text = utf8Text;
+	StringDecoder.prototype.fillLast = function(buf) {
+		if (this.lastNeed <= buf.length) {
+			buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
+			return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+		}
+		buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
+		this.lastNeed -= buf.length;
+	};
+	function utf8CheckByte(byte) {
+		if (byte <= 127) return 0;
+		else if (byte >> 5 === 6) return 2;
+		else if (byte >> 4 === 14) return 3;
+		else if (byte >> 3 === 30) return 4;
+		return byte >> 6 === 2 ? -1 : -2;
+	}
+	function utf8CheckIncomplete(self, buf, i) {
+		var j = buf.length - 1;
+		if (j < i) return 0;
+		var nb = utf8CheckByte(buf[j]);
+		if (nb >= 0) {
+			if (nb > 0) self.lastNeed = nb - 1;
+			return nb;
+		}
+		if (--j < i || nb === -2) return 0;
+		nb = utf8CheckByte(buf[j]);
+		if (nb >= 0) {
+			if (nb > 0) self.lastNeed = nb - 2;
+			return nb;
+		}
+		if (--j < i || nb === -2) return 0;
+		nb = utf8CheckByte(buf[j]);
+		if (nb >= 0) {
+			if (nb > 0) {
+				if (nb === 2) nb = 0;
+				else self.lastNeed = nb - 3;
+			}
+			return nb;
+		}
+		return 0;
+	}
+	function utf8CheckExtraBytes(self, buf, p) {
+		if ((buf[0] & 192) !== 128) {
+			self.lastNeed = 0;
+			return "�";
+		}
+		if (self.lastNeed > 1 && buf.length > 1) {
+			if ((buf[1] & 192) !== 128) {
+				self.lastNeed = 1;
+				return "�";
+			}
+			if (self.lastNeed > 2 && buf.length > 2) {
+				if ((buf[2] & 192) !== 128) {
+					self.lastNeed = 2;
+					return "�";
+				}
+			}
+		}
+	}
+	function utf8FillLast(buf) {
+		var p = this.lastTotal - this.lastNeed;
+		var r = utf8CheckExtraBytes(this, buf, p);
+		if (r !== void 0) return r;
+		if (this.lastNeed <= buf.length) {
+			buf.copy(this.lastChar, p, 0, this.lastNeed);
+			return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+		}
+		buf.copy(this.lastChar, p, 0, buf.length);
+		this.lastNeed -= buf.length;
+	}
+	function utf8Text(buf, i) {
+		var total = utf8CheckIncomplete(this, buf, i);
+		if (!this.lastNeed) return buf.toString("utf8", i);
+		this.lastTotal = total;
+		var end = buf.length - (total - this.lastNeed);
+		buf.copy(this.lastChar, 0, end);
+		return buf.toString("utf8", i, end);
+	}
+	function utf8End(buf) {
+		var r = buf && buf.length ? this.write(buf) : "";
+		if (this.lastNeed) return r + "�";
+		return r;
+	}
+	function utf16Text(buf, i) {
+		if ((buf.length - i) % 2 === 0) {
+			var r = buf.toString("utf16le", i);
+			if (r) {
+				var c = r.charCodeAt(r.length - 1);
+				if (c >= 55296 && c <= 56319) {
+					this.lastNeed = 2;
+					this.lastTotal = 4;
+					this.lastChar[0] = buf[buf.length - 2];
+					this.lastChar[1] = buf[buf.length - 1];
+					return r.slice(0, -1);
+				}
+			}
+			return r;
+		}
+		this.lastNeed = 1;
+		this.lastTotal = 2;
+		this.lastChar[0] = buf[buf.length - 1];
+		return buf.toString("utf16le", i, buf.length - 1);
+	}
+	function utf16End(buf) {
+		var r = buf && buf.length ? this.write(buf) : "";
+		if (this.lastNeed) {
+			var end = this.lastTotal - this.lastNeed;
+			return r + this.lastChar.toString("utf16le", 0, end);
+		}
+		return r;
+	}
+	function base64Text(buf, i) {
+		var n = (buf.length - i) % 3;
+		if (n === 0) return buf.toString("base64", i);
+		this.lastNeed = 3 - n;
+		this.lastTotal = 3;
+		if (n === 1) this.lastChar[0] = buf[buf.length - 1];
+		else {
+			this.lastChar[0] = buf[buf.length - 2];
+			this.lastChar[1] = buf[buf.length - 1];
+		}
+		return buf.toString("base64", i, buf.length - n);
+	}
+	function base64End(buf) {
+		var r = buf && buf.length ? this.write(buf) : "";
+		if (this.lastNeed) return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
+		return r;
+	}
+	function simpleWrite(buf) {
+		return buf.toString(this.encoding);
+	}
+	function simpleEnd(buf) {
+		return buf && buf.length ? this.write(buf) : "";
+	}
+})))();
+var string_decoder_default = { StringDecoder: import_string_decoder.StringDecoder };
+//#endregion
+var StringDecoder = import_string_decoder.StringDecoder;
+export { StringDecoder, string_decoder_default as default };

package/dist/node/sys.js

@@ -0,0 +1,6 @@
+import util from "@kasperpeulen/vitest-plugin-nextjs/node/util";
+export * from "@kasperpeulen/vitest-plugin-nextjs/node/util";
+//#region src/node/sys.ts
+var sys_default = util;
+//#endregion
+export { sys_default as default };

package/dist/node/timers/promises.js

@@ -0,0 +1,71 @@
+//#region src/registry-global.ts
+const registryGlobal = "__vitest_plugin_rsc_next__";
+//#endregion
+//#region src/node/timers.ts
+const registry = () => globalThis[registryGlobal];
+const setImmediate$1 = (callback, ...args) => registry().setImmediate(callback, ...args);
+const clearImmediate = (id) => registry().clearImmediate(id);
+const setTimeout$1 = (callback, delay, ...args) => globalThis.setTimeout(callback, delay, ...args);
+const clearTimeout = (id) => globalThis.clearTimeout(id);
+//#endregion
+//#region src/node/timers/promises.ts
+const aborted = (signal) => Object.assign(/* @__PURE__ */ new Error("The operation was aborted"), {
+	name: "AbortError",
+	code: "ABORT_ERR",
+	cause: signal.reason
+});
+const after = (start, clear, value, options) => new Promise((resolve, reject) => {
+	const signal = options?.signal;
+	if (signal?.aborted) return reject(aborted(signal));
+	const abort = () => {
+		clear(id);
+		reject(aborted(signal));
+	};
+	const id = start(() => {
+		signal?.removeEventListener("abort", abort);
+		resolve(value);
+	});
+	signal?.addEventListener("abort", abort, { once: true });
+});
+const setTimeout = (delay, value, options) => after((done) => setTimeout$1(done, delay), (id) => clearTimeout(id), value, options);
+const setImmediate = (value, options) => after((done) => setImmediate$1(done), clearImmediate, value, options);
+async function* setInterval(delay, value, options) {
+	const signal = options?.signal;
+	if (signal?.aborted) throw aborted(signal);
+	let pending = 0;
+	let wake;
+	const tick = () => {
+		pending++;
+		wake?.();
+	};
+	const id = globalThis.setInterval(tick, delay);
+	signal?.addEventListener("abort", tick, { once: true });
+	try {
+		for (;;) {
+			while (pending === 0 && !signal?.aborted) {
+				await new Promise((resolve) => {
+					wake = resolve;
+				});
+				wake = void 0;
+			}
+			if (signal?.aborted) throw aborted(signal);
+			pending--;
+			yield value;
+		}
+	} finally {
+		globalThis.clearInterval(id);
+		signal?.removeEventListener("abort", tick);
+	}
+}
+const scheduler = {
+	wait: (delay, options) => setTimeout(delay, void 0, options),
+	yield: () => setImmediate()
+};
+var promises_default = {
+	setTimeout,
+	setImmediate,
+	setInterval,
+	scheduler
+};
+//#endregion
+export { promises_default as default, scheduler, setImmediate, setInterval, setTimeout };

package/dist/node/timers.js

@@ -0,0 +1,133 @@
+import promises from "node:timers/promises";
+//#region src/registry-global.ts
+const registryGlobal = "__vitest_plugin_rsc_next__";
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/_internal/utils.mjs
+/* @__NO_SIDE_EFFECTS__ */
+function createNotImplementedError(name) {
+	return /* @__PURE__ */ new Error(`[unenv] ${name} is not implemented yet!`);
+}
+/* @__NO_SIDE_EFFECTS__ */
+function notImplemented(name) {
+	const fn = () => {
+		throw /* @__PURE__ */ createNotImplementedError(name);
+	};
+	return Object.assign(fn, { __unenv__: true });
+}
+Object.assign(() => {}, { __unenv__: true });
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/timers/timeout.mjs
+var Timeout = class {
+	constructor(callback, args) {
+		if (typeof callback === "function") callback(...args);
+	}
+	close() {
+		throw /* @__PURE__ */ createNotImplementedError("node.timers.timeout.close");
+	}
+	_onTimeout(...args) {
+		throw /* @__PURE__ */ createNotImplementedError("node.timers.timeout._onTimeout");
+	}
+	ref() {
+		return this;
+	}
+	unref() {
+		return this;
+	}
+	hasRef() {
+		return false;
+	}
+	refresh() {
+		return this;
+	}
+	[Symbol.dispose]() {}
+	[Symbol.toPrimitive]() {
+		return 0;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/timers/set-timeout.mjs
+function setTimeoutFallbackPromises(delay, value, options) {
+	return new Promise((res) => {
+		res(value);
+	});
+}
+function setTimeoutFallback(callback, ms, ...args) {
+	return new Timeout(callback, args);
+}
+setTimeoutFallback.__promisify__ = setTimeoutFallbackPromises;
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/timers/immediate.mjs
+var Immediate = class {
+	_onImmediate;
+	_timeout;
+	constructor(callback, args) {
+		this._onImmediate = callback;
+		if ("setTimeout" in globalThis) this._timeout = setTimeout(callback, 0, ...args);
+		else callback(...args);
+	}
+	ref() {
+		this._timeout?.ref();
+		return this;
+	}
+	unref() {
+		this._timeout?.unref();
+		return this;
+	}
+	hasRef() {
+		return this._timeout?.hasRef() ?? false;
+	}
+	[Symbol.dispose]() {
+		if ("clearTimeout" in globalThis) clearTimeout(this._timeout);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/timers/set-immediate.mjs
+function setImmediateFallbackPromises(value) {
+	return new Promise((res) => {
+		res(value);
+	});
+}
+function setImmediateFallback(callback, ...args) {
+	return new Immediate(callback, args);
+}
+setImmediateFallback.__promisify__ = setImmediateFallbackPromises;
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/timers/set-interval.mjs
+async function* setIntervalFallbackPromises(delay, value) {
+	yield value;
+}
+function setIntervalFallback(callback, ms, ...args) {
+	return new Timeout(callback, args);
+}
+setIntervalFallback.__promisify__ = setIntervalFallbackPromises;
+globalThis.clearImmediate?.bind(globalThis);
+globalThis.clearInterval?.bind(globalThis);
+globalThis.clearTimeout?.bind(globalThis);
+globalThis.setImmediate?.bind(globalThis);
+globalThis.setTimeout?.bind(globalThis);
+globalThis.setInterval?.bind(globalThis);
+const active = function active(timeout) {
+	timeout?.refresh?.();
+};
+const _unrefActive = active;
+const enroll = /* @__PURE__ */ notImplemented("timers.enroll");
+const unenroll = /* @__PURE__ */ notImplemented("timers.unenroll");
+//#endregion
+//#region src/node/timers.ts
+const registry = () => globalThis[registryGlobal];
+const setImmediate = (callback, ...args) => registry().setImmediate(callback, ...args);
+const clearImmediate = (id) => registry().clearImmediate(id);
+const setTimeout$1 = (callback, delay, ...args) => globalThis.setTimeout(callback, delay, ...args);
+const clearTimeout$1 = (id) => globalThis.clearTimeout(id);
+const setInterval = (callback, delay, ...args) => globalThis.setInterval(callback, delay, ...args);
+const clearInterval = (id) => globalThis.clearInterval(id);
+var timers_default = {
+	setImmediate,
+	clearImmediate,
+	setTimeout: setTimeout$1,
+	clearTimeout: clearTimeout$1,
+	setInterval,
+	clearInterval
+};
+//#endregion
+export { _unrefActive, active, clearImmediate, clearInterval, clearTimeout$1 as clearTimeout, timers_default as default, enroll, promises, setImmediate, setInterval, setTimeout$1 as setTimeout, unenroll };

package/dist/node/tls.js

@@ -0,0 +1,122 @@
+import { Server as Server$1, Socket } from "node:net";
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/_internal/utils.mjs
+/* @__NO_SIDE_EFFECTS__ */
+function createNotImplementedError(name) {
+	return /* @__PURE__ */ new Error(`[unenv] ${name} is not implemented yet!`);
+}
+/* @__NO_SIDE_EFFECTS__ */
+function notImplemented(name) {
+	const fn = () => {
+		throw /* @__PURE__ */ createNotImplementedError(name);
+	};
+	return Object.assign(fn, { __unenv__: true });
+}
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/tls/tls-socket.mjs
+var TLSSocket = class extends Socket {
+	authorized = false;
+	encrypted = true;
+	alpnProtocol = null;
+	authorizationError = /* @__PURE__ */ new Error("[unenv] TLSSocket.authorizationError is not implemented yet!");
+	exportKeyingMaterial() {
+		throw /* @__PURE__ */ createNotImplementedError("TLSSocket.exportKeyingMaterial");
+	}
+	getCipher() {
+		throw /* @__PURE__ */ createNotImplementedError("TLSSocket.getCipher");
+	}
+	getPeerCertificate(_detailed) {
+		throw /* @__PURE__ */ createNotImplementedError("TLSSocket.getPeerCertificate");
+	}
+	getCertificate() {
+		return null;
+	}
+	getEphemeralKeyInfo() {
+		return null;
+	}
+	getFinished() {}
+	getPeerFinished() {}
+	getProtocol() {
+		return null;
+	}
+	getSession() {}
+	getSharedSigalgs() {
+		return [];
+	}
+	getTLSTicket() {}
+	isSessionReused() {
+		return false;
+	}
+	renegotiate(options, callback) {
+		if (typeof callback === "function") callback(null);
+	}
+	setMaxSendFragment(size) {
+		return false;
+	}
+	disableRenegotiation() {}
+	enableTrace() {}
+	getPeerX509Certificate() {}
+	getX509Certificate() {}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/tls/server.mjs
+var Server = class extends Server$1 {
+	constructor(arg1, arg2) {
+		super(arg1, arg2);
+	}
+	addContext(hostname, context) {}
+	setSecureContext(options) {}
+	setTicketKeys(_keys) {
+		throw /* @__PURE__ */ createNotImplementedError("Server.setTicketKeys");
+	}
+	getTicketKeys() {
+		throw /* @__PURE__ */ createNotImplementedError("Server.getTicketKeys");
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/tls/secure-context.mjs
+var SecureContext = class {
+	context = {};
+};
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/tls/constants.mjs
+const CLIENT_RENEG_LIMIT = 3;
+const CLIENT_RENEG_WINDOW = 600;
+const DEFAULT_CIPHERS = "";
+const DEFAULT_ECDH_CURVE = "auto";
+const DEFAULT_MIN_VERSION = "TLSv1.2";
+const DEFAULT_MAX_VERSION = "TLSv1.3";
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/tls.mjs
+const connect = function connect() {
+	return new TLSSocket();
+};
+const createServer = function createServer() {
+	return new Server();
+};
+const checkServerIdentity = /* @__PURE__ */ notImplemented("tls.checkServerIdentity");
+const convertALPNProtocols = /* @__PURE__ */ notImplemented("tls.convertALPNProtocols");
+const createSecureContext = /* @__PURE__ */ notImplemented("tls.createSecureContext");
+const createSecurePair = /* @__PURE__ */ notImplemented("tls.createSecurePair");
+const getCiphers = /* @__PURE__ */ notImplemented("tls.getCiphers");
+const rootCertificates = [];
+var tls_default = {
+	CLIENT_RENEG_LIMIT: 3,
+	CLIENT_RENEG_WINDOW: 600,
+	DEFAULT_CIPHERS: "",
+	DEFAULT_ECDH_CURVE,
+	DEFAULT_MAX_VERSION,
+	DEFAULT_MIN_VERSION,
+	SecureContext,
+	Server,
+	TLSSocket,
+	checkServerIdentity,
+	connect,
+	convertALPNProtocols,
+	createSecureContext,
+	createSecurePair,
+	createServer,
+	getCiphers,
+	rootCertificates
+};
+//#endregion
+export { CLIENT_RENEG_LIMIT, CLIENT_RENEG_WINDOW, DEFAULT_CIPHERS, DEFAULT_ECDH_CURVE, DEFAULT_MAX_VERSION, DEFAULT_MIN_VERSION, SecureContext, Server, TLSSocket, checkServerIdentity, connect, convertALPNProtocols, createSecureContext, createSecurePair, createServer, tls_default as default, getCiphers, rootCertificates };

package/dist/node/trace_events.js

@@ -0,0 +1,23 @@
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/trace_events/tracing.mjs
+var Tracing = class {
+	categories = "";
+	enabled = false;
+	disable() {
+		this.enabled = false;
+	}
+	enable() {
+		this.enabled = true;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/trace_events.mjs
+const createTracing = function() {
+	return new Tracing();
+};
+const getEnabledCategories = () => "";
+var trace_events_default = {
+	createTracing,
+	getEnabledCategories
+};
+//#endregion
+export { createTracing, trace_events_default as default, getEnabledCategories };

package/dist/node/tty.js

@@ -0,0 +1,69 @@
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/tty/read-stream.mjs
+var ReadStream = class {
+	fd;
+	isRaw = false;
+	isTTY = false;
+	constructor(fd) {
+		this.fd = fd;
+	}
+	setRawMode(mode) {
+		this.isRaw = mode;
+		return this;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/tty/write-stream.mjs
+var WriteStream = class {
+	fd;
+	columns = 80;
+	rows = 24;
+	isTTY = false;
+	constructor(fd) {
+		this.fd = fd;
+	}
+	clearLine(dir, callback) {
+		callback && callback();
+		return false;
+	}
+	clearScreenDown(callback) {
+		callback && callback();
+		return false;
+	}
+	cursorTo(x, y, callback) {
+		callback && typeof callback === "function" && callback();
+		return false;
+	}
+	moveCursor(dx, dy, callback) {
+		callback && callback();
+		return false;
+	}
+	getColorDepth(env) {
+		return 1;
+	}
+	hasColors(count, env) {
+		return false;
+	}
+	getWindowSize() {
+		return [this.columns, this.rows];
+	}
+	write(str, encoding, cb) {
+		if (str instanceof Uint8Array) str = new TextDecoder().decode(str);
+		try {
+			console.log(str);
+		} catch {}
+		cb && typeof cb === "function" && cb();
+		return false;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/tty.mjs
+const isatty = function() {
+	return false;
+};
+var tty_default = {
+	ReadStream,
+	WriteStream,
+	isatty
+};
+//#endregion
+export { ReadStream, WriteStream, tty_default as default, isatty };