Add files using upload-large-folder tool

worker/node_modules/unenv/dist/index.mjs

@@ -0,0 +1,338 @@
+import { builtinModules } from "node:module";
+import { createResolver } from "exsolve";
+
+//#region node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+	if (!input) return input;
+	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const normalize = function(path) {
+	if (path.length === 0) return ".";
+	path = normalizeWindowsPath(path);
+	const isUNCPath = path.match(_UNC_REGEX);
+	const isPathAbsolute = isAbsolute(path);
+	const trailingSeparator = path[path.length - 1] === "/";
+	path = normalizeString(path, !isPathAbsolute);
+	if (path.length === 0) {
+		if (isPathAbsolute) return "/";
+		return trailingSeparator ? "./" : ".";
+	}
+	if (trailingSeparator) path += "/";
+	if (_DRIVE_LETTER_RE.test(path)) path += "/";
+	if (isUNCPath) {
+		if (!isPathAbsolute) return `//./${path}`;
+		return `//${path}`;
+	}
+	return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+const join = function(...segments) {
+	let path = "";
+	for (const seg of segments) {
+		if (!seg) continue;
+		if (path.length > 0) {
+			const pathTrailing = path[path.length - 1] === "/";
+			const segLeading = seg[0] === "/";
+			const both = pathTrailing && segLeading;
+			if (both) path += seg.slice(1);
+			else path += pathTrailing || segLeading ? seg : `/${seg}`;
+		} else path += seg;
+	}
+	return normalize(path);
+};
+function normalizeString(path, allowAboveRoot) {
+	let res = "";
+	let lastSegmentLength = 0;
+	let lastSlash = -1;
+	let dots = 0;
+	let char = null;
+	for (let index = 0; index <= path.length; ++index) {
+		if (index < path.length) char = path[index];
+		else if (char === "/") break;
+		else char = "/";
+		if (char === "/") {
+			if (lastSlash === index - 1 || dots === 1);
+			else if (dots === 2) {
+				if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+					if (res.length > 2) {
+						const lastSlashIndex = res.lastIndexOf("/");
+						if (lastSlashIndex === -1) {
+							res = "";
+							lastSegmentLength = 0;
+						} else {
+							res = res.slice(0, lastSlashIndex);
+							lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+						}
+						lastSlash = index;
+						dots = 0;
+						continue;
+					} else if (res.length > 0) {
+						res = "";
+						lastSegmentLength = 0;
+						lastSlash = index;
+						dots = 0;
+						continue;
+					}
+				}
+				if (allowAboveRoot) {
+					res += res.length > 0 ? "/.." : "..";
+					lastSegmentLength = 2;
+				}
+			} else {
+				if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
+				else res = path.slice(lastSlash + 1, index);
+				lastSegmentLength = index - lastSlash - 1;
+			}
+			lastSlash = index;
+			dots = 0;
+		} else if (char === "." && dots !== -1) ++dots;
+		else dots = -1;
+	}
+	return res;
+}
+const isAbsolute = function(p) {
+	return _IS_ABSOLUTE_RE.test(p);
+};
+
+//#endregion
+//#region node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/utils.mjs
+const pathSeparators = /* @__PURE__ */ new Set([
+	"/",
+	"\\",
+	void 0
+]);
+const normalizedAliasSymbol = Symbol.for("pathe:normalizedAlias");
+function normalizeAliases(_aliases) {
+	if (_aliases[normalizedAliasSymbol]) return _aliases;
+	const aliases = Object.fromEntries(Object.entries(_aliases).sort(([a], [b]) => _compareAliases(a, b)));
+	for (const key in aliases) for (const alias in aliases) {
+		if (alias === key || key.startsWith(alias)) continue;
+		if (aliases[key]?.startsWith(alias) && pathSeparators.has(aliases[key][alias.length])) aliases[key] = aliases[alias] + aliases[key].slice(alias.length);
+	}
+	Object.defineProperty(aliases, normalizedAliasSymbol, {
+		value: true,
+		enumerable: false
+	});
+	return aliases;
+}
+function resolveAlias(path, aliases) {
+	const _path = normalizeWindowsPath(path);
+	aliases = normalizeAliases(aliases);
+	for (const [alias, to] of Object.entries(aliases)) {
+		if (!_path.startsWith(alias)) continue;
+		const _alias = hasTrailingSlash(alias) ? alias.slice(0, -1) : alias;
+		if (hasTrailingSlash(_path[_alias.length])) return join(to, _path.slice(alias.length));
+	}
+	return _path;
+}
+function _compareAliases(a, b) {
+	return b.split("/").length - a.split("/").length;
+}
+function hasTrailingSlash(path = "/") {
+	const lastChar = path[path.length - 1];
+	return lastChar === "/" || lastChar === "\\";
+}
+
+//#endregion
+//#region package.json
+var version = "2.0.0-rc.14";
+
+//#endregion
+//#region src/preset.ts
+const nodeCompatAliases = {
+	_http_agent: "unenv/mock/proxy-cjs",
+	_http_client: "unenv/mock/proxy-cjs",
+	_http_common: "unenv/mock/proxy-cjs",
+	_http_incoming: "unenv/mock/proxy-cjs",
+	_http_outgoing: "unenv/mock/proxy-cjs",
+	_http_server: "unenv/mock/proxy-cjs",
+	_stream_duplex: "unenv/mock/proxy-cjs",
+	_stream_passthrough: "unenv/mock/proxy-cjs",
+	_stream_readable: "unenv/mock/proxy-cjs",
+	_stream_transform: "unenv/mock/proxy-cjs",
+	_stream_wrap: "unenv/mock/proxy-cjs",
+	_stream_writable: "unenv/mock/proxy-cjs",
+	_tls_common: "unenv/mock/proxy-cjs",
+	_tls_wrap: "unenv/mock/proxy-cjs",
+	assert: "unenv/node/assert",
+	"assert/strict": "unenv/node/assert/strict",
+	async_hooks: "unenv/node/async_hooks",
+	buffer: "unenv/node/buffer",
+	child_process: "unenv/node/child_process",
+	cluster: "unenv/node/cluster",
+	console: "unenv/node/console",
+	constants: "unenv/node/constants",
+	crypto: "unenv/node/crypto",
+	dgram: "unenv/node/dgram",
+	diagnostics_channel: "unenv/node/diagnostics_channel",
+	dns: "unenv/node/dns",
+	"dns/promises": "unenv/node/dns/promises",
+	domain: "unenv/node/domain",
+	events: "unenv/node/events",
+	fs: "unenv/node/fs",
+	"fs/promises": "unenv/node/fs/promises",
+	http: "unenv/node/http",
+	http2: "unenv/node/http2",
+	https: "unenv/node/https",
+	inspector: "unenv/node/inspector",
+	"inspector/promises": "unenv/node/inspector/promises",
+	module: "unenv/node/module",
+	net: "unenv/node/net",
+	os: "unenv/node/os",
+	path: "unenv/node/path",
+	"path/posix": "unenv/node/path",
+	"path/win32": "unenv/node/path",
+	perf_hooks: "unenv/node/perf_hooks",
+	process: "unenv/node/process",
+	punycode: "unenv/node/punycode",
+	querystring: "unenv/node/querystring",
+	readline: "unenv/node/readline",
+	"readline/promises": "unenv/node/readline/promises",
+	repl: "unenv/node/repl",
+	stream: "unenv/node/stream",
+	"stream/consumers": "unenv/node/stream/consumers",
+	"stream/promises": "unenv/node/stream/promises",
+	"stream/web": "unenv/node/stream/web",
+	string_decoder: "unenv/node/string_decoder",
+	sys: "unenv/node/util",
+	timers: "unenv/node/timers",
+	"timers/promises": "unenv/node/timers/promises",
+	tls: "unenv/node/tls",
+	trace_events: "unenv/node/trace_events",
+	tty: "unenv/node/tty",
+	url: "unenv/node/url",
+	util: "unenv/node/util",
+	"util/types": "unenv/node/util/types",
+	v8: "unenv/node/v8",
+	vm: "unenv/node/vm",
+	wasi: "unenv/node/wasi",
+	worker_threads: "unenv/node/worker_threads",
+	zlib: "unenv/node/zlib"
+};
+const nodeCompatInjects = {
+	process: "unenv/node/process",
+	global: "unenv/polyfill/globalthis",
+	Buffer: ["node:buffer", "Buffer"],
+	clearImmediate: ["node:timers", "clearImmediate"],
+	setImmediate: ["node:timers", "setImmediate"]
+};
+const npmShims = {
+	"cross-fetch": "unenv/npm/cross-fetch",
+	debug: "unenv/npm/debug",
+	fsevents: "unenv/npm/fsevents",
+	inherits: "unenv/npm/inherits",
+	"node-fetch": "unenv/npm/node-fetch",
+	"node-fetch-native": "unenv/npm/node-fetch",
+	"whatwg-url": "unenv/npm/whatwg-url",
+	"cross-fetch/polyfill": "unenv/mock/empty",
+	"node-fetch-native/polyfill": "unenv/mock/empty",
+	"isomorphic-fetch": "unenv/mock/empty"
+};
+
+//#endregion
+//#region src/env.ts
+const defineEnv = (opts = {}) => {
+	const presets = [];
+	presets.push(unenvPreset(opts));
+	if (opts.presets) presets.push(...opts.presets);
+	if (opts.overrides) presets.push(opts.overrides);
+	if (opts.resolve) {
+		for (const preset of presets) if (preset.meta?.url) resolvePaths(preset, [preset.meta.url], opts);
+	}
+	const env = mergePresets(...presets);
+	if (opts.resolve) resolvePaths(env, presets.map((preset) => preset.meta?.url).filter((v) => v !== undefined), opts);
+	return {
+		env,
+		presets
+	};
+};
+function unenvPreset(opts) {
+	const preset = {
+		meta: {
+			name: "unenv",
+			version,
+			url: import.meta.url
+		},
+		alias: {},
+		inject: {},
+		external: [],
+		polyfill: []
+	};
+	if (opts.nodeCompat !== false) {
+		Object.assign(preset.inject, nodeCompatInjects);
+		Object.assign(preset.alias, { ...Object.fromEntries(Object.entries(nodeCompatAliases).flatMap(([from, to]) => {
+			const aliases = [[from, to], [`node:${from}`, to]];
+			return aliases;
+		})) });
+	}
+	if (opts.npmShims) Object.assign(preset.alias, npmShims);
+	return preset;
+}
+function resolvePaths(env, from, opts = {}) {
+	if (!opts.resolve) return;
+	const { resolveModulePath } = createResolver({ from: [
+		...opts.resolve === true ? [] : opts.resolve.paths || [],
+		...from,
+		import.meta.url,
+		process.cwd() + "/"
+	] });
+	const _resolve = (id) => {
+		if (!id) return id;
+		if (env.alias) id = resolveAlias(id, env.alias);
+		if (id.startsWith("node:")) return id;
+		if (builtinModules.includes(id)) return `node:${id}`;
+		let resolved = resolveModulePath(id, { try: true });
+		if (!resolved && id.startsWith("unenv/")) resolved = resolveModulePath(id.replace("unenv/", "unenv-nightly/"), { try: true });
+		return resolved || id;
+	};
+	for (const alias in env.alias) env.alias[alias] = _resolve(env.alias[alias]);
+	if (env.polyfill) for (let i = 0; i < env.polyfill.length; i++) env.polyfill[i] = _resolve(env.polyfill[i]);
+	for (const global in env.inject) {
+		const inject = env.inject[global];
+		if (Array.isArray(inject)) {
+			const [id, ...path] = inject;
+			env.inject[global] = [_resolve(id), ...path];
+		} else env.inject[global] = _resolve(inject);
+	}
+	return env;
+}
+function mergePresets(...presets) {
+	const env = {
+		alias: {},
+		inject: {},
+		polyfill: [],
+		external: []
+	};
+	for (const preset of presets) {
+		if (preset.alias) {
+			const aliases = Object.keys(preset.alias).sort((a, b) => b.split("/").length - a.split("/").length || b.length - a.length);
+			for (const from of aliases) env.alias[from] = preset.alias[from];
+		}
+		if (preset.inject) for (const [global, globalValue] of Object.entries(preset.inject)) if (Array.isArray(globalValue)) env.inject[global] = globalValue;
+		else if (globalValue === false) delete env.inject[global];
+		else env.inject[global] = globalValue;
+		if (preset.polyfill) env.polyfill.push(...preset.polyfill.filter(Boolean));
+		if (preset.external) env.external.push(...preset.external);
+	}
+	env.polyfill = resolveArray(env.polyfill);
+	env.external = resolveArray(env.external);
+	return env;
+}
+/**
+* - Deduplicates items
+* - Removes nagate items with ! prefix
+*/
+function resolveArray(arr) {
+	const set = new Set(arr);
+	for (const item of arr) if (item.startsWith("!")) {
+		set.delete(item);
+		set.delete(item.slice(1));
+	}
+	return [...set];
+}
+
+//#endregion
+export { defineEnv };

worker/node_modules/unenv/dist/runtime/_internal/types.d.mts

@@ -0,0 +1,5 @@
+export type Callback<E = Error | null | undefined> = (error?: E) => void;
+export type HeadersObject = {
+	[key: string]: string | string[] | undefined
+};
+export type BufferEncoding = any;

worker/node_modules/unenv/dist/runtime/_internal/types.mjs

@@ -0,0 +1 @@
+export {};

worker/node_modules/unenv/dist/runtime/_internal/utils.d.mts

@@ -0,0 +1,14 @@
+import type { HeadersObject } from "./types.mjs";
+/*@__NO_SIDE_EFFECTS__*/ export declare function rawHeaders(headers: HeadersObject);
+type Fn = (...args: any[]) => any;
+/*@__NO_SIDE_EFFECTS__*/ export declare function mergeFns(...functions: Fn[]): unknown;
+/*@__NO_SIDE_EFFECTS__*/ export declare function createNotImplementedError(name: string);
+/*@__NO_SIDE_EFFECTS__*/ export declare function notImplemented<Fn extends (...args: any) => any>(name: string): Fn;
+export interface Promisifiable {
+	(): any;
+	native: Promisifiable;
+	__promisify__: () => Promise<any>;
+}
+/*@__NO_SIDE_EFFECTS__*/ export declare function notImplementedAsync(name: string): Promisifiable;
+/*@__NO_SIDE_EFFECTS__*/ export declare function notImplementedClass<T = unknown>(name: string): T;
+export {};

worker/node_modules/unenv/dist/runtime/_internal/utils.mjs

@@ -0,0 +1,43 @@
+/*@__NO_SIDE_EFFECTS__*/ export function rawHeaders(headers) {
+	const rawHeaders = [];
+	for (const key in headers) {
+		if (Array.isArray(headers[key])) {
+			for (const h of headers[key]) {
+				rawHeaders.push(key, h);
+			}
+		} else {
+			rawHeaders.push(key, headers[key]);
+		}
+	}
+	return rawHeaders;
+}
+/*@__NO_SIDE_EFFECTS__*/ export function mergeFns(...functions) {
+	return function(...args) {
+		for (const fn of functions) {
+			fn(...args);
+		}
+	};
+}
+/*@__NO_SIDE_EFFECTS__*/ export function createNotImplementedError(name) {
+	return new Error(`[unenv] ${name} is not implemented yet!`);
+}
+/*@__NO_SIDE_EFFECTS__*/ export function notImplemented(name) {
+	const fn = () => {
+		throw createNotImplementedError(name);
+	};
+	return Object.assign(fn, { __unenv__: true });
+}
+/*@__NO_SIDE_EFFECTS__*/ export function notImplementedAsync(name) {
+	const fn = notImplemented(name);
+	fn.__promisify__ = () => notImplemented(name + ".__promisify__");
+	fn.native = fn;
+	return fn;
+}
+/*@__NO_SIDE_EFFECTS__*/ export function notImplementedClass(name) {
+	return class {
+		__unenv__ = true;
+		constructor() {
+			throw new Error(`[unenv] ${name} is not implemented yet!`);
+		}
+	};
+}

worker/node_modules/unenv/dist/runtime/mock/empty.d.mts

@@ -0,0 +1,2 @@
+declare const _default;
+export default _default;

worker/node_modules/unenv/dist/runtime/mock/empty.mjs

@@ -0,0 +1 @@
+export default Object.freeze(Object.create(null, { __unenv__: { get: () => true } }));

worker/node_modules/unenv/dist/runtime/mock/noop.d.mts

@@ -0,0 +1,2 @@
+declare const _default;
+export default _default;

worker/node_modules/unenv/dist/runtime/mock/noop.mjs

@@ -0,0 +1 @@
+export default Object.assign(() => {}, { __unenv__: true });

worker/node_modules/unenv/dist/runtime/mock/proxy.d.mts

@@ -0,0 +1,2 @@
+declare const _default;
+export default _default;

worker/node_modules/unenv/dist/runtime/mock/proxy.mjs

@@ -0,0 +1,42 @@
+function createMock(name, overrides = {}) {
+	const proxyFn = function() {};
+	proxyFn.prototype.name = name;
+	const props = {};
+	const proxy = new Proxy(proxyFn, {
+		get(_target, prop) {
+			if (prop === "caller") {
+				return null;
+			}
+			if (prop === "__createMock__") {
+				return createMock;
+			}
+			if (prop === "__unenv__") {
+				return true;
+			}
+			if (prop in overrides) {
+				return overrides[prop];
+			}
+			if (prop === "then") {
+				return (fn) => Promise.resolve(fn());
+			}
+			if (prop === "catch") {
+				return (fn) => Promise.resolve();
+			}
+			if (prop === "finally") {
+				return (fn) => Promise.resolve(fn());
+			}
+			return props[prop] = props[prop] || createMock(`${name}.${prop.toString()}`);
+		},
+		apply(_target, _this, _args) {
+			return createMock(`${name}()`);
+		},
+		construct(_target, _args, _newT) {
+			return createMock(`[${name}]`);
+		},
+		enumerate() {
+			return [];
+		}
+	});
+	return proxy;
+}
+export default createMock("mock");

