Website Structure

Frontend-Learner/node_modules/unenv/dist/runtime/node/internal/process/env.d.mts

@@ -0,0 +1 @@
+export declare const env: NodeJS.Process["env"];

Frontend-Learner/node_modules/unenv/dist/runtime/node/internal/process/env.mjs

@@ -0,0 +1,40 @@
+const _envShim = Object.create(null);
+// Keep a reference to the original process to avoid circular references after polyfilling
+const originalProcess = globalThis["process"];
+const _getEnv = (useShim) => globalThis.__env__ || originalProcess?.env || (useShim ? _envShim : globalThis);
+export const env = /* @__PURE__ */ new Proxy(_envShim, {
+	get(_, prop) {
+		const env = _getEnv();
+		return env[prop] ?? _envShim[prop];
+	},
+	has(_, prop) {
+		const env = _getEnv();
+		return prop in env || 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
+			};
+		}
+		return undefined;
+	}
+});

Frontend-Learner/node_modules/unenv/dist/runtime/node/internal/process/hrtime.d.mts

@@ -0,0 +1,2 @@
+// https://nodejs.org/api/process.html#processhrtime
+export declare const hrtime: NodeJS.Process["hrtime"];

Frontend-Learner/node_modules/unenv/dist/runtime/node/internal/process/hrtime.mjs

@@ -0,0 +1,21 @@
+// https://nodejs.org/api/process.html#processhrtime
+export const hrtime = /* @__PURE__ */ Object.assign(function hrtime(startTime) {
+	const now = Date.now();
+	// millis to seconds
+	const seconds = Math.trunc(now / 1e3);
+	// convert millis to nanos
+	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() {
+	// Convert milliseconds to nanoseconds
+	return BigInt(Date.now() * 1e6);
+} });

Frontend-Learner/node_modules/unenv/dist/runtime/node/internal/process/nexttick.d.mts

@@ -0,0 +1,3 @@
+// https://developer.mozilla.org/en-US/docs/Web/API/queueMicrotask
+// https://nodejs.org/api/process.html#when-to-use-queuemicrotask-vs-processnexttick
+export declare const nextTick: NodeJS.Process["nextTick"];

Frontend-Learner/node_modules/unenv/dist/runtime/node/internal/process/nexttick.mjs

@@ -0,0 +1,55 @@
+// https://developer.mozilla.org/en-US/docs/Web/API/queueMicrotask
+// https://nodejs.org/api/process.html#when-to-use-queuemicrotask-vs-processnexttick
+export const nextTick = globalThis.queueMicrotask ? (cb, ...args) => {
+	globalThis.queueMicrotask(cb.bind(undefined, ...args));
+} : /* @__PURE__ */ createNextTickWithTimeout();
+// Fallback for runtimes not implementing queueMicrotask
+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 = undefined;
+		draining = false;
+		clearTimeout(timeout);
+	}
+	const nextTick = (cb, ...args) => {
+		queue.push(cb.bind(undefined, ...args));
+		if (queue.length === 1 && !draining) {
+			setTimeout(drainQueue);
+		}
+	};
+	return nextTick;
+}

Frontend-Learner/node_modules/unenv/dist/runtime/node/internal/process/node-version.d.mts

@@ -0,0 +1,2 @@
+// Extracted from .nvmrc
+export declare const NODE_VERSION = "22.14.0";

Frontend-Learner/node_modules/unenv/dist/runtime/node/internal/process/node-version.mjs

@@ -0,0 +1,2 @@
+// Extracted from .nvmrc
+export const NODE_VERSION = "22.14.0";

Frontend-Learner/node_modules/unenv/dist/runtime/node/internal/process/process.d.mts

