@capsule-run/sdk 0.8.4 → 0.8.6

package/dist/polyfills/unenv-runtime/node/internal/stream/writable.mjs

@@ -0,0 +1,87 @@
+import { EventEmitter } from "node:events";
+// Docs: https://nodejs.org/api/stream.html#stream_writable_streams
+// Implementation: https://github.com/nodejs/node/blob/master/lib/internal/streams/writable.js
+class _Writable extends EventEmitter {
+	__unenv__ = true;
+	writable = true;
+	writableEnded = false;
+	writableFinished = false;
+	writableHighWaterMark = 0;
+	writableLength = 0;
+	writableObjectMode = false;
+	writableCorked = 0;
+	closed = false;
+	errored = null;
+	writableNeedDrain = false;
+	destroyed = false;
+	_data;
+	_encoding = "utf-8";
+	constructor(_opts) {
+		super();
+	}
+	pipe(_destenition, _options) {
+		return {};
+	}
+	_write(chunk, encoding, callback) {
+		if (this.writableEnded) {
+			if (callback) {
+				callback();
+			}
+			return;
+		}
+		if (this._data === undefined) {
+			this._data = chunk;
+		} else {
+			const a = typeof this._data === "string" ? Buffer.from(this._data, this._encoding || encoding || "utf8") : this._data;
+			const b = typeof chunk === "string" ? Buffer.from(chunk, encoding || this._encoding || "utf8") : chunk;
+			this._data = Buffer.concat([a, b]);
+		}
+		this._encoding = encoding;
+		if (callback) {
+			callback();
+		}
+	}
+	_writev(_chunks, _callback) {}
+	_destroy(_error, _callback) {}
+	_final(_callback) {}
+	write(chunk, arg2, arg3) {
+		const encoding = typeof arg2 === "string" ? this._encoding : "utf-8";
+		const cb = typeof arg2 === "function" ? arg2 : typeof arg3 === "function" ? arg3 : undefined;
+		this._write(chunk, encoding, cb);
+		return true;
+	}
+	setDefaultEncoding(_encoding) {
+		return this;
+	}
+	end(arg1, arg2, arg3) {
+		const callback = typeof arg1 === "function" ? arg1 : typeof arg2 === "function" ? arg2 : typeof arg3 === "function" ? arg3 : undefined;
+		if (this.writableEnded) {
+			if (callback) {
+				callback();
+			}
+			return this;
+		}
+		const data = arg1 === callback ? undefined : arg1;
+		if (data) {
+			const encoding = arg2 === callback ? undefined : arg2;
+			this.write(data, encoding, callback);
+		}
+		this.writableEnded = true;
+		this.writableFinished = true;
+		this.emit("close");
+		this.emit("finish");
+		return this;
+	}
+	cork() {}
+	uncork() {}
+	destroy(_error) {
+		this.destroyed = true;
+		delete this._data;
+		this.removeAllListeners();
+		return this;
+	}
+	compose(stream, options) {
+		throw new Error("[h3] Method not implemented.");
+	}
+}
+export const Writable = globalThis.Writable || _Writable;

package/dist/polyfills/unenv-runtime/node/internal/timers/immediate.d.mts

@@ -0,0 +1,9 @@
+export declare class Immediate<TArgs extends any[]> implements NodeJS.Immediate {
+	_onImmediate: (...args: TArgs) => void;
+	private _timeout?;
+	constructor(callback: (...args: TArgs) => void, args: TArgs);
+	ref(): this;
+	unref(): this;
+	hasRef(): boolean;
+	[Symbol.dispose]();
+}

package/dist/polyfills/unenv-runtime/node/internal/timers/immediate.mjs

@@ -0,0 +1,28 @@
+export class Immediate {
+	_onImmediate;
+	_timeout;
+	constructor(callback, args) {
+		this._onImmediate = callback;
+		if ("setTimeout" in globalThis) {
+			this._timeout = setTimeout(callback, 0, ...args);
+		} else {
+			callback(...args);
+		}
+	}
+	ref() {
+		this._timeout?.ref();
+		return this;
+	}
+	unref() {
+		this._timeout?.unref();
+		return this;
+	}
+	hasRef() {
+		return this._timeout?.hasRef() ?? false;
+	}
+	[Symbol.dispose]() {
+		if ("clearTimeout" in globalThis) {
+			clearTimeout(this._timeout);
+		}
+	}
+}