worker/node_modules/unenv/dist/runtime/node/assert.d.mts

@@ -0,0 +1,133 @@
+import type nodeAssert from "node:assert";
+export declare class AssertionError extends Error implements nodeAssert.AssertionError {
+	actual: unknown;
+	expected: unknown;
+	operator: string;
+	generatedMessage: boolean;
+	code: "ERR_ASSERTION";
+	constructor(options: {
+		message?: string
+		actual?: unknown
+		expected?: unknown
+		operator?: string
+		stackStartFn?: Function
+	});
+}
+/**
+* Pure assertion tests whether a value is truthy, as determined
+* by !!value.
+* @param {...any} args
+* @returns {void}
+*/
+export declare function ok(...args: unknown[]);
+/**
+* The equality assertion tests shallow, coercive equality with ==.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export declare function equal(actual: unknown, expected: unknown, message?: string | Error): void;
+/**
+* The non-equality assertion tests for whether two objects are not
+* equal with !=.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export declare function notEqual(actual: unknown, expected: unknown, message?: string | Error);
+/**
+* The deep equivalence assertion tests a deep equality relation.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export declare function deepEqual(actual: unknown, expected: unknown, message?: string | Error);
+/**
+* The deep non-equivalence assertion tests for any deep inequality.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export declare function notDeepEqual(actual: unknown, expected: unknown, message?: string | Error);
+/**
+* The deep strict equivalence assertion tests a deep strict equality
+* relation.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export declare function deepStrictEqual(actual: unknown, expected: unknown, message?: string | Error);
+/**
+* The deep strict non-equivalence assertion tests for any deep strict
+* inequality.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export declare function notDeepStrictEqual(actual: unknown, expected: unknown, message?: string | Error);
+/**
+* The strict equivalence assertion tests a strict equality relation.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export declare function strictEqual(actual: unknown, expected: unknown, message?: string | Error);
+/**
+* The strict non-equivalence assertion tests for any strict inequality.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export declare function notStrictEqual(actual: unknown, expected: unknown, message?: string | Error);
+/**
+* Expects the function `promiseFn` to throw an error.
+*/
+export declare function throws(promiseFn: () => any, ...args: unknown[]): void;
+/**
+* Expects `promiseFn` function or its value to reject.
+*/
+export declare function rejects(promiseFn: (() => Promise<unknown>) | Promise<unknown>, ...args: unknown[]): Promise<void>;
+/**
+* Asserts that the function `fn` does not throw an error.
+*/
+export declare function doesNotThrow(fn: () => any, ...args: unknown[]): void;
+/**
+* Expects `fn` or its value to not reject.
+*/
+export declare function doesNotReject(fn: (() => Promise<unknown>) | Promise<unknown>, ...args: unknown[]): Promise<void>;
+/**
+* Throws `value` if the value is not `null` or `undefined`.
+* @param {any} err
+* @returns {void}
+*/
+export declare function ifError(err: unknown);
+/**
+* Expects the `string` input to match the regular expression.
+* @param {string} string
+* @param {RegExp} regexp
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export declare function match(string: string, regexp: RegExp, message?: string | Error);
+/**
+* Expects the `string` input not to match the regular expression.
+* @param {string} string
+* @param {RegExp} regexp
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export declare function doesNotMatch(string: string, regexp: RegExp, message?: string | Error);
+export declare function fail(actual: unknown, expected?: unknown, message?: string | Error, operator?: string, stackStartFn?: Function): never;
+export declare const CallTracker: typeof nodeAssert.CallTracker;
+export declare const partialDeepStrictEqual: unknown;
+export declare const strict: unknown;
+declare const _default;
+export default _default;

worker/node_modules/unenv/dist/runtime/node/assert.mjs

@@ -0,0 +1,680 @@
+import { isEqual as _ohashIsEqual } from "ohash/utils";
+import { notImplemented, notImplementedClass } from "../_internal/utils.mjs";
+const ERR_AMBIGUOUS_ARGUMENT = Error;
+const ERR_INVALID_ARG_TYPE = Error;
+const ERR_INVALID_ARG_VALUE = Error;
+const ERR_INVALID_RETURN_VALUE = Error;
+const ERR_MISSING_ARGS = Error;
+export class AssertionError extends Error {
+	actual;
+	expected;
+	operator;
+	generatedMessage;
+	code = "ERR_ASSERTION";
+	constructor(options) {
+		super();
+		this.actual = options.actual;
+		this.expected = options.expected;
+		this.operator = options.operator || "";
+		this.generatedMessage = options.message === undefined;
+		const stackStartFn = options.stackStartFn || fail;
+		Error.captureStackTrace?.(this, stackStartFn);
+	}
+}
+const inspect = (val, opts) => val;
+const isDeepEqual = _ohashIsEqual;
+const isDeepStrictEqual = _ohashIsEqual;
+let warned = false;
+const NO_EXCEPTION_SENTINEL = {};
+/**
+* Pure assertion tests whether a value is truthy, as determined
+* by !!value.
+* @param {...any} args
+* @returns {void}
+*/
+export function ok(...args) {
+	innerOk(ok, args.length, ...args);
+}
+/**
+* The equality assertion tests shallow, coercive equality with ==.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export function equal(actual, expected, message) {
+	if (arguments.length < 2) {
+		throw new ERR_MISSING_ARGS("actual", "expected");
+	}
+	if (actual != expected && (!Number.isNaN(actual) || !Number.isNaN(expected))) {
+		innerFail({
+			actual,
+			expected,
+			message,
+			operator: "==",
+			stackStartFn: equal
+		});
+	}
+}
+/**
+* The non-equality assertion tests for whether two objects are not
+* equal with !=.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export function notEqual(actual, expected, message) {
+	if (arguments.length < 2) {
+		throw new ERR_MISSING_ARGS("actual", "expected");
+	}
+	if (actual == expected || Number.isNaN(actual) && Number.isNaN(expected)) {
+		innerFail({
+			actual,
+			expected,
+			message,
+			operator: "!=",
+			stackStartFn: notEqual
+		});
+	}
+}
+/**
+* The deep equivalence assertion tests a deep equality relation.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export function deepEqual(actual, expected, message) {
+	if (arguments.length < 2) {
+		throw new ERR_MISSING_ARGS("actual", "expected");
+	}
+	if (!isDeepEqual(actual, expected)) {
+		innerFail({
+			actual,
+			expected,
+			message,
+			operator: "deepEqual",
+			stackStartFn: deepEqual
+		});
+	}
+}
+/**
+* The deep non-equivalence assertion tests for any deep inequality.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export function notDeepEqual(actual, expected, message) {
+	if (arguments.length < 2) {
+		throw new ERR_MISSING_ARGS("actual", "expected");
+	}
+	if (isDeepEqual(actual, expected)) {
+		innerFail({
+			actual,
+			expected,
+			message,
+			operator: "notDeepEqual",
+			stackStartFn: notDeepEqual
+		});
+	}
+}
+/**
+* The deep strict equivalence assertion tests a deep strict equality
+* relation.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export function deepStrictEqual(actual, expected, message) {
+	if (arguments.length < 2) {
+		throw new ERR_MISSING_ARGS("actual", "expected");
+	}
+	if (!isDeepStrictEqual(actual, expected)) {
+		innerFail({
+			actual,
+			expected,
+			message,
+			operator: "deepStrictEqual",
+			stackStartFn: deepStrictEqual
+		});
+	}
+}
+/**
+* The deep strict non-equivalence assertion tests for any deep strict
+* inequality.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export function notDeepStrictEqual(actual, expected, message) {
+	if (arguments.length < 2) {
+		throw new ERR_MISSING_ARGS("actual", "expected");
+	}
+	if (isDeepStrictEqual(actual, expected)) {
+		innerFail({
+			actual,
+			expected,
+			message,
+			operator: "notDeepStrictEqual",
+			stackStartFn: notDeepStrictEqual
+		});
+	}
+}
+/**
+* The strict equivalence assertion tests a strict equality relation.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export function strictEqual(actual, expected, message) {
+	if (arguments.length < 2) {
+		throw new ERR_MISSING_ARGS("actual", "expected");
+	}
+	if (!Object.is(actual, expected)) {
+		innerFail({
+			actual,
+			expected,
+			message,
+			operator: "strictEqual",
+			stackStartFn: strictEqual
+		});
+	}
+}
+/**
+* The strict non-equivalence assertion tests for any strict inequality.
+* @param {any} actual
+* @param {any} expected
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export function notStrictEqual(actual, expected, message) {
+	if (arguments.length < 2) {
+		throw new ERR_MISSING_ARGS("actual", "expected");
+	}
+	if (Object.is(actual, expected)) {
+		innerFail({
+			actual,
+			expected,
+			message,
+			operator: "notStrictEqual",
+			stackStartFn: notStrictEqual
+		});
+	}
+}
+/**
+* Expects the function `promiseFn` to throw an error.
+*/
+export function throws(promiseFn, ...args) {
+	expectsError(throws, getActual(promiseFn), ...args);
+}
+/**
+* Expects `promiseFn` function or its value to reject.
+*/
+export async function rejects(promiseFn, ...args) {
+	expectsError(rejects, await waitForActual(promiseFn), ...args);
+}
+/**
+* Asserts that the function `fn` does not throw an error.
+*/
+export function doesNotThrow(fn, ...args) {
+	expectsNoError(doesNotThrow, getActual(fn), ...args);
+}
+/**
+* Expects `fn` or its value to not reject.
+*/
+export async function doesNotReject(fn, ...args) {
+	expectsNoError(doesNotReject, await waitForActual(fn), ...args);
+}
+/**
+* Throws `value` if the value is not `null` or `undefined`.
+* @param {any} err
+* @returns {void}
+*/
+export function ifError(err) {
+	if (err !== null && err !== undefined) {
+		let message = "ifError got unwanted exception: ";
+		if (typeof err === "object" && typeof err.message === "string") {
+			if (err.message.length === 0 && err.constructor) {
+				message += err.constructor.name;
+			} else {
+				message += err.message;
+			}
+		} else {
+			message += inspect(err);
+		}
+		const newErr = new AssertionError({
+			actual: err,
+			expected: null,
+			operator: "ifError",
+			message,
+			stackStartFn: ifError
+		});
+		const origStack = err?.stack;
+		if (typeof origStack === "string") {
+			const origStackStart = origStack.indexOf("\n    at");
+			if (origStackStart !== -1) {
+				const originalFrames = origStack.slice(origStackStart + 1).split("\n");
+				let newFrames = (newErr.stack || "").split("\n");
+				for (const errFrame of originalFrames) {
+					const pos = newFrames.indexOf(errFrame);
+					if (pos !== -1) {
+						newFrames = newFrames.slice(0, pos);
+						break;
+					}
+				}
+				const stackStart = newFrames.join("\n");
+				const stackEnd = originalFrames.join("\n");
+				newErr.stack = `${stackStart}\n${stackEnd}`;
+			}
+		}
+		throw newErr;
+	}
+}
+/**
+* Expects the `string` input to match the regular expression.
+* @param {string} string
+* @param {RegExp} regexp
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export function match(string, regexp, message) {
+	internalMatch(string, regexp, message, match);
+}
+/**
+* Expects the `string` input not to match the regular expression.
+* @param {string} string
+* @param {RegExp} regexp
+* @param {string | Error} [message]
+* @returns {void}
+*/
+export function doesNotMatch(string, regexp, message) {
+	internalMatch(string, regexp, message, doesNotMatch);
+}
+export function fail(actual, expected, message, operator, stackStartFn) {
+	const argsLen = arguments.length;
+	let internalMessage = false;
+	if (actual == null && argsLen <= 1) {
+		internalMessage = true;
+		message = "Failed";
+	} else if (argsLen === 1) {
+		message = actual;
+		actual = undefined;
+	} else {
+		if (warned === false) {
+			warned = true;
+			process.emitWarning("assert.fail() with more than one argument is deprecated. " + "Please use assert.strictEqual() instead or only pass a message.", "DeprecationWarning", "DEP0094");
+		}
+		if (argsLen === 2) operator = "!=";
+	}
+	if (message instanceof Error) throw message;
+	const errArgs = {
+		actual,
+		expected,
+		operator: operator === undefined ? "fail" : operator,
+		stackStartFn: stackStartFn || fail,
+		message
+	};
+	const err = new AssertionError(errArgs);
+	if (internalMessage) {
+		err.generatedMessage = true;
+	}
+	throw err;
+}
+function innerFail(obj) {
+	if (obj.message instanceof Error) throw obj.message;
+	throw new AssertionError(obj);
+}
+function innerOk(fn, argLen, value, message) {
+	if (!value) {
+		let generatedMessage = false;
+		if (argLen === 0) {
+			generatedMessage = true;
+			message = "No value argument passed to `assert.ok()`";
+		} else if (message == null) {
+			generatedMessage = true;
+			message = "<null>";
+		} else if (message instanceof Error) {
+			throw message;
+		}
+		const err = new AssertionError({
+			actual: value,
+			expected: true,
+			message,
+			operator: "==",
+			stackStartFn: fn
+		});
+		err.generatedMessage = generatedMessage;
+		throw err;
+	}
+}
+class Comparison {
+	constructor(obj, keys, actual) {
+		for (const key of keys) {
+			if (key in obj) {
+				if (actual !== undefined && typeof actual[key] === "string" && obj[key] instanceof RegExp && obj[key].exec(actual[key]) !== null) {
+					this[key] = actual[key];
+				} else {
+					this[key] = obj[key];
+				}
+			}
+		}
+	}
+}
+function compareExceptionKey(actual, expected, key, message, keys, fn) {
+	if (!(key in actual) || !isDeepStrictEqual(actual[key], expected[key])) {
+		if (!message) {
+			const a = new Comparison(actual, keys);
+			const b = new Comparison(expected, keys, actual);
+			const err = new AssertionError({
+				actual: a,
+				expected: b,
+				operator: "deepStrictEqual",
+				stackStartFn: fn
+			});
+			err.actual = actual;
+			err.expected = expected;
+			err.operator = fn.name;
+			throw err;
+		}
+		innerFail({
+			actual,
+			expected,
+			message,
+			operator: fn.name,
+			stackStartFn: fn
+		});
+	}
+}
+function expectedException(actual, expected, message, fn) {
+	let generatedMessage = false;
+	let throwError = false;
+	if (typeof expected !== "function") {
+		if (expected instanceof RegExp) {
+			const str = String(actual);
+			if (RegExp.prototype.exec.call(expected, str) !== null) return;
+			if (!message) {
+				generatedMessage = true;
+				message = "The input did not match the regular expression " + `${inspect(expected)}. Input:\n\n${inspect(str)}\n`;
+			}
+			throwError = true;
+		} else if (typeof actual !== "object" || actual === null) {
+			const err = new AssertionError({
+				actual,
+				expected,
+				message,
+				operator: "deepStrictEqual",
+				stackStartFn: fn
+			});
+			err.operator = fn.name;
+			throw err;
+		} else {
+			const keys = Object.keys(expected);
+			if (expected instanceof Error) {
+				keys.push("name", "message");
+			} else if (keys.length === 0) {
+				throw new ERR_INVALID_ARG_VALUE(
+					"error",
+					expected,
+					// @ts-expect-error
+					"may not be an empty object"
+);
+			}
+			for (const key of keys) {
+				if (typeof actual[key] === "string" && expected[key] instanceof RegExp && expected[key].exec(actual[key]) !== null) {
+					continue;
+				}
+				compareExceptionKey(actual, expected, key, message, keys, fn);
+			}
+			return;
+		}
+	} else if (expected.prototype !== undefined && actual instanceof expected) {
+		return;
+	} else if (expected instanceof Error) {
+		if (!message) {
+			generatedMessage = true;
+			message = "The error is expected to be an instance of " + `"${expected.name}". Received `;
+			if (actual instanceof Error) {
+				const name = actual.constructor && actual.constructor.name || actual.name;
+				if (expected.name === name) {
+					message += "an error with identical name but a different prototype.";
+				} else {
+					message += `"${name}"`;
+				}
+				if (actual.message) {
+					message += `\n\nError message:\n\n${actual.message}`;
+				}
+			} else {
+				message += `"${inspect(actual, { depth: -1 })}"`;
+			}
+		}
+		throwError = true;
+	} else {
+		const res = Reflect.apply(expected, {}, [actual]);
+		if (res !== true) {
+			if (!message) {
+				generatedMessage = true;
+				const name = expected.name ? `"${expected.name}" ` : "";
+				message = `The ${name}validation function is expected to return` + ` "true". Received ${inspect(res)}`;
+				if (actual instanceof Error) {
+					message += `\n\nCaught error:\n\n${actual}`;
+				}
+			}
+			throwError = true;
+		}
+	}
+	if (throwError) {
+		const err = new AssertionError({
+			actual,
+			expected,
+			message,
+			operator: fn.name,
+			stackStartFn: fn
+		});
+		err.generatedMessage = generatedMessage;
+		throw err;
+	}
+}
+function getActual(fn) {
+	try {
+		fn();
+	} catch (error_) {
+		return error_;
+	}
+	return NO_EXCEPTION_SENTINEL;
+}
+function checkIsPromise(obj) {
+	return obj instanceof Promise || obj !== null && typeof obj === "object" && typeof obj.then === "function" && typeof obj.catch === "function";
+}
+function internalMatch(string, regexp, message, fn) {
+	if (!(regexp instanceof RegExp)) {
+		throw new ERR_INVALID_ARG_TYPE("regexp", "RegExp", regexp);
+	}
+	const match = fn === assert.match;
+	if (typeof string !== "string" || regexp.exec(string) !== null !== match) {
+		if (message instanceof Error) {
+			throw message;
+		}
+		const generatedMessage = !message;
+		message = message || (typeof string === "string" ? (match ? "The input did not match the regular expression " : "The input was expected to not match the regular expression ") + `${inspect(regexp)}. Input:\n\n${inspect(string)}\n` : "The \"string\" argument must be of type string. Received type " + `${typeof string} (${inspect(string)})`);
+		const err = new AssertionError({
+			actual: string,
+			expected: regexp,
+			message,
+			operator: fn?.name,
+			stackStartFn: fn
+		});
+		err.generatedMessage = generatedMessage;
+		throw err;
+	}
+}
+async function waitForActual(promiseFn) {
+	let resultPromise;
+	if (typeof promiseFn === "function") {
+		resultPromise = promiseFn();
+		if (!checkIsPromise(resultPromise)) {
+			throw new ERR_INVALID_RETURN_VALUE(
+				"instance of Promise",
+				"promiseFn",
+				// @ts-expect-error
+				resultPromise
+);
+		}
+	} else if (checkIsPromise(promiseFn)) {
+		resultPromise = promiseFn;
+	} else {
+		throw new ERR_INVALID_ARG_TYPE(
+			"promiseFn",
+			["Function", "Promise"],
+			// @ts-expect-error
+			promiseFn
+);
+	}
+	try {
+		await resultPromise;
+	} catch (error_) {
+		return error_;
+	}
+	return NO_EXCEPTION_SENTINEL;
+}
+function expectsError(stackStartFn, actual, error, message) {
+	if (typeof error === "string") {
+		if (arguments.length === 4) {
+			throw new ERR_INVALID_ARG_TYPE(
+				"error",
+				[
+					"Object",
+					"Error",
+					"Function",
+					"RegExp"
+				],
+				// @ts-expect-error
+				error
+);
+		}
+		if (typeof actual === "object" && actual !== null) {
+			if (actual?.message === error) {
+				throw new ERR_AMBIGUOUS_ARGUMENT(
+					"error/message",
+					// @ts-expect-error
+					`The error message "${actual.message}" is identical to the message.`
+);
+			}
+		} else if (actual === error) {
+			throw new ERR_AMBIGUOUS_ARGUMENT(
+				"error/message",
+				// @ts-expect-error
+				`The error "${actual}" is identical to the message.`
+);
+		}
+		message = error;
+		error = undefined;
+	} else if (error != null && typeof error !== "object" && typeof error !== "function") {
+		throw new ERR_INVALID_ARG_TYPE(
+			"error",
+			[
+				"Object",
+				"Error",
+				"Function",
+				"RegExp"
+			],
+			// @ts-expect-error
+			error
+);
+	}
+	if (actual === NO_EXCEPTION_SENTINEL) {
+		let details = "";
+		if (error && error.name) {
+			details += ` (${error.name})`;
+		}
+		details += message ? `: ${message}` : ".";
+		const fnType = stackStartFn === assert.rejects ? "rejection" : "exception";
+		innerFail({
+			actual: undefined,
+			expected: error,
+			operator: stackStartFn.name,
+			message: `Missing expected ${fnType}${details}`,
+			stackStartFn
+		});
+	}
+	if (!error) return;
+	expectedException(actual, error, message, stackStartFn);
+}
+function hasMatchingError(actual, expected) {
+	if (typeof expected !== "function") {
+		if (expected instanceof RegExp) {
+			const str = String(actual);
+			return RegExp.prototype.exec.call(expected, str) !== null;
+		}
+		throw new ERR_INVALID_ARG_TYPE(
+			"expected",
+			["Function", "RegExp"],
+			// @ts-expect-error
+			expected
+);
+	}
+	if (expected.prototype !== undefined && actual instanceof expected) {
+		return true;
+	}
+	if (expected instanceof Error) {
+		return false;
+	}
+	return Reflect.apply(expected, {}, [actual]) === true;
+}
+function expectsNoError(stackStartFn, actual, error, message) {
+	if (actual === NO_EXCEPTION_SENTINEL) return;
+	if (typeof error === "string") {
+		message = error;
+		error = undefined;
+	}
+	if (!error || hasMatchingError(actual, error)) {
+		const details = message ? `: ${message}` : ".";
+		const fnType = stackStartFn === assert.doesNotReject ? "rejection" : "exception";
+		innerFail({
+			actual,
+			expected: error,
+			operator: stackStartFn?.name,
+			message: `Got unwanted ${fnType}${details}\n` + `Actual message: "${actual && actual.message}"`,
+			stackStartFn
+		});
+	}
+	throw actual;
+}
+const assert = Object.assign(ok, {});
+export const CallTracker = /*@__PURE__*/ notImplementedClass("asset.CallTracker");
+export const partialDeepStrictEqual = /* @__PURE__ */ notImplemented("assert.partialDeepStrictEqual");
+assert.fail = fail;
+assert.ok = ok;
+assert.equal = equal;
+assert.notEqual = notEqual;
+assert.deepEqual = deepEqual;
+assert.notDeepEqual = notDeepEqual;
+assert.deepStrictEqual = deepStrictEqual;
+assert.notDeepStrictEqual = notDeepStrictEqual;
+assert.strictEqual = strictEqual;
+assert.notStrictEqual = notStrictEqual;
+assert.throws = throws;
+assert.rejects = rejects;
+assert.doesNotThrow = doesNotThrow;
+assert.doesNotReject = doesNotReject;
+assert.ifError = ifError;
+assert.match = match;
+assert.doesNotMatch = doesNotMatch;
+assert.partialDeepStrictEqual = partialDeepStrictEqual;
+assert.AssertionError = AssertionError;
+assert.CallTracker = CallTracker;
+export const strict = Object.assign(function _strict(...args) {
+	innerOk(strict, args.length, ...args);
+}, assert, {
+	equal: assert.strictEqual,
+	deepEqual: assert.deepStrictEqual,
+	notEqual: assert.notStrictEqual,
+	notDeepEqual: assert.notDeepStrictEqual
+});
+assert.strict = strict;
+assert.strict.strict = assert.strict;
+export default assert;

