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

package/dist/node/process.js

@@ -0,0 +1,452 @@
+import { EventEmitter } from "node:events";
+import { ReadStream, WriteStream } from "node:tty";
+//#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/process/node-version.mjs
+const NODE_VERSION = "22.14.0";
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/process/process.mjs
+var Process = class Process extends EventEmitter {
+	env;
+	hrtime;
+	nextTick;
+	constructor(impl) {
+		super();
+		this.env = impl.env;
+		this.hrtime = impl.hrtime;
+		this.nextTick = impl.nextTick;
+		for (const prop of [...Object.getOwnPropertyNames(Process.prototype), ...Object.getOwnPropertyNames(EventEmitter.prototype)]) {
+			const value = this[prop];
+			if (typeof value === "function") this[prop] = value.bind(this);
+		}
+	}
+	emitWarning(warning, type, code) {
+		console.warn(`${code ? `[${code}] ` : ""}${type ? `${type}: ` : ""}${warning}`);
+	}
+	emit(...args) {
+		return super.emit(...args);
+	}
+	listeners(eventName) {
+		return super.listeners(eventName);
+	}
+	#stdin;
+	#stdout;
+	#stderr;
+	get stdin() {
+		return this.#stdin ??= new ReadStream(0);
+	}
+	get stdout() {
+		return this.#stdout ??= new WriteStream(1);
+	}
+	get stderr() {
+		return this.#stderr ??= new WriteStream(2);
+	}
+	#cwd = "/";
+	chdir(cwd) {
+		this.#cwd = cwd;
+	}
+	cwd() {
+		return this.#cwd;
+	}
+	arch = "";
+	platform = "";
+	argv = [];
+	argv0 = "";
+	execArgv = [];
+	execPath = "";
+	title = "";
+	pid = 200;
+	ppid = 100;
+	get version() {
+		return `v${NODE_VERSION}`;
+	}
+	get versions() {
+		return { node: NODE_VERSION };
+	}
+	get allowedNodeEnvironmentFlags() {
+		return /* @__PURE__ */ new Set();
+	}
+	get sourceMapsEnabled() {
+		return false;
+	}
+	get debugPort() {
+		return 0;
+	}
+	get throwDeprecation() {
+		return false;
+	}
+	get traceDeprecation() {
+		return false;
+	}
+	get features() {
+		return {};
+	}
+	get release() {
+		return {};
+	}
+	get connected() {
+		return false;
+	}
+	get config() {
+		return {};
+	}
+	get moduleLoadList() {
+		return [];
+	}
+	constrainedMemory() {
+		return 0;
+	}
+	availableMemory() {
+		return 0;
+	}
+	uptime() {
+		return 0;
+	}
+	resourceUsage() {
+		return {};
+	}
+	ref() {}
+	unref() {}
+	umask() {
+		throw /* @__PURE__ */ createNotImplementedError("process.umask");
+	}
+	getBuiltinModule() {}
+	getActiveResourcesInfo() {
+		throw /* @__PURE__ */ createNotImplementedError("process.getActiveResourcesInfo");
+	}
+	exit() {
+		throw /* @__PURE__ */ createNotImplementedError("process.exit");
+	}
+	reallyExit() {
+		throw /* @__PURE__ */ createNotImplementedError("process.reallyExit");
+	}
+	kill() {
+		throw /* @__PURE__ */ createNotImplementedError("process.kill");
+	}
+	abort() {
+		throw /* @__PURE__ */ createNotImplementedError("process.abort");
+	}
+	dlopen() {
+		throw /* @__PURE__ */ createNotImplementedError("process.dlopen");
+	}
+	setSourceMapsEnabled() {
+		throw /* @__PURE__ */ createNotImplementedError("process.setSourceMapsEnabled");
+	}
+	loadEnvFile() {
+		throw /* @__PURE__ */ createNotImplementedError("process.loadEnvFile");
+	}
+	disconnect() {
+		throw /* @__PURE__ */ createNotImplementedError("process.disconnect");
+	}
+	cpuUsage() {
+		throw /* @__PURE__ */ createNotImplementedError("process.cpuUsage");
+	}
+	setUncaughtExceptionCaptureCallback() {
+		throw /* @__PURE__ */ createNotImplementedError("process.setUncaughtExceptionCaptureCallback");
+	}
+	hasUncaughtExceptionCaptureCallback() {
+		throw /* @__PURE__ */ createNotImplementedError("process.hasUncaughtExceptionCaptureCallback");
+	}
+	initgroups() {
+		throw /* @__PURE__ */ createNotImplementedError("process.initgroups");
+	}
+	openStdin() {
+		throw /* @__PURE__ */ createNotImplementedError("process.openStdin");
+	}
+	assert() {
+		throw /* @__PURE__ */ createNotImplementedError("process.assert");
+	}
+	binding() {
+		throw /* @__PURE__ */ createNotImplementedError("process.binding");
+	}
+	permission = { has: /* @__PURE__ */ notImplemented("process.permission.has") };
+	report = {
+		directory: "",
+		filename: "",
+		signal: "SIGUSR2",
+		compact: false,
+		reportOnFatalError: false,
+		reportOnSignal: false,
+		reportOnUncaughtException: false,
+		getReport: /* @__PURE__ */ notImplemented("process.report.getReport"),
+		writeReport: /* @__PURE__ */ notImplemented("process.report.writeReport")
+	};
+	finalization = {
+		register: /* @__PURE__ */ notImplemented("process.finalization.register"),
+		unregister: /* @__PURE__ */ notImplemented("process.finalization.unregister"),
+		registerBeforeExit: /* @__PURE__ */ notImplemented("process.finalization.registerBeforeExit")
+	};
+	memoryUsage = Object.assign(() => ({
+		arrayBuffers: 0,
+		rss: 0,
+		external: 0,
+		heapTotal: 0,
+		heapUsed: 0
+	}), { rss: () => 0 });
+	mainModule = void 0;
+	domain = void 0;
+	send = void 0;
+	exitCode = void 0;
+	channel = void 0;
+	getegid = void 0;
+	geteuid = void 0;
+	getgid = void 0;
+	getgroups = void 0;
+	getuid = void 0;
+	setegid = void 0;
+	seteuid = void 0;
+	setgid = void 0;
+	setgroups = void 0;
+	setuid = void 0;
+	_events = void 0;
+	_eventsCount = void 0;
+	_exiting = void 0;
+	_maxListeners = void 0;
+	_debugEnd = void 0;
+	_debugProcess = void 0;
+	_fatalException = void 0;
+	_getActiveHandles = void 0;
+	_getActiveRequests = void 0;
+	_kill = void 0;
+	_preload_modules = void 0;
+	_rawDebug = void 0;
+	_startProfilerIdleNotifier = void 0;
+	_stopProfilerIdleNotifier = void 0;
+	_tickCallback = void 0;
+	_disconnect = void 0;
+	_handleQueue = void 0;
+	_pendingMessage = void 0;
+	_channel = void 0;
+	_send = void 0;
+	_linkedBinding = void 0;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/process/env.mjs
+const _envShim = Object.create(null);
+const originalProcess = globalThis["process"];
+const _getEnv = (useShim) => globalThis.__env__ || originalProcess?.env || (useShim ? _envShim : globalThis);
+const env$2 = /* @__PURE__ */ new Proxy(_envShim, {
+	get(_, prop) {
+		return _getEnv()[prop] ?? _envShim[prop];
+	},
+	has(_, prop) {
+		return prop in _getEnv() || prop in _envShim;
+	},
+	set(_, prop, value) {
+		const env = _getEnv(true);
+		env[prop] = value;
+		return true;
+	},
+	deleteProperty(_, prop) {
+		const env = _getEnv(true);
+		delete env[prop];
+		return true;
+	},
+	ownKeys() {
+		const env = _getEnv();
+		return Object.keys(env);
+	},
+	getOwnPropertyDescriptor(_, prop) {
+		const env = _getEnv();
+		if (prop in env) return {
+			value: env[prop],
+			writable: true,
+			enumerable: true,
+			configurable: true
+		};
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/process/hrtime.mjs
+const hrtime$2 = /* @__PURE__ */ Object.assign(function hrtime(startTime) {
+	const now = Date.now();
+	const seconds = Math.trunc(now / 1e3);
+	const nanos = now % 1e3 * 1e6;
+	if (startTime) {
+		let diffSeconds = seconds - startTime[0];
+		let diffNanos = nanos - startTime[0];
+		if (diffNanos < 0) {
+			diffSeconds = diffSeconds - 1;
+			diffNanos = 1e9 + diffNanos;
+		}
+		return [diffSeconds, diffNanos];
+	}
+	return [seconds, nanos];
+}, { bigint: function bigint() {
+	return BigInt(Date.now() * 1e6);
+} });
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/process/nexttick.mjs
+const nextTick$2 = globalThis.queueMicrotask ? (cb, ...args) => {
+	globalThis.queueMicrotask(cb.bind(void 0, ...args));
+} : /* @__PURE__ */ createNextTickWithTimeout();
+function createNextTickWithTimeout() {
+	let queue = [];
+	let draining = false;
+	let currentQueue;
+	let queueIndex = -1;
+	function cleanUpNextTick() {
+		if (!draining || !currentQueue) return;
+		draining = false;
+		if (currentQueue.length > 0) queue = [...currentQueue, ...queue];
+		else queueIndex = -1;
+		if (queue.length > 0) drainQueue();
+	}
+	function drainQueue() {
+		if (draining) return;
+		const timeout = setTimeout(cleanUpNextTick);
+		draining = true;
+		let len = queue.length;
+		while (len) {
+			currentQueue = queue;
+			queue = [];
+			while (++queueIndex < len) if (currentQueue) currentQueue[queueIndex]();
+			queueIndex = -1;
+			len = queue.length;
+		}
+		currentQueue = void 0;
+		draining = false;
+		clearTimeout(timeout);
+	}
+	const nextTick = (cb, ...args) => {
+		queue.push(cb.bind(void 0, ...args));
+		if (queue.length === 1 && !draining) setTimeout(drainQueue);
+	};
+	return nextTick;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/process.mjs
+const unenvProcess = new Process({
+	env: env$2,
+	hrtime: hrtime$2,
+	nextTick: nextTick$2
+});
+const { abort: abort$1, addListener: addListener$1, allowedNodeEnvironmentFlags: allowedNodeEnvironmentFlags$1, hasUncaughtExceptionCaptureCallback: hasUncaughtExceptionCaptureCallback$1, setUncaughtExceptionCaptureCallback: setUncaughtExceptionCaptureCallback$1, loadEnvFile: loadEnvFile$1, sourceMapsEnabled: sourceMapsEnabled$1, arch: arch$1, argv: argv$1, argv0: argv0$1, chdir: chdir$1, config: config$1, connected: connected$1, constrainedMemory: constrainedMemory$1, availableMemory: availableMemory$1, cpuUsage: cpuUsage$1, cwd: cwd$1, debugPort: debugPort$1, dlopen: dlopen$1, disconnect: disconnect$1, emit: emit$1, emitWarning: emitWarning$1, env: env$1, eventNames: eventNames$1, execArgv: execArgv$1, execPath: execPath$1, exit: exit$1, finalization: finalization$1, features: features$1, getBuiltinModule: getBuiltinModule$1, getActiveResourcesInfo: getActiveResourcesInfo$1, getMaxListeners: getMaxListeners$1, hrtime: hrtime$1, kill: kill$1, listeners: listeners$1, listenerCount: listenerCount$1, memoryUsage: memoryUsage$1, nextTick: nextTick$1, on: on$1, off: off$1, once: once$1, pid: pid$1, platform: platform$1, ppid: ppid$1, prependListener: prependListener$1, prependOnceListener: prependOnceListener$1, rawListeners: rawListeners$1, release: release$1, removeAllListeners: removeAllListeners$1, removeListener: removeListener$1, report: report$1, resourceUsage: resourceUsage$1, setMaxListeners: setMaxListeners$1, setSourceMapsEnabled: setSourceMapsEnabled$1, stderr: stderr$1, stdin: stdin$1, stdout: stdout$1, title: title$1, umask: umask$1, uptime: uptime$1, version: version$1, versions: versions$1, domain: domain$1, initgroups: initgroups$1, moduleLoadList: moduleLoadList$1, reallyExit: reallyExit$1, openStdin: openStdin$1, assert: assert$1, binding: binding$1, send: send$1, exitCode: exitCode$1, channel: channel$1, getegid: getegid$1, geteuid: geteuid$1, getgid: getgid$1, getgroups: getgroups$1, getuid: getuid$1, setegid: setegid$1, seteuid: seteuid$1, setgid: setgid$1, setgroups: setgroups$1, setuid: setuid$1, permission: permission$1, mainModule: mainModule$1, ref: ref$1, unref: unref$1, _events: _events$1, _eventsCount: _eventsCount$1, _exiting: _exiting$1, _maxListeners: _maxListeners$1, _debugEnd: _debugEnd$1, _debugProcess: _debugProcess$1, _fatalException: _fatalException$1, _getActiveHandles: _getActiveHandles$1, _getActiveRequests: _getActiveRequests$1, _kill: _kill$1, _preload_modules: _preload_modules$1, _rawDebug: _rawDebug$1, _startProfilerIdleNotifier: _startProfilerIdleNotifier$1, _stopProfilerIdleNotifier: _stopProfilerIdleNotifier$1, _tickCallback: _tickCallback$1, _disconnect: _disconnect$1, _handleQueue: _handleQueue$1, _pendingMessage: _pendingMessage$1, _channel: _channel$1, _send: _send$1, _linkedBinding: _linkedBinding$1 } = unenvProcess;
+//#endregion
+//#region src/node/process.ts
+const process = globalThis.process ??= { env: {} };
+const fallback = unenvProcess;
+var process_default = new Proxy(process, {
+	get: (target, key) => target[key] ?? fallback[key],
+	has: (target, key) => key in target || key in fallback
+});
+const abort = process.abort ?? unenvProcess.abort;
+const addListener = process.addListener ?? unenvProcess.addListener;
+const allowedNodeEnvironmentFlags = process.allowedNodeEnvironmentFlags ?? unenvProcess.allowedNodeEnvironmentFlags;
+const hasUncaughtExceptionCaptureCallback = process.hasUncaughtExceptionCaptureCallback ?? unenvProcess.hasUncaughtExceptionCaptureCallback;
+const setUncaughtExceptionCaptureCallback = process.setUncaughtExceptionCaptureCallback ?? unenvProcess.setUncaughtExceptionCaptureCallback;
+const loadEnvFile = process.loadEnvFile ?? unenvProcess.loadEnvFile;
+const sourceMapsEnabled = process.sourceMapsEnabled ?? unenvProcess.sourceMapsEnabled;
+const arch = process.arch ?? unenvProcess.arch;
+const argv = process.argv ?? unenvProcess.argv;
+const argv0 = process.argv0 ?? unenvProcess.argv0;
+const chdir = process.chdir ?? unenvProcess.chdir;
+const config = process.config ?? unenvProcess.config;
+const connected = process.connected ?? unenvProcess.connected;
+const constrainedMemory = process.constrainedMemory ?? unenvProcess.constrainedMemory;
+const availableMemory = process.availableMemory ?? unenvProcess.availableMemory;
+const cpuUsage = process.cpuUsage ?? unenvProcess.cpuUsage;
+const cwd = process.cwd ?? unenvProcess.cwd;
+const debugPort = process.debugPort ?? unenvProcess.debugPort;
+const dlopen = process.dlopen ?? unenvProcess.dlopen;
+const disconnect = process.disconnect ?? unenvProcess.disconnect;
+const emit = process.emit ?? unenvProcess.emit;
+const emitWarning = process.emitWarning ?? unenvProcess.emitWarning;
+const env = process.env ?? unenvProcess.env;
+const eventNames = process.eventNames ?? unenvProcess.eventNames;
+const execArgv = process.execArgv ?? unenvProcess.execArgv;
+const execPath = process.execPath ?? unenvProcess.execPath;
+const exit = process.exit ?? unenvProcess.exit;
+const finalization = process.finalization ?? unenvProcess.finalization;
+const features = process.features ?? unenvProcess.features;
+const getBuiltinModule = process.getBuiltinModule ?? unenvProcess.getBuiltinModule;
+const getActiveResourcesInfo = process.getActiveResourcesInfo ?? unenvProcess.getActiveResourcesInfo;
+const getMaxListeners = process.getMaxListeners ?? unenvProcess.getMaxListeners;
+const hrtime = process.hrtime ?? unenvProcess.hrtime;
+const kill = process.kill ?? unenvProcess.kill;
+const listeners = process.listeners ?? unenvProcess.listeners;
+const listenerCount = process.listenerCount ?? unenvProcess.listenerCount;
+const memoryUsage = process.memoryUsage ?? unenvProcess.memoryUsage;
+const nextTick = process.nextTick ?? unenvProcess.nextTick;
+const on = process.on ?? unenvProcess.on;
+const off = process.off ?? unenvProcess.off;
+const once = process.once ?? unenvProcess.once;
+const pid = process.pid ?? unenvProcess.pid;
+const platform = process.platform ?? unenvProcess.platform;
+const ppid = process.ppid ?? unenvProcess.ppid;
+const prependListener = process.prependListener ?? unenvProcess.prependListener;
+const prependOnceListener = process.prependOnceListener ?? unenvProcess.prependOnceListener;
+const rawListeners = process.rawListeners ?? unenvProcess.rawListeners;
+const release = process.release ?? unenvProcess.release;
+const removeAllListeners = process.removeAllListeners ?? unenvProcess.removeAllListeners;
+const removeListener = process.removeListener ?? unenvProcess.removeListener;
+const report = process.report ?? unenvProcess.report;
+const resourceUsage = process.resourceUsage ?? unenvProcess.resourceUsage;
+const setMaxListeners = process.setMaxListeners ?? unenvProcess.setMaxListeners;
+const setSourceMapsEnabled = process.setSourceMapsEnabled ?? unenvProcess.setSourceMapsEnabled;
+const stderr = process.stderr ?? unenvProcess.stderr;
+const stdin = process.stdin ?? unenvProcess.stdin;
+const stdout = process.stdout ?? unenvProcess.stdout;
+const title = process.title ?? unenvProcess.title;
+const umask = process.umask ?? unenvProcess.umask;
+const uptime = process.uptime ?? unenvProcess.uptime;
+const version = process.version ?? unenvProcess.version;
+const versions = process.versions ?? unenvProcess.versions;
+const domain = process.domain ?? unenvProcess.domain;
+const initgroups = process.initgroups ?? unenvProcess.initgroups;
+const moduleLoadList = process.moduleLoadList ?? unenvProcess.moduleLoadList;
+const reallyExit = process.reallyExit ?? unenvProcess.reallyExit;
+const openStdin = process.openStdin ?? unenvProcess.openStdin;
+const assert = process.assert ?? unenvProcess.assert;
+const binding = process.binding ?? unenvProcess.binding;
+const send = process.send ?? unenvProcess.send;
+const exitCode = process.exitCode ?? unenvProcess.exitCode;
+const channel = process.channel ?? unenvProcess.channel;
+const getegid = process.getegid ?? unenvProcess.getegid;
+const geteuid = process.geteuid ?? unenvProcess.geteuid;
+const getgid = process.getgid ?? unenvProcess.getgid;
+const getgroups = process.getgroups ?? unenvProcess.getgroups;
+const getuid = process.getuid ?? unenvProcess.getuid;
+const setegid = process.setegid ?? unenvProcess.setegid;
+const seteuid = process.seteuid ?? unenvProcess.seteuid;
+const setgid = process.setgid ?? unenvProcess.setgid;
+const setgroups = process.setgroups ?? unenvProcess.setgroups;
+const setuid = process.setuid ?? unenvProcess.setuid;
+const permission = process.permission ?? unenvProcess.permission;
+const mainModule = process.mainModule ?? unenvProcess.mainModule;
+const ref = process.ref ?? unenvProcess.ref;
+const unref = process.unref ?? unenvProcess.unref;
+const _events = process._events ?? unenvProcess._events;
+const _eventsCount = process._eventsCount ?? unenvProcess._eventsCount;
+const _exiting = process._exiting ?? unenvProcess._exiting;
+const _maxListeners = process._maxListeners ?? unenvProcess._maxListeners;
+const _debugEnd = process._debugEnd ?? unenvProcess._debugEnd;
+const _debugProcess = process._debugProcess ?? unenvProcess._debugProcess;
+const _fatalException = process._fatalException ?? unenvProcess._fatalException;
+const _getActiveHandles = process._getActiveHandles ?? unenvProcess._getActiveHandles;
+const _getActiveRequests = process._getActiveRequests ?? unenvProcess._getActiveRequests;
+const _kill = process._kill ?? unenvProcess._kill;
+const _preload_modules = process._preload_modules ?? unenvProcess._preload_modules;
+const _rawDebug = process._rawDebug ?? unenvProcess._rawDebug;
+const _startProfilerIdleNotifier = process._startProfilerIdleNotifier ?? unenvProcess._startProfilerIdleNotifier;
+const _stopProfilerIdleNotifier = process._stopProfilerIdleNotifier ?? unenvProcess._stopProfilerIdleNotifier;
+const _tickCallback = process._tickCallback ?? unenvProcess._tickCallback;
+const _disconnect = process._disconnect ?? unenvProcess._disconnect;
+const _handleQueue = process._handleQueue ?? unenvProcess._handleQueue;
+const _pendingMessage = process._pendingMessage ?? unenvProcess._pendingMessage;
+const _channel = process._channel ?? unenvProcess._channel;
+const _send = process._send ?? unenvProcess._send;
+const _linkedBinding = process._linkedBinding ?? unenvProcess._linkedBinding;
+//#endregion
+export { _channel, _debugEnd, _debugProcess, _disconnect, _events, _eventsCount, _exiting, _fatalException, _getActiveHandles, _getActiveRequests, _handleQueue, _kill, _linkedBinding, _maxListeners, _pendingMessage, _preload_modules, _rawDebug, _send, _startProfilerIdleNotifier, _stopProfilerIdleNotifier, _tickCallback, abort, addListener, allowedNodeEnvironmentFlags, arch, argv, argv0, assert, availableMemory, binding, channel, chdir, config, connected, constrainedMemory, cpuUsage, cwd, debugPort, process_default as default, disconnect, dlopen, domain, emit, emitWarning, env, eventNames, execArgv, execPath, exit, exitCode, features, finalization, getActiveResourcesInfo, getBuiltinModule, getMaxListeners, getegid, geteuid, getgid, getgroups, getuid, hasUncaughtExceptionCaptureCallback, hrtime, initgroups, kill, listenerCount, listeners, loadEnvFile, mainModule, memoryUsage, moduleLoadList, nextTick, off, on, once, openStdin, permission, pid, platform, ppid, prependListener, prependOnceListener, rawListeners, reallyExit, ref, release, removeAllListeners, removeListener, report, resourceUsage, send, setMaxListeners, setSourceMapsEnabled, setUncaughtExceptionCaptureCallback, setegid, seteuid, setgid, setgroups, setuid, sourceMapsEnabled, stderr, stdin, stdout, title, umask, unref, uptime, version, versions };

package/dist/node/punycode.js

@@ -0,0 +1,178 @@
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/internal/punycode/punycode.mjs
+const maxInt = 2147483647;
+const base = 36;
+const tMin = 1;
+const tMax = 26;
+const skew = 38;
+const damp = 700;
+const initialBias = 72;
+const initialN = 128;
+const delimiter = "-";
+const regexPunycode = /^xn--/;
+const regexNonASCII = /[^\0-\u007F]/;
+const regexSeparators = /[.\u3002\uFF0E\uFF61]/g;
+const errors = {
+	overflow: "Overflow: input needs wider integers to process",
+	"not-basic": "Illegal input >= 0x80 (not a basic code point)",
+	"invalid-input": "Invalid input"
+};
+const baseMinusTMin = 35;
+const floor = Math.floor;
+const stringFromCharCode = String.fromCharCode;
+function error(type) {
+	throw new RangeError(errors[type]);
+}
+function map(array, callback) {
+	const result = [];
+	let length = array.length;
+	while (length--) result[length] = callback(array[length]);
+	return result;
+}
+function mapDomain(domain, callback) {
+	const parts = domain.split("@");
+	let result = "";
+	if (parts.length > 1) {
+		result = parts[0] + "@";
+		domain = parts[1];
+	}
+	domain = domain.replace(regexSeparators, ".");
+	const encoded = map(domain.split("."), callback).join(".");
+	return result + encoded;
+}
+function ucs2decode(string) {
+	const output = [];
+	let counter = 0;
+	const length = string.length;
+	while (counter < length) {
+		const value = string.charCodeAt(counter++);
+		if (value >= 55296 && value <= 56319 && counter < length) {
+			const extra = string.charCodeAt(counter++);
+			if ((extra & 64512) == 56320) output.push(((value & 1023) << 10) + (extra & 1023) + 65536);
+			else {
+				output.push(value);
+				counter--;
+			}
+		} else output.push(value);
+	}
+	return output;
+}
+const ucs2encode = (codePoints) => String.fromCodePoint(...codePoints);
+const basicToDigit = function(codePoint) {
+	if (codePoint >= 48 && codePoint < 58) return 26 + (codePoint - 48);
+	if (codePoint >= 65 && codePoint < 91) return codePoint - 65;
+	if (codePoint >= 97 && codePoint < 123) return codePoint - 97;
+	return base;
+};
+const digitToBasic = function(digit, flag) {
+	return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
+};
+const adapt = function(delta, numPoints, firstTime) {
+	let k = 0;
+	delta = firstTime ? floor(delta / damp) : delta >> 1;
+	delta += floor(delta / numPoints);
+	for (; delta > 455; k += base) delta = floor(delta / baseMinusTMin);
+	return floor(k + 36 * delta / (delta + skew));
+};
+const decode = function(input) {
+	const output = [];
+	const inputLength = input.length;
+	let i = 0;
+	let n = initialN;
+	let bias = initialBias;
+	let basic = input.lastIndexOf(delimiter);
+	if (basic < 0) basic = 0;
+	for (let j = 0; j < basic; ++j) {
+		if (input.charCodeAt(j) >= 128) error("not-basic");
+		output.push(input.charCodeAt(j));
+	}
+	for (let index = basic > 0 ? basic + 1 : 0; index < inputLength;) {
+		const oldi = i;
+		for (let w = 1, k = base;; k += base) {
+			if (index >= inputLength) error("invalid-input");
+			const digit = basicToDigit(input.charCodeAt(index++));
+			if (digit >= base) error("invalid-input");
+			if (digit > floor((maxInt - i) / w)) error("overflow");
+			i += digit * w;
+			const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
+			if (digit < t) break;
+			const baseMinusT = base - t;
+			if (w > floor(maxInt / baseMinusT)) error("overflow");
+			w *= baseMinusT;
+		}
+		const out = output.length + 1;
+		bias = adapt(i - oldi, out, oldi === 0);
+		if (floor(i / out) > maxInt - n) error("overflow");
+		n += floor(i / out);
+		i %= out;
+		output.splice(i++, 0, n);
+	}
+	return String.fromCodePoint(...output);
+};
+const encode = function(_input) {
+	const output = [];
+	const input = ucs2decode(_input);
+	const inputLength = input.length;
+	let n = initialN;
+	let delta = 0;
+	let bias = initialBias;
+	for (const currentValue of input) if (currentValue < 128) output.push(stringFromCharCode(currentValue));
+	const basicLength = output.length;
+	let handledCPCount = basicLength;
+	if (basicLength) output.push(delimiter);
+	while (handledCPCount < inputLength) {
+		let m = maxInt;
+		for (const currentValue of input) if (currentValue >= n && currentValue < m) m = currentValue;
+		const handledCPCountPlusOne = handledCPCount + 1;
+		if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) error("overflow");
+		delta += (m - n) * handledCPCountPlusOne;
+		n = m;
+		for (const currentValue of input) {
+			if (currentValue < n && ++delta > maxInt) error("overflow");
+			if (currentValue === n) {
+				let q = delta;
+				for (let k = base;; k += base) {
+					const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
+					if (q < t) break;
+					const qMinusT = q - t;
+					const baseMinusT = base - t;
+					output.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)));
+					q = floor(qMinusT / baseMinusT);
+				}
+				output.push(stringFromCharCode(digitToBasic(q, 0)));
+				bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);
+				delta = 0;
+				++handledCPCount;
+			}
+		}
+		++delta;
+		++n;
+	}
+	return output.join("");
+};
+const toUnicode = function(input) {
+	return mapDomain(input, function(string) {
+		return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;
+	});
+};
+const toASCII = function(input) {
+	return mapDomain(input, function(string) {
+		return regexNonASCII.test(string) ? "xn--" + encode(string) : string;
+	});
+};
+const version = "2.3.1";
+const ucs2 = {
+	decode: ucs2decode,
+	encode: ucs2encode
+};
+//#endregion
+//#region ../../node_modules/.pnpm/unenv@2.0.0-rc.24/node_modules/unenv/dist/runtime/node/punycode.mjs
+var punycode_default = {
+	version,
+	ucs2,
+	decode,
+	encode,
+	toASCII,
+	toUnicode
+};
+//#endregion
+export { decode, punycode_default as default, encode, toASCII, toUnicode, ucs2, version };