package/dist/polyfills/unenv-runtime/node/internal/timers/scheduler.d.mts

@@ -0,0 +1,6 @@
+import timers from "node:timers/promises";
+import type { TimerOptions } from "node:timers";
+export declare class Scheduler implements timers.Scheduler {
+	wait(delay?: number | undefined, options?: Pick<TimerOptions, "signal"> | undefined);
+	yield();
+}

package/dist/polyfills/unenv-runtime/node/internal/timers/scheduler.mjs

@@ -0,0 +1,10 @@
+import { setTimeoutFallbackPromises as setTimeout } from "./set-timeout.mjs";
+import { setImmediateFallbackPromises as setImmediate } from "./set-immediate.mjs";
+export class Scheduler {
+	wait(delay, options) {
+		return setTimeout(delay, undefined, options);
+	}
+	yield() {
+		return setImmediate();
+	}
+}

package/dist/polyfills/unenv-runtime/node/internal/timers/set-immediate.d.mts

@@ -0,0 +1,3 @@
+export declare function setImmediateFallbackPromises<T = void>(value?: T): Promise<T>;
+export declare function setImmediateFallback<TArgs extends any[]>(callback: (...args: TArgs) => void, ...args: TArgs): NodeJS.Immediate;
+export declare function clearImmediateFallback(immediate: NodeJS.Immediate | undefined);

package/dist/polyfills/unenv-runtime/node/internal/timers/set-immediate.mjs

@@ -0,0 +1,13 @@
+import { Immediate } from "./immediate.mjs";
+export function setImmediateFallbackPromises(value) {
+	return new Promise((res) => {
+		res(value);
+	});
+}
+export function setImmediateFallback(callback, ...args) {
+	return new Immediate(callback, args);
+}
+setImmediateFallback.__promisify__ = setImmediateFallbackPromises;
+export function clearImmediateFallback(immediate) {
+	immediate?.[Symbol.dispose]();
+}

package/dist/polyfills/unenv-runtime/node/internal/timers/set-interval.d.mts

@@ -0,0 +1,2 @@
+export declare function setIntervalFallbackPromises<T = void>(delay?: number, value?: T): NodeJS.AsyncIterator<T>;
+export declare function setIntervalFallback(callback: (args: void) => void, ms?: number): NodeJS.Timeout;

package/dist/polyfills/unenv-runtime/node/internal/timers/set-interval.mjs

@@ -0,0 +1,8 @@
+import { Timeout } from "./timeout.mjs";
+export async function* setIntervalFallbackPromises(delay, value) {
+	yield value;
+}
+export function setIntervalFallback(callback, ms, ...args) {
+	return new Timeout(callback, args);
+}
+setIntervalFallback.__promisify__ = setIntervalFallbackPromises;

package/dist/polyfills/unenv-runtime/node/internal/timers/set-timeout.d.mts

@@ -0,0 +1,3 @@
+import type nodeTimers from "node:timers";
+export declare function setTimeoutFallbackPromises<T = void>(delay?: number, value?: T, options?: nodeTimers.TimerOptions): Promise<T>;
+export declare function setTimeoutFallback(callback: TimerHandler, ms?: number): NodeJS.Timeout;

package/dist/polyfills/unenv-runtime/node/internal/timers/set-timeout.mjs

@@ -0,0 +1,11 @@
+import { Timeout } from "./timeout.mjs";
+export function setTimeoutFallbackPromises(delay, value, options) {
+	return new Promise((res) => {
+		// NOTE: we are ignoring options?.signal? as promise is immediately resolved
+		res(value);
+	});
+}
+export function setTimeoutFallback(callback, ms, ...args) {
+	return new Timeout(callback, args);
+}
+setTimeoutFallback.__promisify__ = setTimeoutFallbackPromises;