worker/node_modules/unenv/dist/runtime/node/assert/strict.d.mts

@@ -0,0 +1,4 @@
+import type nodeAssert from "node:assert";
+export { AssertionError, CallTracker, strict, fail, ok, throws, rejects, doesNotThrow, doesNotReject, ifError, match, doesNotMatch, notDeepStrictEqual, notDeepStrictEqual as notDeepEqual, strictEqual, strictEqual as equal, notStrictEqual, notStrictEqual as notEqual, deepStrictEqual, deepStrictEqual as deepEqual, partialDeepStrictEqual } from "../assert.mjs";
+declare const _default: typeof nodeAssert.strict;
+export default _default;

worker/node_modules/unenv/dist/runtime/node/assert/strict.mjs

@@ -0,0 +1,25 @@
+import { AssertionError, CallTracker, strict, fail, ok, throws, rejects, doesNotThrow, doesNotReject, ifError, match, doesNotMatch, notDeepStrictEqual, notDeepStrictEqual as notDeepEqual, strictEqual, strictEqual as equal, notStrictEqual, notStrictEqual as notEqual, deepStrictEqual, deepStrictEqual as deepEqual, partialDeepStrictEqual } from "../assert.mjs";
+export { AssertionError, CallTracker, strict, fail, ok, throws, rejects, doesNotThrow, doesNotReject, ifError, match, doesNotMatch, notDeepStrictEqual, notDeepStrictEqual as notDeepEqual, strictEqual, strictEqual as equal, notStrictEqual, notStrictEqual as notEqual, deepStrictEqual, deepStrictEqual as deepEqual, partialDeepStrictEqual } from "../assert.mjs";
+export default Object.assign(ok, {
+	AssertionError,
+	CallTracker,
+	strict,
+	fail,
+	ok,
+	throws,
+	rejects,
+	doesNotThrow,
+	doesNotReject,
+	ifError,
+	match,
+	doesNotMatch,
+	notDeepStrictEqual,
+	notDeepEqual,
+	strictEqual,
+	equal,
+	notStrictEqual,
+	notEqual,
+	deepStrictEqual,
+	deepEqual,
+	partialDeepStrictEqual
+});

worker/node_modules/unenv/dist/runtime/node/async_hooks.d.mts

@@ -0,0 +1,5 @@
+export { AsyncLocalStorage } from "./internal/async_hooks/async-local-storage.mjs";
+export { AsyncResource } from "./internal/async_hooks/async-resource.mjs";
+export * from "./internal/async_hooks/async-hook.mjs";
+declare const _default: {};
+export default _default;

worker/node_modules/unenv/dist/runtime/node/async_hooks.mjs

@@ -0,0 +1,15 @@
+import { AsyncLocalStorage } from "./internal/async_hooks/async-local-storage.mjs";
+import { AsyncResource } from "./internal/async_hooks/async-resource.mjs";
+import { asyncWrapProviders, createHook, executionAsyncId, executionAsyncResource, triggerAsyncId } from "./internal/async_hooks/async-hook.mjs";
+export { AsyncLocalStorage } from "./internal/async_hooks/async-local-storage.mjs";
+export { AsyncResource } from "./internal/async_hooks/async-resource.mjs";
+export * from "./internal/async_hooks/async-hook.mjs";
+export default {
+	asyncWrapProviders,
+	AsyncLocalStorage,
+	AsyncResource,
+	createHook,
+	executionAsyncId,
+	executionAsyncResource,
+	triggerAsyncId
+};

worker/node_modules/unenv/dist/runtime/node/buffer.d.mts

@@ -0,0 +1,17 @@
+import type nodeBuffer from "node:buffer";
+export { kMaxLength, INSPECT_MAX_BYTES, SlowBuffer } from "./internal/buffer/buffer.mjs";
+export declare const Buffer: unknown;
+export { File } from "./internal/buffer/file.mjs";
+export declare const Blob: typeof nodeBuffer.Blob;
+export declare const resolveObjectURL: unknown;
+export declare const transcode: unknown;
+export declare const isUtf8: unknown;
+export declare const isAscii: unknown;
+export declare const btoa: unknown;
+export declare const atob: unknown;
+export declare const kStringMaxLength = 0;
+export declare const constants: {};
+declare const _default: {
+	SlowBuffer: typeof nodeBuffer.SlowBuffer
+};
+export default _default;

worker/node_modules/unenv/dist/runtime/node/buffer.mjs

@@ -0,0 +1,34 @@
+import { notImplemented } from "../_internal/utils.mjs";
+import { Buffer as _Buffer, kMaxLength, INSPECT_MAX_BYTES, SlowBuffer } from "./internal/buffer/buffer.mjs";
+import { File } from "./internal/buffer/file.mjs";
+export { kMaxLength, INSPECT_MAX_BYTES, SlowBuffer } from "./internal/buffer/buffer.mjs";
+export const Buffer = globalThis.Buffer || _Buffer;
+export { File } from "./internal/buffer/file.mjs";
+export const Blob = globalThis.Blob;
+export const resolveObjectURL = /*@__PURE__*/ notImplemented("buffer.resolveObjectURL");
+export const transcode = /*@__PURE__*/ notImplemented("buffer.transcode");
+export const isUtf8 = /*@__PURE__*/ notImplemented("buffer.isUtf8");
+export const isAscii = /*@__PURE__*/ notImplemented("buffer.isAscii");
+export const btoa = globalThis.btoa.bind(globalThis);
+export const atob = globalThis.atob.bind(globalThis);
+export const kStringMaxLength = 0;
+export const constants = {
+	MAX_LENGTH: kMaxLength,
+	MAX_STRING_LENGTH: kStringMaxLength
+};
+export default {
+	Buffer,
+	SlowBuffer,
+	kMaxLength,
+	INSPECT_MAX_BYTES,
+	Blob,
+	resolveObjectURL,
+	transcode,
+	btoa,
+	atob,
+	kStringMaxLength,
+	constants,
+	isUtf8,
+	isAscii,
+	File
+};

worker/node_modules/unenv/dist/runtime/node/child_process.d.mts

@@ -0,0 +1,12 @@
+import type nodeChildProcess from "node:child_process";
+export declare const ChildProcess: typeof nodeChildProcess.ChildProcess;
+export declare const _forkChild: unknown;
+export declare const exec: typeof nodeChildProcess.exec;
+export declare const execFile: typeof nodeChildProcess.execFile;
+export declare const execFileSync: typeof nodeChildProcess.execFileSync;
+export declare const execSync: typeof nodeChildProcess.execSync;
+export declare const fork: typeof nodeChildProcess.fork;
+export declare const spawn: typeof nodeChildProcess.spawn;
+export declare const spawnSync: typeof nodeChildProcess.spawnSync;
+declare const _default: typeof nodeChildProcess;
+export default _default;

worker/node_modules/unenv/dist/runtime/node/child_process.mjs

@@ -0,0 +1,21 @@
+import { notImplemented, notImplementedClass } from "../_internal/utils.mjs";
+export const ChildProcess = /*@__PURE__*/ notImplementedClass("child_process.ChildProcess");
+export const _forkChild = /*@__PURE__*/ notImplemented("child_process.ChildProcess");
+export const exec = /*@__PURE__*/ notImplemented("child_process.exec");
+export const execFile = /*@__PURE__*/ notImplemented("child_process.execFile");
+export const execFileSync = /*@__PURE__*/ notImplemented("child_process.execFileSync");
+export const execSync = /*@__PURE__*/ notImplemented("child_process.execSyn");
+export const fork = /*@__PURE__*/ notImplemented("child_process.fork");
+export const spawn = /*@__PURE__*/ notImplemented("child_process.spawn");
+export const spawnSync = /*@__PURE__*/ notImplemented("child_process.spawnSync");
+export default {
+	ChildProcess,
+	_forkChild,
+	exec,
+	execFile,
+	execFileSync,
+	execSync,
+	fork,
+	spawn,
+	spawnSync
+};

worker/node_modules/unenv/dist/runtime/node/cluster.d.mts

@@ -0,0 +1,32 @@
+import type nodeCluster from "node:cluster";
+import type { Worker as NodeClusterWorker } from "node:cluster";
+import { EventEmitter } from "node:events";
+export declare const SCHED_NONE: typeof nodeCluster.SCHED_NONE;
+export declare const SCHED_RR: typeof nodeCluster.SCHED_RR;
+export declare const isMaster: typeof nodeCluster.isMaster;
+export declare const isPrimary: typeof nodeCluster.isPrimary;
+export declare const isWorker: typeof nodeCluster.isWorker;
+export declare const schedulingPolicy: typeof nodeCluster.schedulingPolicy;
+export declare const settings: typeof nodeCluster.settings;
+export declare const workers: typeof nodeCluster.workers;
+export declare const fork: typeof nodeCluster.fork;
+export declare const disconnect: typeof nodeCluster.disconnect;
+export declare const setupPrimary: typeof nodeCluster.setupPrimary;
+export declare const setupMaster: typeof nodeCluster.setupMaster;
+export declare const _events: unknown;
+export declare const _eventsCount = 0;
+export declare const _maxListeners = 0;
+export declare class Worker extends EventEmitter implements NodeClusterWorker {
+	_connected: boolean;
+	id: number;
+	get process(): any;
+	get exitedAfterDisconnect();
+	isConnected(): boolean;
+	isDead(): boolean;
+	send(message: any, sendHandle?: any, options?: any, callback?: any): boolean;
+	kill(signal?: string): void;
+	destroy(signal?: string): void;
+	disconnect(): void;
+}
+declare const _default;
+export default _default;

worker/node_modules/unenv/dist/runtime/node/cluster.mjs

@@ -0,0 +1,69 @@
+import { EventEmitter } from "node:events";
+import { notImplemented } from "../_internal/utils.mjs";
+export const SCHED_NONE = 1;
+export const SCHED_RR = 2;
+export const isMaster = true;
+export const isPrimary = true;
+export const isWorker = false;
+export const schedulingPolicy = SCHED_RR;
+export const settings = {};
+export const workers = {};
+export const fork = /*@__PURE__*/ notImplemented("cluster.fork");
+export const disconnect = /*@__PURE__*/ notImplemented("cluster.disconnect");
+export const setupPrimary = /*@__PURE__*/ notImplemented("cluster.setupPrimary");
+export const setupMaster = /*@__PURE__*/ notImplemented("cluster.setupMaster");
+export const _events = [];
+export const _eventsCount = 0;
+export const _maxListeners = 0;
+export class Worker extends EventEmitter {
+	_connected = false;
+	id = 0;
+	get process() {
+		return globalThis.process;
+	}
+	get exitedAfterDisconnect() {
+		return this._connected;
+	}
+	isConnected() {
+		return this._connected;
+	}
+	isDead() {
+		return true;
+	}
+	send(message, sendHandle, options, callback) {
+		return false;
+	}
+	kill(signal) {
+		this._connected = false;
+	}
+	destroy(signal) {
+		this._connected = false;
+	}
+	disconnect() {
+		this._connected = false;
+	}
+}
+class _Cluster extends EventEmitter {
+	Worker = Worker;
+	isMaster = isMaster;
+	isPrimary = isPrimary;
+	isWorker = isWorker;
+	SCHED_NONE = SCHED_NONE;
+	SCHED_RR = SCHED_RR;
+	schedulingPolicy = SCHED_RR;
+	settings = settings;
+	workers = workers;
+	setupPrimary() {
+		return setupPrimary();
+	}
+	setupMaster() {
+		return setupPrimary();
+	}
+	disconnect() {
+		return disconnect();
+	}
+	fork() {
+		return fork();
+	}
+}
+export default new _Cluster();

worker/node_modules/unenv/dist/runtime/node/console.d.mts