@@ -0,0 +1,113 @@
+import { EventEmitter } from "node:events";
+export declare class Process extends EventEmitter implements NodeJS.Process {
+	#private;
+	env: NodeJS.ProcessEnv;
+	hrtime: NodeJS.Process["hrtime"];
+	nextTick: NodeJS.Process["nextTick"];
+	constructor(impl: {
+		env: NodeJS.ProcessEnv;
+		hrtime: NodeJS.Process["hrtime"];
+		nextTick: NodeJS.Process["nextTick"];
+	});
+	// --- event emitter ---
+	emitWarning(warning: unknown, type?: unknown, code?: unknown): void;
+	emit(...args: any[]): any;
+	listeners(eventName: string | symbol): any;
+	get stdin();
+	get stdout();
+	get stderr();
+	chdir(cwd: string): void;
+	cwd(): string;
+	// --- dummy props and getters ---
+	arch: NodeJS.Architecture;
+	platform: NodeJS.Platform;
+	argv: string[];
+	argv0: string;
+	execArgv: string[];
+	execPath: string;
+	title: string;
+	pid: number;
+	ppid: number;
+	get version(): string;
+	get versions(): NodeJS.Process["versions"];
+	get allowedNodeEnvironmentFlags();
+	get sourceMapsEnabled(): boolean;
+	get debugPort(): number;
+	get throwDeprecation(): boolean;
+	get traceDeprecation(): boolean;
+	get features(): NodeJS.Process["features"];
+	get release(): NodeJS.Process["release"];
+	get connected(): boolean;
+	get config(): NodeJS.Process["config"];
+	get moduleLoadList(): unknown;
+	constrainedMemory(): number;
+	availableMemory(): number;
+	uptime(): number;
+	resourceUsage(): NodeJS.ResourceUsage;
+	// --- noop methods ---
+	ref();
+	unref();
+	// --- unimplemented methods ---
+	umask(): number;
+	getBuiltinModule(): any;
+	getActiveResourcesInfo(): string[];
+	exit(): never;
+	reallyExit(): never;
+	kill(): true;
+	abort(): never;
+	dlopen(): void;
+	setSourceMapsEnabled(): void;
+	loadEnvFile(): void;
+	disconnect(): void;
+	cpuUsage(): NodeJS.CpuUsage;
+	setUncaughtExceptionCaptureCallback(): void;
+	hasUncaughtExceptionCaptureCallback(): boolean;
+	initgroups(): void;
+	openStdin(): NodeJS.Socket;
+	assert();
+	binding();
+	// --- attached interfaces ---
+	permission: NodeJS.ProcessPermission;
+	report: NodeJS.ProcessReport;
+	finalization: NodeJS.Process["finalization"];
+	memoryUsage;
+	// --- undefined props ---
+	mainModule?: NodeJS.Module | undefined;
+	domain: undefined;
+	// optional
+	send: undefined;
+	exitCode: undefined;
+	channel: undefined;
+	getegid: undefined;
+	geteuid: undefined;
+	getgid: undefined;
+	getgroups: undefined;
+	getuid: undefined;
+	setegid: undefined;
+	seteuid: undefined;
+	setgid: undefined;
+	setgroups: undefined;
+	setuid: undefined;
+	// internals
+	_events: undefined;
+	_eventsCount: undefined;
+	_exiting: undefined;
+	_maxListeners: undefined;
+	_debugEnd: undefined;
+	_debugProcess: undefined;
+	_fatalException: undefined;
+	_getActiveHandles: undefined;
+	_getActiveRequests: undefined;
+	_kill: undefined;
+	_preload_modules: undefined;
+	_rawDebug: undefined;
+	_startProfilerIdleNotifier: undefined;
+	_stopProfilerIdleNotifier: undefined;
+	_tickCallback: undefined;
+	_disconnect: undefined;
+	_handleQueue: undefined;
+	_pendingMessage: undefined;
+	_channel: undefined;
+	_send: undefined;
+	_linkedBinding: undefined;
+}

Frontend-Learner/node_modules/unenv/dist/runtime/node/internal/process/process.mjs