package/dist/polyfills/unenv-runtime/node/internal/timers/timeout.d.mts

@@ -0,0 +1,11 @@
+export declare class Timeout<TArgs extends any[]> implements NodeJS.Timeout {
+	constructor(callback: TimerHandler, args: TArgs);
+	close(): this;
+	_onTimeout(...args: any[]): void;
+	ref();
+	unref();
+	hasRef(): boolean;
+	refresh();
+	[Symbol.dispose]();
+	[Symbol.toPrimitive](): number;
+}

package/dist/polyfills/unenv-runtime/node/internal/timers/timeout.mjs

@@ -0,0 +1,30 @@
+import { createNotImplementedError } from "../../../_internal/utils.mjs";
+export class Timeout {
+	constructor(callback, args) {
+		if (typeof callback === "function") {
+			callback(...args);
+		}
+	}
+	close() {
+		throw createNotImplementedError("node.timers.timeout.close");
+	}
+	_onTimeout(...args) {
+		throw createNotImplementedError("node.timers.timeout._onTimeout");
+	}
+	ref() {
+		return this;
+	}
+	unref() {
+		return this;
+	}
+	hasRef() {
+		return false;
+	}
+	refresh() {
+		return this;
+	}
+	[Symbol.dispose]() {}
+	[Symbol.toPrimitive]() {
+		return 0;
+	}
+}

package/dist/polyfills/unenv-runtime/node/internal/tls/constants.d.mts

@@ -0,0 +1,7 @@
+// npx -y node@22.14 -e 'const tls=require("tls");console.log(Object.entries(tls).filter(e => ["string", "number"].includes(typeof e[1])).map(([k,v]) => `export const ${k} = ${JSON.stringify(v)}`).join("\n"))'
+export declare const CLIENT_RENEG_LIMIT = 3;
+export declare const CLIENT_RENEG_WINDOW = 600;
+export declare const DEFAULT_CIPHERS = "";
+export declare const DEFAULT_ECDH_CURVE = "auto";
+export declare const DEFAULT_MIN_VERSION = "TLSv1.2";
+export declare const DEFAULT_MAX_VERSION = "TLSv1.3";

package/dist/polyfills/unenv-runtime/node/internal/tls/constants.mjs

@@ -0,0 +1,7 @@
+// npx -y node@22.14 -e 'const tls=require("tls");console.log(Object.entries(tls).filter(e => ["string", "number"].includes(typeof e[1])).map(([k,v]) => `export const ${k} = ${JSON.stringify(v)}`).join("\n"))'
+export const CLIENT_RENEG_LIMIT = 3;
+export const CLIENT_RENEG_WINDOW = 600;
+export const DEFAULT_CIPHERS = "";
+export const DEFAULT_ECDH_CURVE = "auto";
+export const DEFAULT_MIN_VERSION = "TLSv1.2";
+export const DEFAULT_MAX_VERSION = "TLSv1.3";

package/dist/polyfills/unenv-runtime/node/internal/tls/secure-context.d.mts

@@ -0,0 +1,4 @@
+import type nodeTls from "node:tls";
+export declare class SecureContext implements nodeTls.SecureContext {
+	context: {};
+}

package/dist/polyfills/unenv-runtime/node/internal/tls/secure-context.mjs

@@ -0,0 +1,3 @@
+export class SecureContext {
+	context = {};
+}

package/dist/polyfills/unenv-runtime/node/internal/tls/server.d.mts

@@ -0,0 +1,9 @@
+import type nodeTls from "node:tls";
+import { Server as _Server } from "node:net";
+export declare class Server extends _Server implements nodeTls.Server {
+	constructor(arg1?: nodeTls.TlsOptions | ((socket: nodeTls.TLSSocket) => void), arg2?: (socket: nodeTls.TLSSocket) => void);
+	addContext(hostname: string, context: nodeTls.SecureContextOptions);
+	setSecureContext(options: nodeTls.SecureContextOptions);
+	setTicketKeys(_keys: Buffer);
+	getTicketKeys(): Buffer;
+}