@@ -0,0 +1,35 @@
+import type nodeConsole from "node:console";
+import { Writable } from "node:stream";
+export declare const _ignoreErrors: boolean;
+export declare const _stderr: Writable;
+export declare const _stdout: Writable;
+export declare const log: typeof nodeConsole.log;
+export declare const info: typeof nodeConsole.info;
+export declare const trace: typeof nodeConsole.trace;
+export declare const debug: typeof nodeConsole.debug;
+export declare const table: typeof nodeConsole.table;
+export declare const error: typeof nodeConsole.error;
+export declare const warn: typeof nodeConsole.warn;
+export declare const createTask: unknown;
+export declare const assert: typeof nodeConsole.assert;
+export declare const clear: typeof nodeConsole.clear;
+export declare const count: typeof nodeConsole.count;
+export declare const countReset: typeof nodeConsole.countReset;
+export declare const dir: typeof nodeConsole.dir;
+export declare const dirxml: typeof nodeConsole.dirxml;
+export declare const group: typeof nodeConsole.group;
+export declare const groupEnd: typeof nodeConsole.groupEnd;
+export declare const groupCollapsed: typeof nodeConsole.groupCollapsed;
+export declare const profile: typeof nodeConsole.profile;
+export declare const profileEnd: typeof nodeConsole.profileEnd;
+export declare const time: typeof nodeConsole.time;
+export declare const timeEnd: typeof nodeConsole.timeEnd;
+export declare const timeLog: typeof nodeConsole.timeLog;
+export declare const timeStamp: typeof nodeConsole.timeStamp;
+export declare const Console: typeof nodeConsole.Console;
+export declare const _times: unknown;
+export declare function context();
+export declare const _stdoutErrorHandler: unknown;
+export declare const _stderrErrorHandler: unknown;
+declare const _default: {};
+export default _default;

worker/node_modules/unenv/dist/runtime/node/console.mjs

@@ -0,0 +1,70 @@
+import { Writable } from "node:stream";
+import noop from "../mock/noop.mjs";
+import { notImplemented, notImplementedClass } from "../_internal/utils.mjs";
+const _console = globalThis.console;
+export const _ignoreErrors = true;
+export const _stderr = new Writable();
+export const _stdout = new Writable();
+export const log = _console?.log ?? noop;
+export const info = _console?.info ?? log;
+export const trace = _console?.trace ?? info;
+export const debug = _console?.debug ?? log;
+export const table = _console?.table ?? log;
+export const error = _console?.error ?? log;
+export const warn = _console?.warn ?? error;
+export const createTask = _console?.createTask ?? /*@__PURE__*/ notImplemented("console.createTask");
+export const assert = /*@__PURE__*/ notImplemented("console.assert");
+export const clear = _console?.clear ?? noop;
+export const count = _console?.count ?? noop;
+export const countReset = _console?.countReset ?? noop;
+export const dir = _console?.dir ?? noop;
+export const dirxml = _console?.dirxml ?? noop;
+export const group = _console?.group ?? noop;
+export const groupEnd = _console?.groupEnd ?? noop;
+export const groupCollapsed = _console?.groupCollapsed ?? noop;
+export const profile = _console?.profile ?? noop;
+export const profileEnd = _console?.profileEnd ?? noop;
+export const time = _console?.time ?? noop;
+export const timeEnd = _console?.timeEnd ?? noop;
+export const timeLog = _console?.timeLog ?? noop;
+export const timeStamp = _console?.timeStamp ?? noop;
+export const Console = _console?.Console ?? /*@__PURE__*/ notImplementedClass("console.Console");
+export const _times = /*@__PURE__*/ new Map();
+export function context() {
+	return _console;
+}
+export const _stdoutErrorHandler = noop;
+export const _stderrErrorHandler = noop;
+export default {
+	_times,
+	_ignoreErrors,
+	_stdoutErrorHandler,
+	_stderrErrorHandler,
+	_stdout,
+	_stderr,
+	assert,
+	clear,
+	Console,
+	count,
+	countReset,
+	debug,
+	dir,
+	dirxml,
+	error,
+	context,
+	createTask,
+	group,
+	groupEnd,
+	groupCollapsed,
+	info,
+	log,
+	profile,
+	profileEnd,
+	table,
+	time,
+	timeEnd,
+	timeLog,
+	timeStamp,
+	trace,
+	warn
+};

worker/node_modules/unenv/dist/runtime/node/constants.d.mts

@@ -0,0 +1,8 @@
+export * from "./internal/fs/constants.mjs";
+export { OPENSSL_VERSION_NUMBER, SSL_OP_ALL, SSL_OP_ALLOW_NO_DHE_KEX, SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION, SSL_OP_CIPHER_SERVER_PREFERENCE, SSL_OP_CISCO_ANYCONNECT, SSL_OP_COOKIE_EXCHANGE, SSL_OP_CRYPTOPRO_TLSEXT_BUG, SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS, SSL_OP_LEGACY_SERVER_CONNECT, SSL_OP_NO_COMPRESSION, SSL_OP_NO_ENCRYPT_THEN_MAC, SSL_OP_NO_QUERY_MTU, SSL_OP_NO_RENEGOTIATION, SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION, SSL_OP_NO_SSLv2, SSL_OP_NO_SSLv3, SSL_OP_NO_TICKET, SSL_OP_NO_TLSv1, SSL_OP_NO_TLSv1_1, SSL_OP_NO_TLSv1_2, SSL_OP_NO_TLSv1_3, SSL_OP_PRIORITIZE_CHACHA, SSL_OP_TLS_ROLLBACK_BUG, ENGINE_METHOD_RSA, ENGINE_METHOD_DSA, ENGINE_METHOD_DH, ENGINE_METHOD_RAND, ENGINE_METHOD_EC, ENGINE_METHOD_CIPHERS, ENGINE_METHOD_DIGESTS, ENGINE_METHOD_PKEY_METHS, ENGINE_METHOD_PKEY_ASN1_METHS, ENGINE_METHOD_ALL, ENGINE_METHOD_NONE, DH_CHECK_P_NOT_SAFE_PRIME, DH_CHECK_P_NOT_PRIME, DH_UNABLE_TO_CHECK_GENERATOR, DH_NOT_SUITABLE_GENERATOR, RSA_PKCS1_PADDING, RSA_NO_PADDING, RSA_PKCS1_OAEP_PADDING, RSA_X931_PADDING, RSA_PKCS1_PSS_PADDING, RSA_PSS_SALTLEN_DIGEST, RSA_PSS_SALTLEN_MAX_SIGN, RSA_PSS_SALTLEN_AUTO, defaultCoreCipherList, TLS1_VERSION, TLS1_1_VERSION, TLS1_2_VERSION, TLS1_3_VERSION, POINT_CONVERSION_COMPRESSED, POINT_CONVERSION_UNCOMPRESSED, POINT_CONVERSION_HYBRID } from "./internal/crypto/constants.mjs";
+export declare const;
+export declare const;
+export declare const;
+export declare const;
+declare const _default: {};
+export default _default;

worker/node_modules/unenv/dist/runtime/node/constants.mjs

@@ -0,0 +1,247 @@
+import { errno, priority, signals, dlopen } from "./internal/os/constants.mjs";
+import { UV_FS_SYMLINK_DIR, UV_FS_SYMLINK_JUNCTION, O_RDONLY, O_WRONLY, O_RDWR, UV_DIRENT_UNKNOWN, UV_DIRENT_FILE, UV_DIRENT_DIR, UV_DIRENT_LINK, UV_DIRENT_FIFO, UV_DIRENT_SOCKET, UV_DIRENT_CHAR, UV_DIRENT_BLOCK, EXTENSIONLESS_FORMAT_JAVASCRIPT, EXTENSIONLESS_FORMAT_WASM, S_IFMT, S_IFREG, S_IFDIR, S_IFCHR, S_IFBLK, S_IFIFO, S_IFLNK, S_IFSOCK, O_CREAT, O_EXCL, UV_FS_O_FILEMAP, O_NOCTTY, O_TRUNC, O_APPEND, O_DIRECTORY, O_NOATIME, O_NOFOLLOW, O_SYNC, O_DSYNC, O_DIRECT, O_NONBLOCK, S_IRWXU, S_IRUSR, S_IWUSR, S_IXUSR, S_IRWXG, S_IRGRP, S_IWGRP, S_IXGRP, S_IRWXO, S_IROTH, S_IWOTH, S_IXOTH, F_OK, R_OK, W_OK, X_OK, UV_FS_COPYFILE_EXCL, COPYFILE_EXCL, UV_FS_COPYFILE_FICLONE, COPYFILE_FICLONE, UV_FS_COPYFILE_FICLONE_FORCE, COPYFILE_FICLONE_FORCE } from "./internal/fs/constants.mjs";
+import { OPENSSL_VERSION_NUMBER, SSL_OP_ALL, SSL_OP_ALLOW_NO_DHE_KEX, SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION, SSL_OP_CIPHER_SERVER_PREFERENCE, SSL_OP_CISCO_ANYCONNECT, SSL_OP_COOKIE_EXCHANGE, SSL_OP_CRYPTOPRO_TLSEXT_BUG, SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS, SSL_OP_LEGACY_SERVER_CONNECT, SSL_OP_NO_COMPRESSION, SSL_OP_NO_ENCRYPT_THEN_MAC, SSL_OP_NO_QUERY_MTU, SSL_OP_NO_RENEGOTIATION, SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION, SSL_OP_NO_SSLv2, SSL_OP_NO_SSLv3, SSL_OP_NO_TICKET, SSL_OP_NO_TLSv1, SSL_OP_NO_TLSv1_1, SSL_OP_NO_TLSv1_2, SSL_OP_NO_TLSv1_3, SSL_OP_PRIORITIZE_CHACHA, SSL_OP_TLS_ROLLBACK_BUG, ENGINE_METHOD_RSA, ENGINE_METHOD_DSA, ENGINE_METHOD_DH, ENGINE_METHOD_RAND, ENGINE_METHOD_EC, ENGINE_METHOD_CIPHERS, ENGINE_METHOD_DIGESTS, ENGINE_METHOD_PKEY_METHS, ENGINE_METHOD_PKEY_ASN1_METHS, ENGINE_METHOD_ALL, ENGINE_METHOD_NONE, DH_CHECK_P_NOT_SAFE_PRIME, DH_CHECK_P_NOT_PRIME, DH_UNABLE_TO_CHECK_GENERATOR, DH_NOT_SUITABLE_GENERATOR, RSA_PKCS1_PADDING, RSA_NO_PADDING, RSA_PKCS1_OAEP_PADDING, RSA_X931_PADDING, RSA_PKCS1_PSS_PADDING, RSA_PSS_SALTLEN_DIGEST, RSA_PSS_SALTLEN_MAX_SIGN, RSA_PSS_SALTLEN_AUTO, defaultCoreCipherList, TLS1_VERSION, TLS1_1_VERSION, TLS1_2_VERSION, TLS1_3_VERSION, POINT_CONVERSION_COMPRESSED, POINT_CONVERSION_UNCOMPRESSED, POINT_CONVERSION_HYBRID } from "./internal/crypto/constants.mjs";
+export * from "./internal/fs/constants.mjs";
+export { OPENSSL_VERSION_NUMBER, SSL_OP_ALL, SSL_OP_ALLOW_NO_DHE_KEX, SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION, SSL_OP_CIPHER_SERVER_PREFERENCE, SSL_OP_CISCO_ANYCONNECT, SSL_OP_COOKIE_EXCHANGE, SSL_OP_CRYPTOPRO_TLSEXT_BUG, SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS, SSL_OP_LEGACY_SERVER_CONNECT, SSL_OP_NO_COMPRESSION, SSL_OP_NO_ENCRYPT_THEN_MAC, SSL_OP_NO_QUERY_MTU, SSL_OP_NO_RENEGOTIATION, SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION, SSL_OP_NO_SSLv2, SSL_OP_NO_SSLv3, SSL_OP_NO_TICKET, SSL_OP_NO_TLSv1, SSL_OP_NO_TLSv1_1, SSL_OP_NO_TLSv1_2, SSL_OP_NO_TLSv1_3, SSL_OP_PRIORITIZE_CHACHA, SSL_OP_TLS_ROLLBACK_BUG, ENGINE_METHOD_RSA, ENGINE_METHOD_DSA, ENGINE_METHOD_DH, ENGINE_METHOD_RAND, ENGINE_METHOD_EC, ENGINE_METHOD_CIPHERS, ENGINE_METHOD_DIGESTS, ENGINE_METHOD_PKEY_METHS, ENGINE_METHOD_PKEY_ASN1_METHS, ENGINE_METHOD_ALL, ENGINE_METHOD_NONE, DH_CHECK_P_NOT_SAFE_PRIME, DH_CHECK_P_NOT_PRIME, DH_UNABLE_TO_CHECK_GENERATOR, DH_NOT_SUITABLE_GENERATOR, RSA_PKCS1_PADDING, RSA_NO_PADDING, RSA_PKCS1_OAEP_PADDING, RSA_X931_PADDING, RSA_PKCS1_PSS_PADDING, RSA_PSS_SALTLEN_DIGEST, RSA_PSS_SALTLEN_MAX_SIGN, RSA_PSS_SALTLEN_AUTO, defaultCoreCipherList, TLS1_VERSION, TLS1_1_VERSION, TLS1_2_VERSION, TLS1_3_VERSION, POINT_CONVERSION_COMPRESSED, POINT_CONVERSION_UNCOMPRESSED, POINT_CONVERSION_HYBRID } from "./internal/crypto/constants.mjs";
+export const { RTLD_LAZY, RTLD_NOW, RTLD_GLOBAL, RTLD_LOCAL, RTLD_DEEPBIND } = dlopen;
+export const { E2BIG, EACCES, EADDRINUSE, EADDRNOTAVAIL, EAFNOSUPPORT, EAGAIN, EALREADY, EBADF, EBADMSG, EBUSY, ECANCELED, ECHILD, ECONNABORTED, ECONNREFUSED, ECONNRESET, EDEADLK, EDESTADDRREQ, EDOM, EDQUOT, EEXIST, EFAULT, EFBIG, EHOSTUNREACH, EIDRM, EILSEQ, EINPROGRESS, EINTR, EINVAL, EIO, EISCONN, EISDIR, ELOOP, EMFILE, EMLINK, EMSGSIZE, EMULTIHOP, ENAMETOOLONG, ENETDOWN, ENETRESET, ENETUNREACH, ENFILE, ENOBUFS, ENODATA, ENODEV, ENOENT, ENOEXEC, ENOLCK, ENOLINK, ENOMEM, ENOMSG, ENOPROTOOPT, ENOSPC, ENOSR, ENOSTR, ENOSYS, ENOTCONN, ENOTDIR, ENOTEMPTY, ENOTSOCK, ENOTSUP, ENOTTY, ENXIO, EOPNOTSUPP, EOVERFLOW, EPERM, EPIPE, EPROTO, EPROTONOSUPPORT, EPROTOTYPE, ERANGE, EROFS, ESPIPE, ESRCH, ESTALE, ETIME, ETIMEDOUT, ETXTBSY, EWOULDBLOCK, EXDEV } = errno;
+export const { PRIORITY_LOW, PRIORITY_BELOW_NORMAL, PRIORITY_NORMAL, PRIORITY_ABOVE_NORMAL, PRIORITY_HIGH, PRIORITY_HIGHEST } = priority;
+export const { SIGHUP, SIGINT, SIGQUIT, SIGILL, SIGTRAP, SIGABRT, SIGIOT, SIGBUS, SIGFPE, SIGKILL, SIGUSR1, SIGSEGV, SIGUSR2, SIGPIPE, SIGALRM, SIGTERM, SIGCHLD, SIGSTKFLT, SIGCONT, SIGSTOP, SIGTSTP, SIGTTIN, SIGTTOU, SIGURG, SIGXCPU, SIGXFSZ, SIGVTALRM, SIGPROF, SIGWINCH, SIGIO, SIGPOLL, SIGPWR, SIGSYS } = signals;
+export default {
+	OPENSSL_VERSION_NUMBER,
+	SSL_OP_ALL,
+	SSL_OP_ALLOW_NO_DHE_KEX,
+	SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION,
+	SSL_OP_CIPHER_SERVER_PREFERENCE,
+	SSL_OP_CISCO_ANYCONNECT,
+	SSL_OP_COOKIE_EXCHANGE,
+	SSL_OP_CRYPTOPRO_TLSEXT_BUG,
+	SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS,
+	SSL_OP_LEGACY_SERVER_CONNECT,
+	SSL_OP_NO_COMPRESSION,
+	SSL_OP_NO_ENCRYPT_THEN_MAC,
+	SSL_OP_NO_QUERY_MTU,
+	SSL_OP_NO_RENEGOTIATION,
+	SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION,
+	SSL_OP_NO_SSLv2,
+	SSL_OP_NO_SSLv3,
+	SSL_OP_NO_TICKET,
+	SSL_OP_NO_TLSv1,
+	SSL_OP_NO_TLSv1_1,
+	SSL_OP_NO_TLSv1_2,
+	SSL_OP_NO_TLSv1_3,
+	SSL_OP_PRIORITIZE_CHACHA,
+	SSL_OP_TLS_ROLLBACK_BUG,
+	ENGINE_METHOD_RSA,
+	ENGINE_METHOD_DSA,
+	ENGINE_METHOD_DH,
+	ENGINE_METHOD_RAND,
+	ENGINE_METHOD_EC,
+	ENGINE_METHOD_CIPHERS,
+	ENGINE_METHOD_DIGESTS,
+	ENGINE_METHOD_PKEY_METHS,
+	ENGINE_METHOD_PKEY_ASN1_METHS,
+	ENGINE_METHOD_ALL,
+	ENGINE_METHOD_NONE,
+	DH_CHECK_P_NOT_SAFE_PRIME,
+	DH_CHECK_P_NOT_PRIME,
+	DH_UNABLE_TO_CHECK_GENERATOR,
+	DH_NOT_SUITABLE_GENERATOR,
+	RSA_PKCS1_PADDING,
+	RSA_NO_PADDING,
+	RSA_PKCS1_OAEP_PADDING,
+	RSA_X931_PADDING,
+	RSA_PKCS1_PSS_PADDING,
+	RSA_PSS_SALTLEN_DIGEST,
+	RSA_PSS_SALTLEN_MAX_SIGN,
+	RSA_PSS_SALTLEN_AUTO,
+	defaultCoreCipherList,
+	TLS1_VERSION,
+	TLS1_1_VERSION,
+	TLS1_2_VERSION,
+	TLS1_3_VERSION,
+	POINT_CONVERSION_COMPRESSED,
+	POINT_CONVERSION_UNCOMPRESSED,
+	POINT_CONVERSION_HYBRID,
+	UV_FS_SYMLINK_DIR,
+	UV_FS_SYMLINK_JUNCTION,
+	O_RDONLY,
+	O_WRONLY,
+	O_RDWR,
+	UV_DIRENT_UNKNOWN,
+	UV_DIRENT_FILE,
+	UV_DIRENT_DIR,
+	UV_DIRENT_LINK,
+	UV_DIRENT_FIFO,
+	UV_DIRENT_SOCKET,
+	UV_DIRENT_CHAR,
+	UV_DIRENT_BLOCK,
+	EXTENSIONLESS_FORMAT_JAVASCRIPT,
+	EXTENSIONLESS_FORMAT_WASM,
+	S_IFMT,
+	S_IFREG,
+	S_IFDIR,
+	S_IFCHR,
+	S_IFBLK,
+	S_IFIFO,
+	S_IFLNK,
+	S_IFSOCK,
+	O_CREAT,
+	O_EXCL,
+	UV_FS_O_FILEMAP,
+	O_NOCTTY,
+	O_TRUNC,
+	O_APPEND,
+	O_DIRECTORY,
+	O_NOATIME,
+	O_NOFOLLOW,
+	O_SYNC,
+	O_DSYNC,
+	O_DIRECT,
+	O_NONBLOCK,
+	S_IRWXU,
+	S_IRUSR,
+	S_IWUSR,
+	S_IXUSR,
+	S_IRWXG,
+	S_IRGRP,
+	S_IWGRP,
+	S_IXGRP,
+	S_IRWXO,
+	S_IROTH,
+	S_IWOTH,
+	S_IXOTH,
+	F_OK,
+	R_OK,
+	W_OK,
+	X_OK,
+	UV_FS_COPYFILE_EXCL,
+	COPYFILE_EXCL,
+	UV_FS_COPYFILE_FICLONE,
+	COPYFILE_FICLONE,
+	UV_FS_COPYFILE_FICLONE_FORCE,
+	COPYFILE_FICLONE_FORCE,
+	E2BIG,
+	EACCES,
+	EADDRINUSE,
+	EADDRNOTAVAIL,
+	EAFNOSUPPORT,
+	EAGAIN,
+	EALREADY,
+	EBADF,
+	EBADMSG,
+	EBUSY,
+	ECANCELED,
+	ECHILD,
+	ECONNABORTED,
+	ECONNREFUSED,
+	ECONNRESET,
+	EDEADLK,
+	EDESTADDRREQ,
+	EDOM,
+	EDQUOT,
+	EEXIST,
+	EFAULT,
+	EFBIG,
+	EHOSTUNREACH,
+	EIDRM,
+	EILSEQ,
+	EINPROGRESS,
+	EINTR,
+	EINVAL,
+	EIO,
+	EISCONN,
+	EISDIR,
+	ELOOP,
+	EMFILE,
+	EMLINK,
+	EMSGSIZE,
+	EMULTIHOP,
+	ENAMETOOLONG,
+	ENETDOWN,
+	ENETRESET,
+	ENETUNREACH,
+	ENFILE,
+	ENOBUFS,
+	ENODATA,
+	ENODEV,
+	ENOENT,
+	ENOEXEC,
+	ENOLCK,
+	ENOLINK,
+	ENOMEM,
+	ENOMSG,
+	ENOPROTOOPT,
+	ENOSPC,
+	ENOSR,
+	ENOSTR,
+	ENOSYS,
+	ENOTCONN,
+	ENOTDIR,
+	ENOTEMPTY,
+	ENOTSOCK,
+	ENOTSUP,
+	ENOTTY,
+	ENXIO,
+	EOPNOTSUPP,
+	EOVERFLOW,
+	EPERM,
+	EPIPE,
+	EPROTO,
+	EPROTONOSUPPORT,
+	EPROTOTYPE,
+	ERANGE,
+	EROFS,
+	ESPIPE,
+	ESRCH,
+	ESTALE,
+	ETIME,
+	ETIMEDOUT,
+	ETXTBSY,
+	EWOULDBLOCK,
+	EXDEV,
+	RTLD_LAZY,
+	RTLD_NOW,
+	RTLD_GLOBAL,
+	RTLD_LOCAL,
+	RTLD_DEEPBIND,
+	PRIORITY_LOW,
+	PRIORITY_BELOW_NORMAL,
+	PRIORITY_NORMAL,
+	PRIORITY_ABOVE_NORMAL,
+	PRIORITY_HIGH,
+	PRIORITY_HIGHEST,
+	SIGHUP,
+	SIGINT,
+	SIGQUIT,
+	SIGILL,
+	SIGTRAP,
+	SIGABRT,
+	SIGIOT,
+	SIGBUS,
+	SIGFPE,
+	SIGKILL,
+	SIGUSR1,
+	SIGSEGV,
+	SIGUSR2,
+	SIGPIPE,
+	SIGALRM,
+	SIGTERM,
+	SIGCHLD,
+	SIGSTKFLT,
+	SIGCONT,
+	SIGSTOP,
+	SIGTSTP,
+	SIGTTIN,
+	SIGTTOU,
+	SIGURG,
+	SIGXCPU,
+	SIGXFSZ,
+	SIGVTALRM,
+	SIGPROF,
+	SIGWINCH,
+	SIGIO,
+	SIGPOLL,
+	SIGPWR,
+	SIGSYS
+};