@@ -0,0 +1,238 @@
+import { EventEmitter } from "node:events";
+import { ReadStream, WriteStream } from "node:tty";
+import { notImplemented, createNotImplementedError } from "../../../_internal/utils.mjs";
+// node-version.ts is generated at build time
+import { NODE_VERSION } from "./node-version.mjs";
+export 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);
+			}
+		}
+	}
+	// --- event emitter ---
+	emitWarning(warning, type, code) {
+		console.warn(`${code ? `[${code}] ` : ""}${type ? `${type}: ` : ""}${warning}`);
+	}
+	emit(...args) {
+		// @ts-ignore
+		return super.emit(...args);
+	}
+	listeners(eventName) {
+		return super.listeners(eventName);
+	}
+	// --- stdio (lazy initializers) ---
+	#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 ---
+	#cwd = "/";
+	chdir(cwd) {
+		this.#cwd = cwd;
+	}
+	cwd() {
+		return this.#cwd;
+	}
+	// --- dummy props and getters ---
+	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 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 {};
+	}
+	// --- noop methods ---
+	ref() {
+		// noop
+	}
+	unref() {
+		// noop
+	}
+	// --- unimplemented methods ---
+	umask() {
+		throw createNotImplementedError("process.umask");
+	}
+	getBuiltinModule() {
+		return undefined;
+	}
+	getActiveResourcesInfo() {
+		throw createNotImplementedError("process.getActiveResourcesInfo");
+	}
+	exit() {
+		throw createNotImplementedError("process.exit");
+	}
+	reallyExit() {
+		throw createNotImplementedError("process.reallyExit");
+	}
+	kill() {
+		throw createNotImplementedError("process.kill");
+	}
+	abort() {
+		throw createNotImplementedError("process.abort");
+	}
+	dlopen() {
+		throw createNotImplementedError("process.dlopen");
+	}
+	setSourceMapsEnabled() {
+		throw createNotImplementedError("process.setSourceMapsEnabled");
+	}
+	loadEnvFile() {
+		throw createNotImplementedError("process.loadEnvFile");
+	}
+	disconnect() {
+		throw createNotImplementedError("process.disconnect");
+	}
+	cpuUsage() {
+		throw createNotImplementedError("process.cpuUsage");
+	}
+	setUncaughtExceptionCaptureCallback() {
+		throw createNotImplementedError("process.setUncaughtExceptionCaptureCallback");
+	}
+	hasUncaughtExceptionCaptureCallback() {
+		throw createNotImplementedError("process.hasUncaughtExceptionCaptureCallback");
+	}
+	initgroups() {
+		throw createNotImplementedError("process.initgroups");
+	}
+	openStdin() {
+		throw createNotImplementedError("process.openStdin");
+	}
+	assert() {
+		throw createNotImplementedError("process.assert");
+	}
+	binding() {
+		throw createNotImplementedError("process.binding");
+	}
+	// --- attached interfaces ---
+	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 });
+	// --- undefined props ---
+	mainModule = undefined;
+	domain = undefined;
+	// optional
+	send = undefined;
+	exitCode = undefined;
+	channel = undefined;
+	getegid = undefined;
+	geteuid = undefined;
+	getgid = undefined;
+	getgroups = undefined;
+	getuid = undefined;
+	setegid = undefined;
+	seteuid = undefined;
+	setgid = undefined;
+	setgroups = undefined;
+	setuid = undefined;
+	// internals
+	_events = undefined;
+	_eventsCount = undefined;
+	_exiting = undefined;
+	_maxListeners = undefined;
+	_debugEnd = undefined;
+	_debugProcess = undefined;
+	_fatalException = undefined;
+	_getActiveHandles = undefined;
+	_getActiveRequests = undefined;
+	_kill = undefined;
+	_preload_modules = undefined;
+	_rawDebug = undefined;
+	_startProfilerIdleNotifier = undefined;
+	_stopProfilerIdleNotifier = undefined;
+	_tickCallback = undefined;
+	_disconnect = undefined;
+	_handleQueue = undefined;
+	_pendingMessage = undefined;
+	_channel = undefined;
+	_send = undefined;
+	_linkedBinding = undefined;
+}