package/dist/polyfills/unenv-runtime/node/internal/tls/server.mjs

@@ -0,0 +1,15 @@
+import { createNotImplementedError } from "../../../_internal/utils.mjs";
+import { Server as _Server } from "node:net";
+export class Server extends _Server {
+	constructor(arg1, arg2) {
+		super(arg1, arg2);
+	}
+	addContext(hostname, context) {}
+	setSecureContext(options) {}
+	setTicketKeys(_keys) {
+		throw createNotImplementedError("Server.setTicketKeys");
+	}
+	getTicketKeys() {
+		throw createNotImplementedError("Server.getTicketKeys");
+	}
+}

package/dist/polyfills/unenv-runtime/node/internal/tls/tls-socket.d.mts

@@ -0,0 +1,31 @@
+import type nodeTls from "node:tls";
+import { Socket } from "node:net";
+export declare class TLSSocket extends Socket implements nodeTls.TLSSocket {
+	authorized: boolean;
+	encrypted: true;
+	alpnProtocol: null;
+	authorizationError: Error;
+	exportKeyingMaterial(): Buffer;
+	getCipher(): nodeTls.CipherNameAndProtocol;
+	getPeerCertificate(detailed: true): nodeTls.DetailedPeerCertificate;
+	getPeerCertificate(detailed?: false): nodeTls.PeerCertificate;
+	getPeerCertificate(detailed?: boolean): nodeTls.PeerCertificate | nodeTls.DetailedPeerCertificate;
+	getCertificate(): null;
+	getEphemeralKeyInfo(): null;
+	getFinished(): undefined;
+	getPeerFinished(): undefined;
+	getProtocol(): null;
+	getSession(): undefined;
+	getSharedSigalgs(): unknown;
+	getTLSTicket(): undefined;
+	isSessionReused(): boolean;
+	renegotiate(options: {
+		rejectUnauthorized?: boolean | undefined;
+		requestCert?: boolean | undefined;
+	}, callback: (err: Error | null) => void): undefined;
+	setMaxSendFragment(size: number): boolean;
+	disableRenegotiation();
+	enableTrace();
+	getPeerX509Certificate(): undefined;
+	getX509Certificate(): undefined;
+}

package/dist/polyfills/unenv-runtime/node/internal/tls/tls-socket.mjs

@@ -0,0 +1,48 @@
+import { Socket } from "node:net";
+import { createNotImplementedError } from "../../../_internal/utils.mjs";
+export class TLSSocket extends Socket {
+	authorized = false;
+	encrypted = true;
+	alpnProtocol = null;
+	authorizationError = new Error("[unenv] TLSSocket.authorizationError is not implemented yet!");
+	exportKeyingMaterial() {
+		throw createNotImplementedError("TLSSocket.exportKeyingMaterial");
+	}
+	getCipher() {
+		throw createNotImplementedError("TLSSocket.getCipher");
+	}
+	getPeerCertificate(_detailed) {
+		throw createNotImplementedError("TLSSocket.getPeerCertificate");
+	}
+	getCertificate() {
+		return null;
+	}
+	getEphemeralKeyInfo() {
+		return null;
+	}
+	getFinished() {}
+	getPeerFinished() {}
+	getProtocol() {
+		return null;
+	}
+	getSession() {}
+	getSharedSigalgs() {
+		return [];
+	}
+	getTLSTicket() {}
+	isSessionReused() {
+		return false;
+	}
+	renegotiate(options, callback) {
+		if (typeof callback === "function") {
+			callback(null);
+		}
+	}
+	setMaxSendFragment(size) {
+		return false;
+	}
+	disableRenegotiation() {}
+	enableTrace() {}
+	getPeerX509Certificate() {}
+	getX509Certificate() {}
+}

package/dist/polyfills/unenv-runtime/node/internal/trace_events/tracing.d.mts

@@ -0,0 +1,7 @@
+import type nodeTraceEvents from "node:trace_events";
+export declare class Tracing implements nodeTraceEvents.Tracing {
+	categories: string;
+	enabled: boolean;
+	disable();
+	enable();
+}