worker/node_modules/unenv/dist/runtime/node/crypto.d.mts

@@ -0,0 +1,5 @@
+export * from "./internal/crypto/web.mjs";
+export * from "./internal/crypto/node.mjs";
+export declare const constants: {};
+declare const _default: {};
+export default _default;

worker/node_modules/unenv/dist/runtime/node/crypto.mjs

@@ -0,0 +1,136 @@
+import { getRandomValues, randomUUID, subtle } from "./internal/crypto/web.mjs";
+import { Certificate, Cipher, Cipheriv, Decipher, Decipheriv, DiffieHellman, DiffieHellmanGroup, ECDH, Hash, Hmac, KeyObject, Sign, Verify, X509Certificate, checkPrime, checkPrimeSync, createCipheriv, createDecipheriv, createDiffieHellman, createDiffieHellmanGroup, createECDH, createHash, createHmac, createPrivateKey, createPublicKey, createSecretKey, createSign, createVerify, diffieHellman, fips, generateKey, generateKeyPair, generateKeyPairSync, generateKeySync, generatePrime, generatePrimeSync, getCipherInfo, getCiphers, getCurves, getDiffieHellman, getFips, getHashes, hash, hkdf, hkdfSync, pbkdf2, pbkdf2Sync, privateDecrypt, privateEncrypt, pseudoRandomBytes, publicDecrypt, prng, publicEncrypt, randomBytes, randomFill, randomFillSync, randomInt, rng, scrypt, scryptSync, secureHeapUsed, setEngine, setFips, sign, timingSafeEqual, verify, webcrypto } from "./internal/crypto/node.mjs";
+import { OPENSSL_VERSION_NUMBER, SSL_OP_ALL, SSL_OP_ALLOW_NO_DHE_KEX, SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION, SSL_OP_CIPHER_SERVER_PREFERENCE, SSL_OP_CISCO_ANYCONNECT, SSL_OP_COOKIE_EXCHANGE, SSL_OP_CRYPTOPRO_TLSEXT_BUG, SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS, SSL_OP_LEGACY_SERVER_CONNECT, SSL_OP_NO_COMPRESSION, SSL_OP_NO_ENCRYPT_THEN_MAC, SSL_OP_NO_QUERY_MTU, SSL_OP_NO_RENEGOTIATION, SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION, SSL_OP_NO_SSLv2, SSL_OP_NO_SSLv3, SSL_OP_NO_TICKET, SSL_OP_NO_TLSv1, SSL_OP_NO_TLSv1_1, SSL_OP_NO_TLSv1_2, SSL_OP_NO_TLSv1_3, SSL_OP_PRIORITIZE_CHACHA, SSL_OP_TLS_ROLLBACK_BUG, ENGINE_METHOD_RSA, ENGINE_METHOD_DSA, ENGINE_METHOD_DH, ENGINE_METHOD_RAND, ENGINE_METHOD_EC, ENGINE_METHOD_CIPHERS, ENGINE_METHOD_DIGESTS, ENGINE_METHOD_PKEY_METHS, ENGINE_METHOD_PKEY_ASN1_METHS, ENGINE_METHOD_ALL, ENGINE_METHOD_NONE, DH_CHECK_P_NOT_SAFE_PRIME, DH_CHECK_P_NOT_PRIME, DH_UNABLE_TO_CHECK_GENERATOR, DH_NOT_SUITABLE_GENERATOR, RSA_PKCS1_PADDING, RSA_NO_PADDING, RSA_PKCS1_OAEP_PADDING, RSA_X931_PADDING, RSA_PKCS1_PSS_PADDING, RSA_PSS_SALTLEN_DIGEST, RSA_PSS_SALTLEN_MAX_SIGN, RSA_PSS_SALTLEN_AUTO, defaultCoreCipherList, TLS1_VERSION, TLS1_1_VERSION, TLS1_2_VERSION, TLS1_3_VERSION, POINT_CONVERSION_COMPRESSED, POINT_CONVERSION_UNCOMPRESSED, POINT_CONVERSION_HYBRID, defaultCipherList } from "./internal/crypto/constants.mjs";
+export * from "./internal/crypto/web.mjs";
+export * from "./internal/crypto/node.mjs";
+export const constants = {
+	OPENSSL_VERSION_NUMBER,
+	SSL_OP_ALL,
+	SSL_OP_ALLOW_NO_DHE_KEX,
+	SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION,
+	SSL_OP_CIPHER_SERVER_PREFERENCE,
+	SSL_OP_CISCO_ANYCONNECT,
+	SSL_OP_COOKIE_EXCHANGE,
+	SSL_OP_CRYPTOPRO_TLSEXT_BUG,
+	SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS,
+	SSL_OP_LEGACY_SERVER_CONNECT,
+	SSL_OP_NO_COMPRESSION,
+	SSL_OP_NO_ENCRYPT_THEN_MAC,
+	SSL_OP_NO_QUERY_MTU,
+	SSL_OP_NO_RENEGOTIATION,
+	SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION,
+	SSL_OP_NO_SSLv2,
+	SSL_OP_NO_SSLv3,
+	SSL_OP_NO_TICKET,
+	SSL_OP_NO_TLSv1,
+	SSL_OP_NO_TLSv1_1,
+	SSL_OP_NO_TLSv1_2,
+	SSL_OP_NO_TLSv1_3,
+	SSL_OP_PRIORITIZE_CHACHA,
+	SSL_OP_TLS_ROLLBACK_BUG,
+	ENGINE_METHOD_RSA,
+	ENGINE_METHOD_DSA,
+	ENGINE_METHOD_DH,
+	ENGINE_METHOD_RAND,
+	ENGINE_METHOD_EC,
+	ENGINE_METHOD_CIPHERS,
+	ENGINE_METHOD_DIGESTS,
+	ENGINE_METHOD_PKEY_METHS,
+	ENGINE_METHOD_PKEY_ASN1_METHS,
+	ENGINE_METHOD_ALL,
+	ENGINE_METHOD_NONE,
+	DH_CHECK_P_NOT_SAFE_PRIME,
+	DH_CHECK_P_NOT_PRIME,
+	DH_UNABLE_TO_CHECK_GENERATOR,
+	DH_NOT_SUITABLE_GENERATOR,
+	RSA_PKCS1_PADDING,
+	RSA_NO_PADDING,
+	RSA_PKCS1_OAEP_PADDING,
+	RSA_X931_PADDING,
+	RSA_PKCS1_PSS_PADDING,
+	RSA_PSS_SALTLEN_DIGEST,
+	RSA_PSS_SALTLEN_MAX_SIGN,
+	RSA_PSS_SALTLEN_AUTO,
+	defaultCoreCipherList,
+	TLS1_VERSION,
+	TLS1_1_VERSION,
+	TLS1_2_VERSION,
+	TLS1_3_VERSION,
+	POINT_CONVERSION_COMPRESSED,
+	POINT_CONVERSION_UNCOMPRESSED,
+	POINT_CONVERSION_HYBRID,
+	defaultCipherList
+};
+export default {
+	constants,
+	getRandomValues,
+	randomUUID,
+	subtle,
+	Certificate,
+	Cipher,
+	Cipheriv,
+	Decipher,
+	Decipheriv,
+	DiffieHellman,
+	DiffieHellmanGroup,
+	ECDH,
+	Hash,
+	Hmac,
+	KeyObject,
+	Sign,
+	Verify,
+	X509Certificate,
+	checkPrime,
+	checkPrimeSync,
+	createCipheriv,
+	createDecipheriv,
+	createDiffieHellman,
+	createDiffieHellmanGroup,
+	createECDH,
+	createHash,
+	createHmac,
+	createPrivateKey,
+	createPublicKey,
+	createSecretKey,
+	createSign,
+	createVerify,
+	diffieHellman,
+	fips,
+	generateKey,
+	generateKeyPair,
+	generateKeyPairSync,
+	generateKeySync,
+	generatePrime,
+	generatePrimeSync,
+	getCipherInfo,
+	getCiphers,
+	getCurves,
+	getDiffieHellman,
+	getFips,
+	getHashes,
+	hash,
+	hkdf,
+	hkdfSync,
+	pbkdf2,
+	pbkdf2Sync,
+	privateDecrypt,
+	privateEncrypt,
+	pseudoRandomBytes,
+	publicDecrypt,
+	prng,
+	publicEncrypt,
+	randomBytes,
+	randomFill,
+	randomFillSync,
+	randomInt,
+	rng,
+	scrypt,
+	scryptSync,
+	secureHeapUsed,
+	setEngine,
+	setFips,
+	sign,
+	timingSafeEqual,
+	verify,
+	webcrypto
+};

worker/node_modules/unenv/dist/runtime/node/dgram.d.mts

@@ -0,0 +1,6 @@
+import type nodeDgram from "node:dgram";
+export { Socket } from "./internal/dgram/socket.mjs";
+export declare const _createSocketHandle: unknown;
+export declare const createSocket: typeof nodeDgram.createSocket;
+declare const _default: typeof nodeDgram;
+export default _default;

worker/node_modules/unenv/dist/runtime/node/dgram.mjs

@@ -0,0 +1,12 @@
+import noop from "../mock/noop.mjs";
+import { Socket } from "./internal/dgram/socket.mjs";
+export { Socket } from "./internal/dgram/socket.mjs";
+export const _createSocketHandle = noop;
+export const createSocket = function() {
+	return new Socket();
+};
+export default {
+	Socket,
+	_createSocketHandle,
+	createSocket
+};

worker/node_modules/unenv/dist/runtime/node/diagnostics_channel.d.mts

@@ -0,0 +1,9 @@
+import type nodeDiagnosticsChannel from "node:diagnostics_channel";
+export { Channel } from "./internal/diagnostics_channel/channel.mjs";
+export declare const channel: typeof nodeDiagnosticsChannel.channel;
+export declare const hasSubscribers: typeof nodeDiagnosticsChannel.hasSubscribers;
+export declare const subscribe: typeof nodeDiagnosticsChannel.subscribe;
+export declare const unsubscribe: typeof nodeDiagnosticsChannel.unsubscribe;
+export declare const tracingChannel: typeof nodeDiagnosticsChannel.tracingChannel;
+declare const _default: {};
+export default _default;

worker/node_modules/unenv/dist/runtime/node/diagnostics_channel.mjs

@@ -0,0 +1,32 @@
+import { Channel, getChannels } from "./internal/diagnostics_channel/channel.mjs";
+import { TracingChannel } from "./internal/diagnostics_channel/tracing-channel.mjs";
+export { Channel } from "./internal/diagnostics_channel/channel.mjs";
+export const channel = function(name) {
+	const channels = getChannels();
+	if (name in channels) {
+		return channels[name];
+	}
+	return new Channel(name);
+};
+export const hasSubscribers = function(name) {
+	const channels = getChannels();
+	const channel = channels[name];
+	return channel && channel.hasSubscribers;
+};
+export const subscribe = function(name, onMessage) {
+	channel(name).subscribe(onMessage);
+};
+export const unsubscribe = function(name, onMessage) {
+	return channel(name).unsubscribe(onMessage);
+};
+export const tracingChannel = function(name) {
+	return new TracingChannel(name);
+};
+export default {
+	Channel,
+	channel,
+	hasSubscribers,
+	subscribe,
+	tracingChannel,
+	unsubscribe
+};

worker/node_modules/unenv/dist/runtime/node/dns.d.mts

@@ -0,0 +1,27 @@
+import type nodeDns from "node:dns";
+import promises from "node:dns/promises";
+export { promises };
+export declare const Resolver: typeof nodeDns.Resolver;
+export declare const getDefaultResultOrder: typeof nodeDns.getDefaultResultOrder;
+export declare const getServers: typeof nodeDns.getServers;
+export declare const lookup: typeof nodeDns.lookup;
+export declare const lookupService: typeof nodeDns.lookupService;
+export declare const resolve: typeof nodeDns.resolve;
+export declare const resolve4: typeof nodeDns.resolve4;
+export declare const resolve6: typeof nodeDns.resolve6;
+export declare const resolveAny: typeof nodeDns.resolveAny;
+export declare const resolveCaa: typeof nodeDns.resolveCaa;
+export declare const resolveCname: typeof nodeDns.resolveCname;
+export declare const resolveMx: typeof nodeDns.resolveMx;
+export declare const resolveNaptr: typeof nodeDns.resolveNaptr;
+export declare const resolveNs: typeof nodeDns.resolveNs;
+export declare const resolvePtr: typeof nodeDns.resolvePtr;
+export declare const resolveSoa: typeof nodeDns.resolveSoa;
+export declare const resolveSrv: typeof nodeDns.resolveSrv;
+export declare const resolveTxt: typeof nodeDns.resolveTxt;
+export declare const reverse: typeof nodeDns.reverse;
+export declare const setDefaultResultOrder: typeof nodeDns.setDefaultResultOrder;
+export declare const setServers: typeof nodeDns.setServers;
+export { NODATA, FORMERR, SERVFAIL, NOTFOUND, NOTIMP, REFUSED, BADQUERY, BADNAME, BADFAMILY, BADRESP, CONNREFUSED, TIMEOUT, EOF, FILE, NOMEM, DESTRUCTION, BADSTR, BADFLAGS, NONAME, BADHINTS, NOTINITIALIZED, LOADIPHLPAPI, ADDRGETNETWORKPARAMS, CANCELLED, ADDRCONFIG, ALL, V4MAPPED } from "./internal/dns/constants.mjs";
+declare const _default: {};
+export default _default;

worker/node_modules/unenv/dist/runtime/node/dns.mjs

@@ -0,0 +1,78 @@
+import noop from "../mock/noop.mjs";
+import { notImplemented, notImplementedAsync, notImplementedClass } from "../_internal/utils.mjs";
+import promises from "node:dns/promises";
+export { promises };
+export const Resolver = /*@__PURE__*/ notImplementedClass("dns.Resolver");
+export const getDefaultResultOrder = () => "verbatim";
+export const getServers = () => [];
+export const lookup = /*@__PURE__*/ notImplementedAsync("dns.lookup");
+export const lookupService = /*@__PURE__*/ notImplementedAsync("dns.lookupService");
+export const resolve = /*@__PURE__*/ notImplementedAsync("dns.resolve");
+export const resolve4 = /*@__PURE__*/ notImplementedAsync("dns.resolve4");
+export const resolve6 = /*@__PURE__*/ notImplementedAsync("dns.resolve6");
+export const resolveAny = /*@__PURE__*/ notImplementedAsync("dns.resolveAny");
+export const resolveCaa = /*@__PURE__*/ notImplementedAsync("dns.resolveCaa");
+export const resolveCname = /*@__PURE__*/ notImplementedAsync("dns.resolveCname");
+export const resolveMx = /*@__PURE__*/ notImplementedAsync("dns.resolveMx");
+export const resolveNaptr = /*@__PURE__*/ notImplementedAsync("dns.resolveNaptr");
+export const resolveNs = /*@__PURE__*/ notImplementedAsync("dns.resolveNs");
+export const resolvePtr = /*@__PURE__*/ notImplementedAsync("dns.resolvePtr");
+export const resolveSoa = /*@__PURE__*/ notImplementedAsync("dns.resolveSoa");
+export const resolveSrv = /*@__PURE__*/ notImplementedAsync("dns.resolveSrv");
+export const resolveTxt = /*@__PURE__*/ notImplementedAsync("dns.resolveTxt");
+export const reverse = /*@__PURE__*/ notImplemented("dns.reverse");
+export const setDefaultResultOrder = noop;
+export const setServers = noop;
+import { NODATA, FORMERR, SERVFAIL, NOTFOUND, NOTIMP, REFUSED, BADQUERY, BADNAME, BADFAMILY, BADRESP, CONNREFUSED, TIMEOUT, EOF, FILE, NOMEM, DESTRUCTION, BADSTR, BADFLAGS, NONAME, BADHINTS, NOTINITIALIZED, LOADIPHLPAPI, ADDRGETNETWORKPARAMS, CANCELLED, ADDRCONFIG, ALL, V4MAPPED } from "./internal/dns/constants.mjs";
+export { NODATA, FORMERR, SERVFAIL, NOTFOUND, NOTIMP, REFUSED, BADQUERY, BADNAME, BADFAMILY, BADRESP, CONNREFUSED, TIMEOUT, EOF, FILE, NOMEM, DESTRUCTION, BADSTR, BADFLAGS, NONAME, BADHINTS, NOTINITIALIZED, LOADIPHLPAPI, ADDRGETNETWORKPARAMS, CANCELLED, ADDRCONFIG, ALL, V4MAPPED } from "./internal/dns/constants.mjs";
+export default {
+	NODATA,
+	FORMERR,
+	SERVFAIL,
+	NOTFOUND,
+	NOTIMP,
+	REFUSED,
+	BADQUERY,
+	BADNAME,
+	BADFAMILY,
+	BADRESP,
+	CONNREFUSED,
+	TIMEOUT,
+	EOF,
+	FILE,
+	NOMEM,
+	DESTRUCTION,
+	BADSTR,
+	BADFLAGS,
+	NONAME,
+	BADHINTS,
+	NOTINITIALIZED,
+	LOADIPHLPAPI,
+	ADDRGETNETWORKPARAMS,
+	CANCELLED,
+	ADDRCONFIG,
+	ALL,
+	V4MAPPED,
+	Resolver,
+	getDefaultResultOrder,
+	getServers,
+	lookup,
+	lookupService,
+	promises,
+	resolve,
+	resolve4,
+	resolve6,
+	resolveAny,
+	resolveCaa,
+	resolveCname,
+	resolveMx,
+	resolveNaptr,
+	resolveNs,
+	resolvePtr,
+	resolveSoa,
+	resolveSrv,
+	resolveTxt,
+	reverse,
+	setDefaultResultOrder,
+	setServers
+};

worker/node_modules/unenv/dist/runtime/node/dns/promises.d.mts

@@ -0,0 +1,25 @@
+import type nodeDnsPromises from "node:dns/promises";
+export { NODATA, FORMERR, SERVFAIL, NOTFOUND, NOTIMP, REFUSED, BADQUERY, BADNAME, BADFAMILY, BADRESP, CONNREFUSED, TIMEOUT, EOF, FILE, NOMEM, DESTRUCTION, BADSTR, BADFLAGS, NONAME, BADHINTS, NOTINITIALIZED, LOADIPHLPAPI, ADDRGETNETWORKPARAMS, CANCELLED } from "../internal/dns/constants.mjs";
+export declare const Resolver: typeof nodeDnsPromises.Resolver;
+export declare const getDefaultResultOrder: typeof nodeDnsPromises.getDefaultResultOrder;
+export declare const getServers: typeof nodeDnsPromises.getServers;
+export declare const lookup: typeof nodeDnsPromises.lookup;
+export declare const lookupService: typeof nodeDnsPromises.lookupService;
+export declare const resolve: typeof nodeDnsPromises.resolve;
+export declare const resolve4: typeof nodeDnsPromises.resolve4;
+export declare const resolve6: typeof nodeDnsPromises.resolve6;
+export declare const resolveAny: typeof nodeDnsPromises.resolveAny;
+export declare const resolveCaa: typeof nodeDnsPromises.resolveCaa;
+export declare const resolveCname: typeof nodeDnsPromises.resolveCname;
+export declare const resolveMx: typeof nodeDnsPromises.resolveMx;
+export declare const resolveNaptr: typeof nodeDnsPromises.resolveNaptr;
+export declare const resolveNs: typeof nodeDnsPromises.resolveNs;
+export declare const resolvePtr: typeof nodeDnsPromises.resolvePtr;
+export declare const resolveSoa: typeof nodeDnsPromises.resolveSoa;
+export declare const resolveSrv: typeof nodeDnsPromises.resolveSrv;
+export declare const resolveTxt: typeof nodeDnsPromises.resolveTxt;
+export declare const reverse: typeof nodeDnsPromises.reverse;
+export declare const setDefaultResultOrder: typeof nodeDnsPromises.setDefaultResultOrder;
+export declare const setServers: typeof nodeDnsPromises.setServers;
+declare const _default: {};
+export default _default;

worker/node_modules/unenv/dist/runtime/node/dns/promises.mjs

@@ -0,0 +1,72 @@
+import noop from "../../mock/noop.mjs";
+import { notImplemented, notImplementedAsync, notImplementedClass } from "../../_internal/utils.mjs";
+import { NODATA, FORMERR, SERVFAIL, NOTFOUND, NOTIMP, REFUSED, BADQUERY, BADNAME, BADFAMILY, BADRESP, CONNREFUSED, TIMEOUT, EOF, FILE, NOMEM, DESTRUCTION, BADSTR, BADFLAGS, NONAME, BADHINTS, NOTINITIALIZED, LOADIPHLPAPI, ADDRGETNETWORKPARAMS, CANCELLED } from "../internal/dns/constants.mjs";
+export { NODATA, FORMERR, SERVFAIL, NOTFOUND, NOTIMP, REFUSED, BADQUERY, BADNAME, BADFAMILY, BADRESP, CONNREFUSED, TIMEOUT, EOF, FILE, NOMEM, DESTRUCTION, BADSTR, BADFLAGS, NONAME, BADHINTS, NOTINITIALIZED, LOADIPHLPAPI, ADDRGETNETWORKPARAMS, CANCELLED } from "../internal/dns/constants.mjs";
+export const Resolver = /*@__PURE__*/ notImplementedClass("dns.Resolver");
+export const getDefaultResultOrder = () => "verbatim";
+export const getServers = () => [];
+export const lookup = /*@__PURE__*/ notImplementedAsync("dns.lookup");
+export const lookupService = /*@__PURE__*/ notImplementedAsync("dns.lookupService");
+export const resolve = /*@__PURE__*/ notImplementedAsync("dns.resolve");
+export const resolve4 = /*@__PURE__*/ notImplementedAsync("dns.resolve4");
+export const resolve6 = /*@__PURE__*/ notImplementedAsync("dns.resolve6");
+export const resolveAny = /*@__PURE__*/ notImplementedAsync("dns.resolveAny");
+export const resolveCaa = /*@__PURE__*/ notImplementedAsync("dns.resolveCaa");
+export const resolveCname = /*@__PURE__*/ notImplementedAsync("dns.resolveCname");
+export const resolveMx = /*@__PURE__*/ notImplementedAsync("dns.resolveMx");
+export const resolveNaptr = /*@__PURE__*/ notImplementedAsync("dns.resolveNaptr");
+export const resolveNs = /*@__PURE__*/ notImplementedAsync("dns.resolveNs");
+export const resolvePtr = /*@__PURE__*/ notImplementedAsync("dns.resolvePtr");
+export const resolveSoa = /*@__PURE__*/ notImplementedAsync("dns.resolveSoa");
+export const resolveSrv = /*@__PURE__*/ notImplementedAsync("dns.resolveSrv");
+export const resolveTxt = /*@__PURE__*/ notImplementedAsync("dns.resolveTxt");
+export const reverse = /*@__PURE__*/ notImplemented("dns.reverse");
+export const setDefaultResultOrder = noop;
+export const setServers = noop;
+export default {
+	NODATA,
+	FORMERR,
+	SERVFAIL,
+	NOTFOUND,
+	NOTIMP,
+	REFUSED,
+	BADQUERY,
+	BADNAME,
+	BADFAMILY,
+	BADRESP,
+	CONNREFUSED,
+	TIMEOUT,
+	EOF,
+	FILE,
+	NOMEM,
+	DESTRUCTION,
+	BADSTR,
+	BADFLAGS,
+	NONAME,
+	BADHINTS,
+	NOTINITIALIZED,
+	LOADIPHLPAPI,
+	ADDRGETNETWORKPARAMS,
+	CANCELLED,
+	Resolver,
+	getDefaultResultOrder,
+	getServers,
+	lookup,
+	lookupService,
+	resolve,
+	resolve4,
+	resolve6,
+	resolveAny,
+	resolveCaa,
+	resolveCname,
+	resolveMx,
+	resolveNaptr,
+	resolveNs,
+	resolvePtr,
+	resolveSoa,
+	resolveSrv,
+	resolveTxt,
+	reverse,
+	setDefaultResultOrder,
+	setServers
+};

worker/node_modules/unenv/dist/runtime/node/domain.d.mts

@@ -0,0 +1,8 @@
+import type nodeDomain from "node:domain";
+export { Domain } from "./internal/domain/domain.mjs";
+export declare const create: typeof nodeDomain.create;
+export declare const createDomain: typeof nodeDomain.create;
+export declare const active: unknown;
+export declare const _stack: unknown;
+declare const _default: typeof nodeDomain;
+export default _default;

worker/node_modules/unenv/dist/runtime/node/domain.mjs

@@ -0,0 +1,16 @@
+import { Domain } from "./internal/domain/domain.mjs";
+export { Domain } from "./internal/domain/domain.mjs";
+export const create = function() {
+	return new Domain();
+};
+export const createDomain = create;
+const _domain = create();
+export const active = () => _domain;
+export const _stack = [];
+export default {
+	Domain,
+	_stack,
+	active,
+	create,
+	createDomain
+};

worker/node_modules/unenv/dist/runtime/node/events.d.mts

@@ -0,0 +1,12 @@
+import type nodeEvents from "node:events";
+export { _EventEmitter as EventEmitter, EventEmitterAsyncResource, addAbortListener, getEventListeners, getMaxListeners, on, once } from "./internal/events/events.mjs";
+export declare const usingDomains: boolean;
+export declare const captureRejectionSymbol: unknown;
+export declare const captureRejections: boolean;
+export declare const errorMonitor: unknown;
+export declare const defaultMaxListeners = 10;
+export declare const setMaxListeners: unknown;
+export declare const listenerCount: unknown;
+export declare const init: unknown;
+declare const _default: typeof nodeEvents;
+export default _default;

worker/node_modules/unenv/dist/runtime/node/events.mjs

@@ -0,0 +1,12 @@
+import { _EventEmitter } from "./internal/events/events.mjs";
+import { notImplemented } from "../_internal/utils.mjs";
+export { _EventEmitter as EventEmitter, EventEmitterAsyncResource, addAbortListener, getEventListeners, getMaxListeners, on, once } from "./internal/events/events.mjs";
+export const usingDomains = false;
+export const captureRejectionSymbol = /*@__PURE__*/ Symbol.for("nodejs.rejection");
+export const captureRejections = false;
+export const errorMonitor = /*@__PURE__*/ Symbol.for("events.errorMonitor");
+export const defaultMaxListeners = 10;
+export const setMaxListeners = /*@__PURE__*/ notImplemented("node:events.setMaxListeners");
+export const listenerCount = /*@__PURE__*/ notImplemented("node:events.listenerCount");
+export const init = /*@__PURE__*/ notImplemented("node:events.init");
+export default _EventEmitter;

worker/node_modules/unenv/dist/runtime/node/fs.d.mts

@@ -0,0 +1,10 @@
+import promises from "node:fs/promises";
+import * as constants from "./internal/fs/constants.mjs";
+export { F_OK, R_OK, W_OK, X_OK } from "./internal/fs/constants.mjs";
+export { promises, constants };
+export * from "./internal/fs/fs.mjs";
+export * from "./internal/fs/classes.mjs";
+declare const _default: {
+	constants: any
+};
+export default _default;

worker/node_modules/unenv/dist/runtime/node/fs.mjs

@@ -0,0 +1,117 @@
+import promises from "node:fs/promises";
+import { Dir, Dirent, FileReadStream, FileWriteStream, ReadStream, Stats, WriteStream } from "./internal/fs/classes.mjs";
+import { _toUnixTimestamp, access, accessSync, appendFile, appendFileSync, chmod, chmodSync, chown, chownSync, close, closeSync, copyFile, copyFileSync, cp, cpSync, createReadStream, createWriteStream, exists, existsSync, fchmod, fchmodSync, fchown, fchownSync, fdatasync, fdatasyncSync, fstat, fstatSync, fsync, fsyncSync, ftruncate, ftruncateSync, futimes, futimesSync, glob, lchmod, globSync, lchmodSync, lchown, lchownSync, link, linkSync, lstat, lstatSync, lutimes, lutimesSync, mkdir, mkdirSync, mkdtemp, mkdtempSync, open, openAsBlob, openSync, opendir, opendirSync, read, readFile, readFileSync, readSync, readdir, readdirSync, readlink, readlinkSync, readv, readvSync, realpath, realpathSync, rename, renameSync, rm, rmSync, rmdir, rmdirSync, stat, statSync, statfs, statfsSync, symlink, symlinkSync, truncate, truncateSync, unlink, unlinkSync, unwatchFile, utimes, utimesSync, watch, watchFile, write, writeFile, writeFileSync, writeSync, writev, writevSync } from "./internal/fs/fs.mjs";
+import * as constants from "./internal/fs/constants.mjs";
+import { F_OK, R_OK, W_OK, X_OK } from "./internal/fs/constants.mjs";
+export { F_OK, R_OK, W_OK, X_OK } from "./internal/fs/constants.mjs";
+export { promises, constants };
+export * from "./internal/fs/fs.mjs";
+export * from "./internal/fs/classes.mjs";
+export default {
+	F_OK,
+	R_OK,
+	W_OK,
+	X_OK,
+	constants,
+	promises,
+	Dir,
+	Dirent,
+	FileReadStream,
+	FileWriteStream,
+	ReadStream,
+	Stats,
+	WriteStream,
+	_toUnixTimestamp,
+	access,
+	accessSync,
+	appendFile,
+	appendFileSync,
+	chmod,
+	chmodSync,
+	chown,
+	chownSync,
+	close,
+	closeSync,
+	copyFile,
+	copyFileSync,
+	cp,
+	cpSync,
+	createReadStream,
+	createWriteStream,
+	exists,
+	existsSync,
+	fchmod,
+	fchmodSync,
+	fchown,
+	fchownSync,
+	fdatasync,
+	fdatasyncSync,
+	fstat,
+	fstatSync,
+	fsync,
+	fsyncSync,
+	ftruncate,
+	ftruncateSync,
+	futimes,
+	futimesSync,
+	glob,
+	lchmod,
+	globSync,
+	lchmodSync,
+	lchown,
+	lchownSync,
+	link,
+	linkSync,
+	lstat,
+	lstatSync,
+	lutimes,
+	lutimesSync,
+	mkdir,
+	mkdirSync,
+	mkdtemp,
+	mkdtempSync,
+	open,
+	openAsBlob,
+	openSync,
+	opendir,
+	opendirSync,
+	read,
+	readFile,
+	readFileSync,
+	readSync,
+	readdir,
+	readdirSync,
+	readlink,
+	readlinkSync,
+	readv,
+	readvSync,
+	realpath,
+	realpathSync,
+	rename,
+	renameSync,
+	rm,
+	rmSync,
+	rmdir,
+	rmdirSync,
+	stat,
+	statSync,
+	statfs,
+	statfsSync,
+	symlink,
+	symlinkSync,
+	truncate,
+	truncateSync,
+	unlink,
+	unlinkSync,
+	unwatchFile,
+	utimes,
+	utimesSync,
+	watch,
+	watchFile,
+	write,
+	writeFile,
+	writeFileSync,
+	writeSync,
+	writev,
+	writevSync
+};