package/dist/polyfills/unenv-runtime/node/internal/trace_events/tracing.mjs

@@ -0,0 +1,10 @@
+export class Tracing {
+	categories = "";
+	enabled = false;
+	disable() {
+		this.enabled = false;
+	}
+	enable() {
+		this.enabled = true;
+	}
+}

package/dist/polyfills/unenv-runtime/node/internal/tty/read-stream.d.mts

@@ -0,0 +1,8 @@
+import type nodeTty from "node:tty";
+export declare class ReadStream implements Partial<nodeTty.ReadStream> {
+	fd: number;
+	isRaw: boolean;
+	isTTY: boolean;
+	constructor(fd: number);
+	setRawMode(mode: boolean): nodeTty.ReadStream;
+}

package/dist/polyfills/unenv-runtime/node/internal/tty/read-stream.mjs

@@ -0,0 +1,12 @@
+export class ReadStream {
+	fd;
+	isRaw = false;
+	isTTY = false;
+	constructor(fd) {
+		this.fd = fd;
+	}
+	setRawMode(mode) {
+		this.isRaw = mode;
+		return this;
+	}
+}

package/dist/polyfills/unenv-runtime/node/internal/tty/write-stream.d.mts

@@ -0,0 +1,20 @@
+import type nodeTty from "node:tty";
+export declare class WriteStream implements Partial<nodeTty.WriteStream> {
+	fd: number;
+	columns: number;
+	rows: number;
+	isTTY: boolean;
+	constructor(fd: number);
+	clearLine(dir: nodeTty.Direction, callback?: (() => void) | undefined): boolean;
+	clearScreenDown(callback?: (() => void) | undefined): boolean;
+	cursorTo(x: number, y?: number | undefined, callback?: (() => void) | undefined): boolean;
+	cursorTo(x: number, callback: () => void): boolean;
+	moveCursor(dx: number, dy: number, callback?: (() => void) | undefined): boolean;
+	getColorDepth(env?: object | undefined): number;
+	hasColors(count?: number | undefined): boolean;
+	hasColors(env?: object | undefined): boolean;
+	hasColors(count: number, env?: object | undefined): boolean;
+	getWindowSize(): [number, number];
+	write(buffer: Uint8Array | string, cb?: (err?: Error) => void): boolean;
+	write(str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error) => void): boolean;
+}

package/dist/polyfills/unenv-runtime/node/internal/tty/write-stream.mjs

@@ -0,0 +1,44 @@
+export class WriteStream {
+	fd;
+	columns = 80;
+	rows = 24;
+	isTTY = false;
+	constructor(fd) {
+		this.fd = fd;
+	}
+	clearLine(dir, callback) {
+		callback && callback();
+		return false;
+	}
+	clearScreenDown(callback) {
+		callback && callback();
+		return false;
+	}
+	cursorTo(x, y, callback) {
+		callback && typeof callback === "function" && callback();
+		return false;
+	}
+	moveCursor(dx, dy, callback) {
+		callback && callback();
+		return false;
+	}
+	getColorDepth(env) {
+		return 1;
+	}
+	hasColors(count, env) {
+		return false;
+	}
+	getWindowSize() {
+		return [this.columns, this.rows];
+	}
+	write(str, encoding, cb) {
+		if (str instanceof Uint8Array) {
+			str = new TextDecoder().decode(str);
+		}
+		try {
+			console.log(str);
+		} catch {}
+		cb && typeof cb === "function" && cb();
+		return false;
+	}
+}

package/dist/polyfills/unenv-runtime/node/internal/url/constants.d.mts

@@ -0,0 +1,44 @@
+// Source: https://github.com/nodejs/node/blob/v22.7.0/lib/internal/constants.js
+export declare const CHAR_UPPERCASE_A = 65;
+export declare const CHAR_LOWERCASE_A = 97;
+export declare const CHAR_UPPERCASE_Z = 90;
+export declare const CHAR_LOWERCASE_Z = 122;
+export declare const CHAR_UPPERCASE_C = 67;
+export declare const CHAR_LOWERCASE_B = 98;
+export declare const CHAR_LOWERCASE_E = 101;
+export declare const CHAR_LOWERCASE_N = 110;
+export declare const CHAR_DOT = 46;
+export declare const CHAR_FORWARD_SLASH = 47;
+export declare const CHAR_BACKWARD_SLASH = 92;
+export declare const CHAR_VERTICAL_LINE = 124;
+export declare const CHAR_COLON = 58;
+export declare const CHAR_QUESTION_MARK = 63;
+export declare const CHAR_UNDERSCORE = 95;
+export declare const CHAR_LINE_FEED = 10;
+export declare const CHAR_CARRIAGE_RETURN = 13;
+export declare const CHAR_TAB = 9;
+export declare const CHAR_FORM_FEED = 12;
+export declare const CHAR_EXCLAMATION_MARK = 33;
+export declare const CHAR_HASH = 35;
+export declare const CHAR_SPACE = 32;
+export declare const CHAR_NO_BREAK_SPACE = 160;
+export declare const CHAR_ZERO_WIDTH_NOBREAK_SPACE = 65279;
+export declare const CHAR_LEFT_SQUARE_BRACKET = 91;
+export declare const CHAR_RIGHT_SQUARE_BRACKET = 93;
+export declare const CHAR_LEFT_ANGLE_BRACKET = 60;
+export declare const CHAR_RIGHT_ANGLE_BRACKET = 62;
+export declare const CHAR_LEFT_CURLY_BRACKET = 123;
+export declare const CHAR_RIGHT_CURLY_BRACKET = 125;
+export declare const CHAR_HYPHEN_MINUS = 45;
+export declare const CHAR_PLUS = 43;
+export declare const CHAR_DOUBLE_QUOTE = 34;
+export declare const CHAR_SINGLE_QUOTE = 39;
+export declare const CHAR_PERCENT = 37;
+export declare const CHAR_SEMICOLON = 59;
+export declare const CHAR_CIRCUMFLEX_ACCENT = 94;
+export declare const CHAR_GRAVE_ACCENT = 96;
+export declare const CHAR_AT = 64;
+export declare const CHAR_AMPERSAND = 38;
+export declare const CHAR_EQUAL = 61;
+export declare const CHAR_0 = 48;
+export declare const CHAR_9 = 57;

package/dist/polyfills/unenv-runtime/node/internal/url/constants.mjs

@@ -0,0 +1,44 @@
+// Source: https://github.com/nodejs/node/blob/v22.7.0/lib/internal/constants.js
+export const CHAR_UPPERCASE_A = 65;
+export const CHAR_LOWERCASE_A = 97;
+export const CHAR_UPPERCASE_Z = 90;
+export const CHAR_LOWERCASE_Z = 122;
+export const CHAR_UPPERCASE_C = 67;
+export const CHAR_LOWERCASE_B = 98;
+export const CHAR_LOWERCASE_E = 101;
+export const CHAR_LOWERCASE_N = 110;
+export const CHAR_DOT = 46;
+export const CHAR_FORWARD_SLASH = 47;
+export const CHAR_BACKWARD_SLASH = 92;
+export const CHAR_VERTICAL_LINE = 124;
+export const CHAR_COLON = 58;
+export const CHAR_QUESTION_MARK = 63;
+export const CHAR_UNDERSCORE = 95;
+export const CHAR_LINE_FEED = 10;
+export const CHAR_CARRIAGE_RETURN = 13;
+export const CHAR_TAB = 9;
+export const CHAR_FORM_FEED = 12;
+export const CHAR_EXCLAMATION_MARK = 33;
+export const CHAR_HASH = 35;
+export const CHAR_SPACE = 32;
+export const CHAR_NO_BREAK_SPACE = 160;
+export const CHAR_ZERO_WIDTH_NOBREAK_SPACE = 65279;
+export const CHAR_LEFT_SQUARE_BRACKET = 91;
+export const CHAR_RIGHT_SQUARE_BRACKET = 93;
+export const CHAR_LEFT_ANGLE_BRACKET = 60;
+export const CHAR_RIGHT_ANGLE_BRACKET = 62;
+export const CHAR_LEFT_CURLY_BRACKET = 123;
+export const CHAR_RIGHT_CURLY_BRACKET = 125;
+export const CHAR_HYPHEN_MINUS = 45;
+export const CHAR_PLUS = 43;
+export const CHAR_DOUBLE_QUOTE = 34;
+export const CHAR_SINGLE_QUOTE = 39;
+export const CHAR_PERCENT = 37;
+export const CHAR_SEMICOLON = 59;
+export const CHAR_CIRCUMFLEX_ACCENT = 94;
+export const CHAR_GRAVE_ACCENT = 96;
+export const CHAR_AT = 64;
+export const CHAR_AMPERSAND = 38;
+export const CHAR_EQUAL = 61;
+export const CHAR_0 = 48;
+export const CHAR_9 = 57;