worker/node_modules/unenv/dist/runtime/node/fs/promises.d.mts

@@ -0,0 +1,7 @@
+import * as constants from "../internal/fs/constants.mjs";
+export { constants };
+export * from "../internal/fs/promises.mjs";
+declare const _default: {
+	constants: any
+};
+export default _default;

worker/node_modules/unenv/dist/runtime/node/fs/promises.mjs

@@ -0,0 +1,38 @@
+import { access, appendFile, chmod, chown, copyFile, cp, glob, lchmod, lchown, link, lstat, lutimes, mkdir, mkdtemp, open, opendir, readFile, readdir, readlink, realpath, rename, rm, rmdir, stat, statfs, symlink, truncate, unlink, utimes, watch, writeFile } from "../internal/fs/promises.mjs";
+import * as constants from "../internal/fs/constants.mjs";
+export { constants };
+export * from "../internal/fs/promises.mjs";
+export default {
+	constants,
+	access,
+	appendFile,
+	chmod,
+	chown,
+	copyFile,
+	cp,
+	glob,
+	lchmod,
+	lchown,
+	link,
+	lstat,
+	lutimes,
+	mkdir,
+	mkdtemp,
+	open,
+	opendir,
+	readFile,
+	readdir,
+	readlink,
+	realpath,
+	rename,
+	rm,
+	rmdir,
+	stat,
+	statfs,
+	symlink,
+	truncate,
+	unlink,
+	utimes,
+	watch,
+	writeFile
+};

worker/node_modules/unenv/dist/runtime/node/http.d.mts

@@ -0,0 +1,22 @@
+import type nodeHttp from "node:http";
+import { METHODS, STATUS_CODES, maxHeaderSize } from "./internal/http/constants.mjs";
+export { METHODS, STATUS_CODES, maxHeaderSize };
+export * from "./internal/http/request.mjs";
+export * from "./internal/http/response.mjs";
+export { Agent } from "./internal/http/agent.mjs";
+export declare const createServer: unknown;
+export declare const request: unknown;
+export declare const get: unknown;
+export declare const Server: typeof nodeHttp.Server;
+export declare const OutgoingMessage: typeof nodeHttp.OutgoingMessage;
+export declare const ClientRequest: typeof nodeHttp.ClientRequest;
+export declare const globalAgent: typeof nodeHttp.globalAgent;
+export declare const validateHeaderName: unknown;
+export declare const validateHeaderValue: unknown;
+export declare const setMaxIdleHTTPParsers: unknown;
+export declare const _connectionListener: unknown;
+export declare const WebSocket: unknown;
+export declare const CloseEvent: unknown;
+export declare const MessageEvent: unknown;
+declare const _default: typeof nodeHttp;
+export default _default;

worker/node_modules/unenv/dist/runtime/node/http.mjs

@@ -0,0 +1,45 @@
+import { notImplemented, notImplementedClass } from "../_internal/utils.mjs";
+import { IncomingMessage } from "./internal/http/request.mjs";
+import { ServerResponse } from "./internal/http/response.mjs";
+import { Agent } from "./internal/http/agent.mjs";
+import { METHODS, STATUS_CODES, maxHeaderSize } from "./internal/http/constants.mjs";
+export { METHODS, STATUS_CODES, maxHeaderSize };
+export * from "./internal/http/request.mjs";
+export * from "./internal/http/response.mjs";
+export { Agent } from "./internal/http/agent.mjs";
+export const createServer = /*@__PURE__*/ notImplemented("http.createServer");
+export const request = /*@__PURE__*/ notImplemented("http.request");
+export const get = /*@__PURE__*/ notImplemented("http.get");
+export const Server = /*@__PURE__*/ notImplementedClass("http.Server");
+export const OutgoingMessage = /*@__PURE__*/ notImplementedClass("http.OutgoingMessage");
+export const ClientRequest = /*@__PURE__*/ notImplementedClass("http.ClientRequest");
+export const globalAgent = new Agent();
+export const validateHeaderName = /*@__PURE__*/ notImplemented("http.validateHeaderName");
+export const validateHeaderValue = /*@__PURE__*/ notImplemented("http.validateHeaderValue");
+export const setMaxIdleHTTPParsers = /*@__PURE__*/ notImplemented("http.setMaxIdleHTTPParsers");
+export const _connectionListener = /*@__PURE__*/ notImplemented("http._connectionListener");
+export const WebSocket = globalThis.WebSocket || /*@__PURE__*/ notImplementedClass("WebSocket");
+export const CloseEvent = globalThis.CloseEvent || /*@__PURE__*/ notImplementedClass("CloseEvent");
+export const MessageEvent = globalThis.MessageEvent || /*@__PURE__*/ notImplementedClass("MessageEvent");
+export default {
+	METHODS,
+	STATUS_CODES,
+	maxHeaderSize,
+	IncomingMessage,
+	ServerResponse,
+	WebSocket,
+	CloseEvent,
+	MessageEvent,
+	createServer,
+	request,
+	get,
+	Server,
+	OutgoingMessage,
+	ClientRequest,
+	Agent,
+	globalAgent,
+	validateHeaderName,
+	validateHeaderValue,
+	setMaxIdleHTTPParsers,
+	_connectionListener
+};

worker/node_modules/unenv/dist/runtime/node/http2.d.mts

@@ -0,0 +1,14 @@
+import type nodeHttp2 from "node:http2";
+export declare const constants: typeof nodeHttp2.constants;
+export declare const createSecureServer: unknown;
+export declare const createServer: unknown;
+export declare const connect: typeof nodeHttp2.connect;
+export declare const performServerHandshake: typeof nodeHttp2.performServerHandshake;
+export declare const Http2ServerRequest: typeof nodeHttp2.Http2ServerRequest;
+export declare const Http2ServerResponse: typeof nodeHttp2.Http2ServerResponse;
+export declare const getDefaultSettings: typeof nodeHttp2.getDefaultSettings;
+export declare const getPackedSettings: typeof nodeHttp2.getPackedSettings;
+export declare const getUnpackedSettings: typeof nodeHttp2.getUnpackedSettings;
+export declare const sensitiveHeaders: typeof nodeHttp2.sensitiveHeaders;
+declare const _default: {};
+export default _default;

worker/node_modules/unenv/dist/runtime/node/http2.mjs