package/dist/polyfills/unenv-runtime/node/internal/url/errors.d.mts

@@ -0,0 +1,26 @@
+export declare class ERR_INVALID_ARG_VALUE extends TypeError {
+	code: string;
+	constructor(name: string, value: unknown, reason: string);
+}
+export declare class ERR_INVALID_ARG_TYPE extends TypeError {
+	code: string;
+	constructor(name: string, expected: unknown, actual: unknown);
+}
+export declare class ERR_INVALID_URL extends TypeError {
+	code: string;
+	input: string;
+	base?: string;
+	constructor(input: string, base?: string);
+}
+export declare class ERR_INVALID_URL_SCHEME extends TypeError {
+	code: string;
+	constructor(expected: string);
+}
+export declare class ERR_INVALID_FILE_URL_PATH extends TypeError {
+	code: string;
+	constructor(path: string);
+}
+export declare class ERR_INVALID_FILE_URL_HOST extends TypeError {
+	code: string;
+	constructor(host: string);
+}

package/dist/polyfills/unenv-runtime/node/internal/url/errors.mjs

@@ -0,0 +1,54 @@
+// Source: https://github.com/nodejs/node/blob/v22.7.0/lib/internal/errors.js
+function fmt(val) {
+	if (Array.isArray(val)) {
+		return val.map((v) => fmt(v)).join(" or ");
+	}
+	if (!val) {
+		return "" + val;
+	}
+	return val.toString();
+}
+export class ERR_INVALID_ARG_VALUE extends TypeError {
+	code = "ERR_INVALID_ARG_VALUE";
+	constructor(name, value, reason) {
+		super(`The ${name.includes(".") ? "property" : "argument"} '${name}' ${reason}. Received ${value}`);
+	}
+}
+export class ERR_INVALID_ARG_TYPE extends TypeError {
+	code = "ERR_INVALID_ARG_TYPE";
+	constructor(name, expected, actual) {
+		super(`The "${name}" argument must be of type ${fmt(expected)}. Received ${fmt(actual)}`);
+	}
+}
+export class ERR_INVALID_URL extends TypeError {
+	code = "ERR_INVALID_URL";
+	input;
+	base;
+	constructor(input, base) {
+		// Don't include URL in message.
+		// (See https://github.com/nodejs/node/pull/38614)
+		super("Invalid URL");
+		this.input = input;
+		if (base != null) {
+			this.base = base;
+		}
+	}
+}
+export class ERR_INVALID_URL_SCHEME extends TypeError {
+	code = "ERR_INVALID_URL_SCHEME";
+	constructor(expected) {
+		super(`The URL must be of scheme ${expected}`);
+	}
+}
+export class ERR_INVALID_FILE_URL_PATH extends TypeError {
+	code = "ERR_INVALID_FILE_URL_PATH";
+	constructor(path) {
+		super(`Invalid ile URL path: ${path}`);
+	}
+}
+export class ERR_INVALID_FILE_URL_HOST extends TypeError {
+	code = "ERR_INVALID_FILE_URL_HOST";
+	constructor(host) {
+		super(`File URL host must be "localhost" or empty on ${host}`);
+	}
+}