@@ -0,0 +1,282 @@
+import { notImplemented, notImplementedClass } from "../_internal/utils.mjs";
+import { NGHTTP2_ERR_FRAME_SIZE_ERROR, NGHTTP2_SESSION_SERVER, NGHTTP2_SESSION_CLIENT, NGHTTP2_STREAM_STATE_IDLE, NGHTTP2_STREAM_STATE_OPEN, NGHTTP2_STREAM_STATE_RESERVED_LOCAL, NGHTTP2_STREAM_STATE_RESERVED_REMOTE, NGHTTP2_STREAM_STATE_HALF_CLOSED_LOCAL, NGHTTP2_STREAM_STATE_HALF_CLOSED_REMOTE, NGHTTP2_STREAM_STATE_CLOSED, NGHTTP2_FLAG_NONE, NGHTTP2_FLAG_END_STREAM, NGHTTP2_FLAG_END_HEADERS, NGHTTP2_FLAG_ACK, NGHTTP2_FLAG_PADDED, NGHTTP2_FLAG_PRIORITY, DEFAULT_SETTINGS_HEADER_TABLE_SIZE, DEFAULT_SETTINGS_ENABLE_PUSH, DEFAULT_SETTINGS_MAX_CONCURRENT_STREAMS, DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE, DEFAULT_SETTINGS_MAX_FRAME_SIZE, DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE, DEFAULT_SETTINGS_ENABLE_CONNECT_PROTOCOL, MAX_MAX_FRAME_SIZE, MIN_MAX_FRAME_SIZE, MAX_INITIAL_WINDOW_SIZE, NGHTTP2_SETTINGS_HEADER_TABLE_SIZE, NGHTTP2_SETTINGS_ENABLE_PUSH, NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS, NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE, NGHTTP2_SETTINGS_MAX_FRAME_SIZE, NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE, NGHTTP2_SETTINGS_ENABLE_CONNECT_PROTOCOL, PADDING_STRATEGY_NONE, PADDING_STRATEGY_ALIGNED, PADDING_STRATEGY_MAX, PADDING_STRATEGY_CALLBACK, NGHTTP2_NO_ERROR, NGHTTP2_PROTOCOL_ERROR, NGHTTP2_INTERNAL_ERROR, NGHTTP2_FLOW_CONTROL_ERROR, NGHTTP2_SETTINGS_TIMEOUT, NGHTTP2_STREAM_CLOSED, NGHTTP2_FRAME_SIZE_ERROR, NGHTTP2_REFUSED_STREAM, NGHTTP2_CANCEL, NGHTTP2_COMPRESSION_ERROR, NGHTTP2_CONNECT_ERROR, NGHTTP2_ENHANCE_YOUR_CALM, NGHTTP2_INADEQUATE_SECURITY, NGHTTP2_HTTP_1_1_REQUIRED, NGHTTP2_DEFAULT_WEIGHT, HTTP2_HEADER_STATUS, HTTP2_HEADER_METHOD, HTTP2_HEADER_AUTHORITY, HTTP2_HEADER_SCHEME, HTTP2_HEADER_PATH, HTTP2_HEADER_PROTOCOL, HTTP2_HEADER_ACCEPT_ENCODING, HTTP2_HEADER_ACCEPT_LANGUAGE, HTTP2_HEADER_ACCEPT_RANGES, HTTP2_HEADER_ACCEPT, HTTP2_HEADER_ACCESS_CONTROL_ALLOW_CREDENTIALS, HTTP2_HEADER_ACCESS_CONTROL_ALLOW_HEADERS, HTTP2_HEADER_ACCESS_CONTROL_ALLOW_METHODS, HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN, HTTP2_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS, HTTP2_HEADER_ACCESS_CONTROL_REQUEST_HEADERS, HTTP2_HEADER_ACCESS_CONTROL_REQUEST_METHOD, HTTP2_HEADER_AGE, HTTP2_HEADER_AUTHORIZATION, HTTP2_HEADER_CACHE_CONTROL, HTTP2_HEADER_CONNECTION, HTTP2_HEADER_CONTENT_DISPOSITION, HTTP2_HEADER_CONTENT_ENCODING, HTTP2_HEADER_CONTENT_LENGTH, HTTP2_HEADER_CONTENT_TYPE, HTTP2_HEADER_COOKIE, HTTP2_HEADER_DATE, HTTP2_HEADER_ETAG, HTTP2_HEADER_FORWARDED, HTTP2_HEADER_HOST, HTTP2_HEADER_IF_MODIFIED_SINCE, HTTP2_HEADER_IF_NONE_MATCH, HTTP2_HEADER_IF_RANGE, HTTP2_HEADER_LAST_MODIFIED, HTTP2_HEADER_LINK, HTTP2_HEADER_LOCATION, HTTP2_HEADER_RANGE, HTTP2_HEADER_REFERER, HTTP2_HEADER_SERVER, HTTP2_HEADER_SET_COOKIE, HTTP2_HEADER_STRICT_TRANSPORT_SECURITY, HTTP2_HEADER_TRANSFER_ENCODING, HTTP2_HEADER_TE, HTTP2_HEADER_UPGRADE_INSECURE_REQUESTS, HTTP2_HEADER_UPGRADE, HTTP2_HEADER_USER_AGENT, HTTP2_HEADER_VARY, HTTP2_HEADER_X_CONTENT_TYPE_OPTIONS, HTTP2_HEADER_X_FRAME_OPTIONS, HTTP2_HEADER_KEEP_ALIVE, HTTP2_HEADER_PROXY_CONNECTION, HTTP2_HEADER_X_XSS_PROTECTION, HTTP2_HEADER_ALT_SVC, HTTP2_HEADER_CONTENT_SECURITY_POLICY, HTTP2_HEADER_EARLY_DATA, HTTP2_HEADER_EXPECT_CT, HTTP2_HEADER_ORIGIN, HTTP2_HEADER_PURPOSE, HTTP2_HEADER_TIMING_ALLOW_ORIGIN, HTTP2_HEADER_X_FORWARDED_FOR, HTTP2_HEADER_PRIORITY, HTTP2_HEADER_ACCEPT_CHARSET, HTTP2_HEADER_ACCESS_CONTROL_MAX_AGE, HTTP2_HEADER_ALLOW, HTTP2_HEADER_CONTENT_LANGUAGE, HTTP2_HEADER_CONTENT_LOCATION, HTTP2_HEADER_CONTENT_MD5, HTTP2_HEADER_CONTENT_RANGE, HTTP2_HEADER_DNT, HTTP2_HEADER_EXPECT, HTTP2_HEADER_EXPIRES, HTTP2_HEADER_FROM, HTTP2_HEADER_IF_MATCH, HTTP2_HEADER_IF_UNMODIFIED_SINCE, HTTP2_HEADER_MAX_FORWARDS, HTTP2_HEADER_PREFER, HTTP2_HEADER_PROXY_AUTHENTICATE, HTTP2_HEADER_PROXY_AUTHORIZATION, HTTP2_HEADER_REFRESH, HTTP2_HEADER_RETRY_AFTER, HTTP2_HEADER_TRAILER, HTTP2_HEADER_TK, HTTP2_HEADER_VIA, HTTP2_HEADER_WARNING, HTTP2_HEADER_WWW_AUTHENTICATE, HTTP2_HEADER_HTTP2_SETTINGS, HTTP2_METHOD_ACL, HTTP2_METHOD_BASELINE_CONTROL, HTTP2_METHOD_BIND, HTTP2_METHOD_CHECKIN, HTTP2_METHOD_CHECKOUT, HTTP2_METHOD_CONNECT, HTTP2_METHOD_COPY, HTTP2_METHOD_DELETE, HTTP2_METHOD_GET, HTTP2_METHOD_HEAD, HTTP2_METHOD_LABEL, HTTP2_METHOD_LINK, HTTP2_METHOD_LOCK, HTTP2_METHOD_MERGE, HTTP2_METHOD_MKACTIVITY, HTTP2_METHOD_MKCALENDAR, HTTP2_METHOD_MKCOL, HTTP2_METHOD_MKREDIRECTREF, HTTP2_METHOD_MKWORKSPACE, HTTP2_METHOD_MOVE, HTTP2_METHOD_OPTIONS, HTTP2_METHOD_ORDERPATCH, HTTP2_METHOD_PATCH, HTTP2_METHOD_POST, HTTP2_METHOD_PRI, HTTP2_METHOD_PROPFIND, HTTP2_METHOD_PROPPATCH, HTTP2_METHOD_PUT, HTTP2_METHOD_REBIND, HTTP2_METHOD_REPORT, HTTP2_METHOD_SEARCH, HTTP2_METHOD_TRACE, HTTP2_METHOD_UNBIND, HTTP2_METHOD_UNCHECKOUT, HTTP2_METHOD_UNLINK, HTTP2_METHOD_UNLOCK, HTTP2_METHOD_UPDATE, HTTP2_METHOD_UPDATEREDIRECTREF, HTTP2_METHOD_VERSION_CONTROL, HTTP_STATUS_CONTINUE, HTTP_STATUS_SWITCHING_PROTOCOLS, HTTP_STATUS_PROCESSING, HTTP_STATUS_EARLY_HINTS, HTTP_STATUS_OK, HTTP_STATUS_CREATED, HTTP_STATUS_ACCEPTED, HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION, HTTP_STATUS_NO_CONTENT, HTTP_STATUS_RESET_CONTENT, HTTP_STATUS_PARTIAL_CONTENT, HTTP_STATUS_MULTI_STATUS, HTTP_STATUS_ALREADY_REPORTED, HTTP_STATUS_IM_USED, HTTP_STATUS_MULTIPLE_CHOICES, HTTP_STATUS_MOVED_PERMANENTLY, HTTP_STATUS_FOUND, HTTP_STATUS_SEE_OTHER, HTTP_STATUS_NOT_MODIFIED, HTTP_STATUS_USE_PROXY, HTTP_STATUS_TEMPORARY_REDIRECT, HTTP_STATUS_PERMANENT_REDIRECT, HTTP_STATUS_BAD_REQUEST, HTTP_STATUS_UNAUTHORIZED, HTTP_STATUS_PAYMENT_REQUIRED, HTTP_STATUS_FORBIDDEN, HTTP_STATUS_NOT_FOUND, HTTP_STATUS_METHOD_NOT_ALLOWED, HTTP_STATUS_NOT_ACCEPTABLE, HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED, HTTP_STATUS_REQUEST_TIMEOUT, HTTP_STATUS_CONFLICT, HTTP_STATUS_GONE, HTTP_STATUS_LENGTH_REQUIRED, HTTP_STATUS_PRECONDITION_FAILED, HTTP_STATUS_PAYLOAD_TOO_LARGE, HTTP_STATUS_URI_TOO_LONG, HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE, HTTP_STATUS_RANGE_NOT_SATISFIABLE, HTTP_STATUS_EXPECTATION_FAILED, HTTP_STATUS_TEAPOT, HTTP_STATUS_MISDIRECTED_REQUEST, HTTP_STATUS_UNPROCESSABLE_ENTITY, HTTP_STATUS_LOCKED, HTTP_STATUS_FAILED_DEPENDENCY, HTTP_STATUS_TOO_EARLY, HTTP_STATUS_UPGRADE_REQUIRED, HTTP_STATUS_PRECONDITION_REQUIRED, HTTP_STATUS_TOO_MANY_REQUESTS, HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE, HTTP_STATUS_UNAVAILABLE_FOR_LEGAL_REASONS, HTTP_STATUS_INTERNAL_SERVER_ERROR, HTTP_STATUS_NOT_IMPLEMENTED, HTTP_STATUS_BAD_GATEWAY, HTTP_STATUS_SERVICE_UNAVAILABLE, HTTP_STATUS_GATEWAY_TIMEOUT, HTTP_STATUS_HTTP_VERSION_NOT_SUPPORTED, HTTP_STATUS_VARIANT_ALSO_NEGOTIATES, HTTP_STATUS_INSUFFICIENT_STORAGE, HTTP_STATUS_LOOP_DETECTED, HTTP_STATUS_BANDWIDTH_LIMIT_EXCEEDED, HTTP_STATUS_NOT_EXTENDED, HTTP_STATUS_NETWORK_AUTHENTICATION_REQUIRED } from "./internal/http2/constants.mjs";
+export const constants = {
+	NGHTTP2_ERR_FRAME_SIZE_ERROR,
+	NGHTTP2_SESSION_SERVER,
+	NGHTTP2_SESSION_CLIENT,
+	NGHTTP2_STREAM_STATE_IDLE,
+	NGHTTP2_STREAM_STATE_OPEN,
+	NGHTTP2_STREAM_STATE_RESERVED_LOCAL,
+	NGHTTP2_STREAM_STATE_RESERVED_REMOTE,
+	NGHTTP2_STREAM_STATE_HALF_CLOSED_LOCAL,
+	NGHTTP2_STREAM_STATE_HALF_CLOSED_REMOTE,
+	NGHTTP2_STREAM_STATE_CLOSED,
+	NGHTTP2_FLAG_NONE,
+	NGHTTP2_FLAG_END_STREAM,
+	NGHTTP2_FLAG_END_HEADERS,
+	NGHTTP2_FLAG_ACK,
+	NGHTTP2_FLAG_PADDED,
+	NGHTTP2_FLAG_PRIORITY,
+	DEFAULT_SETTINGS_HEADER_TABLE_SIZE,
+	DEFAULT_SETTINGS_ENABLE_PUSH,
+	DEFAULT_SETTINGS_MAX_CONCURRENT_STREAMS,
+	DEFAULT_SETTINGS_INITIAL_WINDOW_SIZE,
+	DEFAULT_SETTINGS_MAX_FRAME_SIZE,
+	DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE,
+	DEFAULT_SETTINGS_ENABLE_CONNECT_PROTOCOL,
+	MAX_MAX_FRAME_SIZE,
+	MIN_MAX_FRAME_SIZE,
+	MAX_INITIAL_WINDOW_SIZE,
+	NGHTTP2_SETTINGS_HEADER_TABLE_SIZE,
+	NGHTTP2_SETTINGS_ENABLE_PUSH,
+	NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS,
+	NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE,
+	NGHTTP2_SETTINGS_MAX_FRAME_SIZE,
+	NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE,
+	NGHTTP2_SETTINGS_ENABLE_CONNECT_PROTOCOL,
+	PADDING_STRATEGY_NONE,
+	PADDING_STRATEGY_ALIGNED,
+	PADDING_STRATEGY_MAX,
+	PADDING_STRATEGY_CALLBACK,
+	NGHTTP2_NO_ERROR,
+	NGHTTP2_PROTOCOL_ERROR,
+	NGHTTP2_INTERNAL_ERROR,
+	NGHTTP2_FLOW_CONTROL_ERROR,
+	NGHTTP2_SETTINGS_TIMEOUT,
+	NGHTTP2_STREAM_CLOSED,
+	NGHTTP2_FRAME_SIZE_ERROR,
+	NGHTTP2_REFUSED_STREAM,
+	NGHTTP2_CANCEL,
+	NGHTTP2_COMPRESSION_ERROR,
+	NGHTTP2_CONNECT_ERROR,
+	NGHTTP2_ENHANCE_YOUR_CALM,
+	NGHTTP2_INADEQUATE_SECURITY,
+	NGHTTP2_HTTP_1_1_REQUIRED,
+	NGHTTP2_DEFAULT_WEIGHT,
+	HTTP2_HEADER_STATUS,
+	HTTP2_HEADER_METHOD,
+	HTTP2_HEADER_AUTHORITY,
+	HTTP2_HEADER_SCHEME,
+	HTTP2_HEADER_PATH,
+	HTTP2_HEADER_PROTOCOL,
+	HTTP2_HEADER_ACCEPT_ENCODING,
+	HTTP2_HEADER_ACCEPT_LANGUAGE,
+	HTTP2_HEADER_ACCEPT_RANGES,
+	HTTP2_HEADER_ACCEPT,
+	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_CREDENTIALS,
+	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_HEADERS,
+	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_METHODS,
+	HTTP2_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
+	HTTP2_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS,
+	HTTP2_HEADER_ACCESS_CONTROL_REQUEST_HEADERS,
+	HTTP2_HEADER_ACCESS_CONTROL_REQUEST_METHOD,
+	HTTP2_HEADER_AGE,
+	HTTP2_HEADER_AUTHORIZATION,
+	HTTP2_HEADER_CACHE_CONTROL,
+	HTTP2_HEADER_CONNECTION,
+	HTTP2_HEADER_CONTENT_DISPOSITION,
+	HTTP2_HEADER_CONTENT_ENCODING,
+	HTTP2_HEADER_CONTENT_LENGTH,
+	HTTP2_HEADER_CONTENT_TYPE,
+	HTTP2_HEADER_COOKIE,
+	HTTP2_HEADER_DATE,
+	HTTP2_HEADER_ETAG,
+	HTTP2_HEADER_FORWARDED,
+	HTTP2_HEADER_HOST,
+	HTTP2_HEADER_IF_MODIFIED_SINCE,
+	HTTP2_HEADER_IF_NONE_MATCH,
+	HTTP2_HEADER_IF_RANGE,
+	HTTP2_HEADER_LAST_MODIFIED,
+	HTTP2_HEADER_LINK,
+	HTTP2_HEADER_LOCATION,
+	HTTP2_HEADER_RANGE,
+	HTTP2_HEADER_REFERER,
+	HTTP2_HEADER_SERVER,
+	HTTP2_HEADER_SET_COOKIE,
+	HTTP2_HEADER_STRICT_TRANSPORT_SECURITY,
+	HTTP2_HEADER_TRANSFER_ENCODING,
+	HTTP2_HEADER_TE,
+	HTTP2_HEADER_UPGRADE_INSECURE_REQUESTS,
+	HTTP2_HEADER_UPGRADE,
+	HTTP2_HEADER_USER_AGENT,
+	HTTP2_HEADER_VARY,
+	HTTP2_HEADER_X_CONTENT_TYPE_OPTIONS,
+	HTTP2_HEADER_X_FRAME_OPTIONS,
+	HTTP2_HEADER_KEEP_ALIVE,
+	HTTP2_HEADER_PROXY_CONNECTION,
+	HTTP2_HEADER_X_XSS_PROTECTION,
+	HTTP2_HEADER_ALT_SVC,
+	HTTP2_HEADER_CONTENT_SECURITY_POLICY,
+	HTTP2_HEADER_EARLY_DATA,
+	HTTP2_HEADER_EXPECT_CT,
+	HTTP2_HEADER_ORIGIN,
+	HTTP2_HEADER_PURPOSE,
+	HTTP2_HEADER_TIMING_ALLOW_ORIGIN,
+	HTTP2_HEADER_X_FORWARDED_FOR,
+	HTTP2_HEADER_PRIORITY,
+	HTTP2_HEADER_ACCEPT_CHARSET,
+	HTTP2_HEADER_ACCESS_CONTROL_MAX_AGE,
+	HTTP2_HEADER_ALLOW,
+	HTTP2_HEADER_CONTENT_LANGUAGE,
+	HTTP2_HEADER_CONTENT_LOCATION,
+	HTTP2_HEADER_CONTENT_MD5,
+	HTTP2_HEADER_CONTENT_RANGE,
+	HTTP2_HEADER_DNT,
+	HTTP2_HEADER_EXPECT,
+	HTTP2_HEADER_EXPIRES,
+	HTTP2_HEADER_FROM,
+	HTTP2_HEADER_IF_MATCH,
+	HTTP2_HEADER_IF_UNMODIFIED_SINCE,
+	HTTP2_HEADER_MAX_FORWARDS,
+	HTTP2_HEADER_PREFER,
+	HTTP2_HEADER_PROXY_AUTHENTICATE,
+	HTTP2_HEADER_PROXY_AUTHORIZATION,
+	HTTP2_HEADER_REFRESH,
+	HTTP2_HEADER_RETRY_AFTER,
+	HTTP2_HEADER_TRAILER,
+	HTTP2_HEADER_TK,
+	HTTP2_HEADER_VIA,
+	HTTP2_HEADER_WARNING,
+	HTTP2_HEADER_WWW_AUTHENTICATE,
+	HTTP2_HEADER_HTTP2_SETTINGS,
+	HTTP2_METHOD_ACL,
+	HTTP2_METHOD_BASELINE_CONTROL,
+	HTTP2_METHOD_BIND,
+	HTTP2_METHOD_CHECKIN,
+	HTTP2_METHOD_CHECKOUT,
+	HTTP2_METHOD_CONNECT,
+	HTTP2_METHOD_COPY,
+	HTTP2_METHOD_DELETE,
+	HTTP2_METHOD_GET,
+	HTTP2_METHOD_HEAD,
+	HTTP2_METHOD_LABEL,
+	HTTP2_METHOD_LINK,
+	HTTP2_METHOD_LOCK,
+	HTTP2_METHOD_MERGE,
+	HTTP2_METHOD_MKACTIVITY,
+	HTTP2_METHOD_MKCALENDAR,
+	HTTP2_METHOD_MKCOL,
+	HTTP2_METHOD_MKREDIRECTREF,
+	HTTP2_METHOD_MKWORKSPACE,
+	HTTP2_METHOD_MOVE,
+	HTTP2_METHOD_OPTIONS,
+	HTTP2_METHOD_ORDERPATCH,
+	HTTP2_METHOD_PATCH,
+	HTTP2_METHOD_POST,
+	HTTP2_METHOD_PRI,
+	HTTP2_METHOD_PROPFIND,
+	HTTP2_METHOD_PROPPATCH,
+	HTTP2_METHOD_PUT,
+	HTTP2_METHOD_REBIND,
+	HTTP2_METHOD_REPORT,
+	HTTP2_METHOD_SEARCH,
+	HTTP2_METHOD_TRACE,
+	HTTP2_METHOD_UNBIND,
+	HTTP2_METHOD_UNCHECKOUT,
+	HTTP2_METHOD_UNLINK,
+	HTTP2_METHOD_UNLOCK,
+	HTTP2_METHOD_UPDATE,
+	HTTP2_METHOD_UPDATEREDIRECTREF,
+	HTTP2_METHOD_VERSION_CONTROL,
+	HTTP_STATUS_CONTINUE,
+	HTTP_STATUS_SWITCHING_PROTOCOLS,
+	HTTP_STATUS_PROCESSING,
+	HTTP_STATUS_EARLY_HINTS,
+	HTTP_STATUS_OK,
+	HTTP_STATUS_CREATED,
+	HTTP_STATUS_ACCEPTED,
+	HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION,
+	HTTP_STATUS_NO_CONTENT,
+	HTTP_STATUS_RESET_CONTENT,
+	HTTP_STATUS_PARTIAL_CONTENT,
+	HTTP_STATUS_MULTI_STATUS,
+	HTTP_STATUS_ALREADY_REPORTED,
+	HTTP_STATUS_IM_USED,
+	HTTP_STATUS_MULTIPLE_CHOICES,
+	HTTP_STATUS_MOVED_PERMANENTLY,
+	HTTP_STATUS_FOUND,
+	HTTP_STATUS_SEE_OTHER,
+	HTTP_STATUS_NOT_MODIFIED,
+	HTTP_STATUS_USE_PROXY,
+	HTTP_STATUS_TEMPORARY_REDIRECT,
+	HTTP_STATUS_PERMANENT_REDIRECT,
+	HTTP_STATUS_BAD_REQUEST,
+	HTTP_STATUS_UNAUTHORIZED,
+	HTTP_STATUS_PAYMENT_REQUIRED,
+	HTTP_STATUS_FORBIDDEN,
+	HTTP_STATUS_NOT_FOUND,
+	HTTP_STATUS_METHOD_NOT_ALLOWED,
+	HTTP_STATUS_NOT_ACCEPTABLE,
+	HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED,
+	HTTP_STATUS_REQUEST_TIMEOUT,
+	HTTP_STATUS_CONFLICT,
+	HTTP_STATUS_GONE,
+	HTTP_STATUS_LENGTH_REQUIRED,
+	HTTP_STATUS_PRECONDITION_FAILED,
+	HTTP_STATUS_PAYLOAD_TOO_LARGE,
+	HTTP_STATUS_URI_TOO_LONG,
+	HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE,
+	HTTP_STATUS_RANGE_NOT_SATISFIABLE,
+	HTTP_STATUS_EXPECTATION_FAILED,
+	HTTP_STATUS_TEAPOT,
+	HTTP_STATUS_MISDIRECTED_REQUEST,
+	HTTP_STATUS_UNPROCESSABLE_ENTITY,
+	HTTP_STATUS_LOCKED,
+	HTTP_STATUS_FAILED_DEPENDENCY,
+	HTTP_STATUS_TOO_EARLY,
+	HTTP_STATUS_UPGRADE_REQUIRED,
+	HTTP_STATUS_PRECONDITION_REQUIRED,
+	HTTP_STATUS_TOO_MANY_REQUESTS,
+	HTTP_STATUS_REQUEST_HEADER_FIELDS_TOO_LARGE,
+	HTTP_STATUS_UNAVAILABLE_FOR_LEGAL_REASONS,
+	HTTP_STATUS_INTERNAL_SERVER_ERROR,
+	HTTP_STATUS_NOT_IMPLEMENTED,
+	HTTP_STATUS_BAD_GATEWAY,
+	HTTP_STATUS_SERVICE_UNAVAILABLE,
+	HTTP_STATUS_GATEWAY_TIMEOUT,
+	HTTP_STATUS_HTTP_VERSION_NOT_SUPPORTED,
+	HTTP_STATUS_VARIANT_ALSO_NEGOTIATES,
+	HTTP_STATUS_INSUFFICIENT_STORAGE,
+	HTTP_STATUS_LOOP_DETECTED,
+	HTTP_STATUS_BANDWIDTH_LIMIT_EXCEEDED,
+	HTTP_STATUS_NOT_EXTENDED,
+	HTTP_STATUS_NETWORK_AUTHENTICATION_REQUIRED
+};
+export const createSecureServer = /*@__PURE__*/ notImplemented("http2.createSecureServer");
+export const createServer = /*@__PURE__*/ notImplemented("http2.createServer");
+export const connect = /*@__PURE__*/ notImplemented("http2.connect");
+export const performServerHandshake = /*@__PURE__*/ notImplemented("http2.performServerHandshake ");
+export const Http2ServerRequest = /*@__PURE__*/ notImplementedClass("http2.Http2ServerRequest");
+export const Http2ServerResponse = /*@__PURE__*/ notImplementedClass("http2.Http2ServerResponse");
+export const getDefaultSettings = function() {
+	return Object.create({
+		headerTableSize: 4096,
+		enablePush: true,
+		initialWindowSize: 65535,
+		maxFrameSize: 16384,
+		maxConcurrentStreams: 4294967295,
+		maxHeaderSize: 65535,
+		maxHeaderListSize: 65535,
+		enableConnectProtocol: false
+	});
+};
+export const getPackedSettings = function() {
+	return Buffer.from("");
+};
+export const getUnpackedSettings = function() {
+	return Object.create({});
+};
+export const sensitiveHeaders = /*@__PURE__*/ Symbol("nodejs.http2.sensitiveHeaders");
+export default {
+	constants,
+	createSecureServer,
+	createServer,
+	Http2ServerRequest,
+	Http2ServerResponse,
+	connect,
+	getDefaultSettings,
+	getPackedSettings,
+	getUnpackedSettings,
+	performServerHandshake,
+	sensitiveHeaders
+};

worker/node_modules/unenv/dist/runtime/node/https.d.mts

@@ -0,0 +1,9 @@
+import type nodeHttps from "node:https";
+export declare const Server: typeof nodeHttps.Server;
+export declare const Agent: typeof nodeHttps.Agent;
+export declare const globalAgent: typeof nodeHttps.globalAgent;
+export declare const get: unknown;
+export declare const createServer: unknown;
+export declare const request: unknown;
+declare const _default: {};
+export default _default;