@capsule-run/sdk 0.8.4 → 0.8.6

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

@@ -0,0 +1,22 @@
+// Protocols that can allow "unsafe" and "unwise" chars.
+export declare const unsafeProtocol: unknown;
+// Protocols that never have a hostname.
+export declare const hostlessProtocol: unknown;
+// Protocols that always contain a // bit.
+export declare const slashedProtocol: unknown;
+export declare function pathToFileURL(filepath: string, options?: {
+	windows?: boolean;
+});
+export declare function fileURLToPath(path: string | URL, options?: {
+	windows?: boolean;
+});
+/**
+* Utility function that converts a URL object into an ordinary options object
+* as expected by the `http.request` and `https.request` APIs.
+* @param {URL} url
+* @returns {Record<string, unknown>}
+*/
+export declare function urlToHttpOptions(url: URL): {
+	__proto__: null;
+	path: string;
+};

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

@@ -0,0 +1,181 @@
+// Source: https://github.com/nodejs/node/blob/v22.7.0/lib/internal/url.js
+import path from "node:path";
+import * as punnycode from "../../punycode.mjs";
+import { CHAR_FORWARD_SLASH, CHAR_BACKWARD_SLASH, CHAR_LOWERCASE_A, CHAR_LOWERCASE_Z } from "./constants.mjs";
+import { ERR_INVALID_ARG_TYPE, ERR_INVALID_ARG_VALUE, ERR_INVALID_URL_SCHEME, ERR_INVALID_FILE_URL_PATH, ERR_INVALID_FILE_URL_HOST } from "./errors.mjs";
+// Protocols that can allow "unsafe" and "unwise" chars.
+export const unsafeProtocol = new Set(["javascript", "javascript:"]);
+// Protocols that never have a hostname.
+export const hostlessProtocol = new Set(["javascript", "javascript:"]);
+// Protocols that always contain a // bit.
+export const slashedProtocol = new Set([
+	"http",
+	"http:",
+	"https",
+	"https:",
+	"ftp",
+	"ftp:",
+	"gopher",
+	"gopher:",
+	"file",
+	"file:",
+	"ws",
+	"ws:",
+	"wss",
+	"wss:"
+]);
+const FORWARD_SLASH = /\//g;
+export function pathToFileURL(filepath, options) {
+	const windows = options?.windows;
+	if (windows && String.prototype.startsWith.call(filepath, "\\\\")) {
+		const outURL = new URL("file://");
+		// UNC path format: \\server\share\resource
+		// Handle extended UNC path and standard UNC path
+		// "\\?\UNC\" path prefix should be ignored.
+		// Ref: https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation
+		const isExtendedUNC = String.prototype.startsWith.call(filepath, "\\\\?\\UNC\\");
+		const prefixLength = isExtendedUNC ? 8 : 2;
+		const hostnameEndIndex = String.prototype.indexOf.call(filepath, "\\", prefixLength);
+		if (hostnameEndIndex === -1) {
+			throw new ERR_INVALID_ARG_VALUE("path", filepath, "Missing UNC resource path");
+		}
+		const hostname = String.prototype.slice.call(filepath, prefixLength, hostnameEndIndex);
+		outURL.hostname = punnycode.toASCII(hostname);
+		outURL.pathname = encodePathChars(filepath.slice(hostnameEndIndex).replace(backslashRegEx, "/"), { windows });
+		return outURL;
+	}
+	let resolved = windows ? path.win32.resolve(filepath) : path.posix.resolve(filepath);
+	// path.resolve strips trailing slashes so we must add them back
+	const filePathLast = String.prototype.charCodeAt.call(filepath, filepath.length - 1);
+	if ((filePathLast === CHAR_FORWARD_SLASH || windows && filePathLast === CHAR_BACKWARD_SLASH) && resolved.at(-1) !== path.sep) resolved += "/";
+	// Call encodePathChars first to avoid encoding % again for ? and #.
+	resolved = encodePathChars(resolved, { windows });
+	// Question and hash character should be included in pathname.
+	// Therefore, encoding is required to eliminate parsing them in different states.
+	// This is done as an optimization to not creating a URL instance and
+	// later triggering pathname setter, which impacts performance
+	if (String.prototype.indexOf.call(resolved, "?") !== -1) resolved = resolved.replace(questionRegex, "%3F");
+	if (String.prototype.indexOf.call(resolved, "#") !== -1) resolved = resolved.replace(hashRegex, "%23");
+	return new URL(`file://${resolved}`);
+}
+export function fileURLToPath(path, options) {
+	const windows = options?.windows;
+	if (typeof path === "string") path = new URL(path);
+	else if (!isURL(path)) throw new ERR_INVALID_ARG_TYPE("path", ["string", "URL"], path);
+	if (path.protocol !== "file:") throw new ERR_INVALID_URL_SCHEME("file");
+	return windows ? getPathFromURLWin32(path) : getPathFromURLPosix(path);
+}
+/**
+* Utility function that converts a URL object into an ordinary options object
+* as expected by the `http.request` and `https.request` APIs.
+* @param {URL} url
+* @returns {Record<string, unknown>}
+*/
+export function urlToHttpOptions(url) {
+	const { hostname, pathname, port, username, password, search } = url;
+	return {
+		__proto__: null,
+		...url,
+		protocol: url.protocol,
+		hostname: hostname && String.prototype.startsWith.call(hostname, "[") ? String.prototype.slice.call(hostname, 1, -1) : hostname,
+		hash: url.hash,
+		search,
+		pathname,
+		path: `${pathname || ""}${search || ""}`,
+		href: url.href,
+		port: port === "" ? undefined : Number(port),
+		auth: username || password ? `${decodeURIComponent(username)}:${decodeURIComponent(password)}` : undefined
+	};
+}
+// The following characters are percent-encoded when converting from file path
+// to URL:
+// - %: The percent character is the only character not encoded by the
+//        `pathname` setter.
+// - \: Backslash is encoded on non-windows platforms since it's a valid
+//      character but the `pathname` setters replaces it by a forward slash.
+// - LF: The newline character is stripped out by the `pathname` setter.
+//       (See whatwg/url#419)
+// - CR: The carriage return character is also stripped out by the `pathname`
+//       setter.
+// - TAB: The tab character is also stripped out by the `pathname` setter.
+const percentRegEx = /%/g;
+const backslashRegEx = /\\/g;
+const newlineRegEx = /\n/g;
+const carriageReturnRegEx = /\r/g;
+const tabRegEx = /\t/g;
+const questionRegex = /\?/g;
+const hashRegex = /#/g;
+function encodePathChars(filepath, options) {
+	const windows = options?.windows;
+	if (String.prototype.indexOf.call(filepath, "%") !== -1) filepath = filepath.replace(percentRegEx, "%25");
+	// In posix, backslash is a valid character in paths:
+	if (!windows && String.prototype.indexOf.call(filepath, "\\") !== -1) filepath = filepath.replace(backslashRegEx, "%5C");
+	if (String.prototype.indexOf.call(filepath, "\n") !== -1) filepath = filepath.replace(newlineRegEx, "%0A");
+	if (String.prototype.indexOf.call(filepath, "\r") !== -1) filepath = filepath.replace(carriageReturnRegEx, "%0D");
+	if (String.prototype.indexOf.call(filepath, "	") !== -1) filepath = filepath.replace(tabRegEx, "%09");
+	return filepath;
+}
+function getPathFromURLWin32(url) {
+	const hostname = url.hostname;
+	let pathname = url.pathname;
+	for (let n = 0; n < pathname.length; n++) {
+		if (pathname[n] === "%") {
+			const third = pathname.codePointAt(n + 2) | 32;
+			if (pathname[n + 1] === "2" && third === 102 || pathname[n + 1] === "5" && third === 99) {
+				// 5c 5C \
+				throw new ERR_INVALID_FILE_URL_PATH(String.raw`must not include encoded \ or / characters`);
+			}
+		}
+	}
+	pathname = pathname.replace(FORWARD_SLASH, "\\");
+	pathname = decodeURIComponent(pathname);
+	if (hostname !== "") {
+		// If hostname is set, then we have a UNC path
+		// Pass the hostname through domainToUnicode just in case
+		// it is an IDN using punycode encoding. We do not need to worry
+		// about percent encoding because the URL parser will have
+		// already taken care of that for us. Note that this only
+		// causes IDNs with an appropriate `xn--` prefix to be decoded.
+		return `\\\\${punnycode.toUnicode(hostname)}${pathname}`;
+	}
+	// Otherwise, it's a local path that requires a drive letter
+	const letter = String.prototype.codePointAt.call(pathname, 1) | 32;
+	const sep = String.prototype.charAt.call(pathname, 2);
+	if (letter < CHAR_LOWERCASE_A || letter > CHAR_LOWERCASE_Z || sep !== ":") {
+		throw new ERR_INVALID_FILE_URL_PATH("must be absolute");
+	}
+	return String.prototype.slice.call(pathname, 1);
+}
+function getPathFromURLPosix(url) {
+	if (url.hostname !== "") {
+		throw new ERR_INVALID_FILE_URL_HOST("??");
+	}
+	const pathname = url.pathname;
+	for (let n = 0; n < pathname.length; n++) {
+		if (pathname[n] === "%") {
+			const third = String.prototype.codePointAt.call(pathname, n + 2) | 32;
+			if (pathname[n + 1] === "2" && third === 102) {
+				throw new ERR_INVALID_FILE_URL_PATH("must not include encoded / characters");
+			}
+		}
+	}
+	return decodeURIComponent(pathname);
+}
+/**
+* Checks if a value has the shape of a WHATWG URL object.
+*
+* Using a symbol or instanceof would not be able to recognize URL objects
+* coming from other implementations (e.g. in Electron), so instead we are
+* checking some well known properties for a lack of a better test.
+*
+* We use `href` and `protocol` as they are the only properties that are
+* easy to retrieve and calculate due to the lazy nature of the getters.
+*
+* We check for `auth` and `path` attribute to distinguish legacy url instance with
+* WHATWG URL instance.
+* @param {*} self
+* @returns {self is URL}
+*/
+function isURL(self) {
+	return Boolean(self?.href && self.protocol && self.auth === undefined && self.path === undefined);
+}

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

@@ -0,0 +1,4 @@
+// Source: https://github.com/nodejs/node/blob/v22.7.0/lib/internal/util.js
+// As of V8 6.6, depending on the size of the array, this is anywhere
+// between 1.5-10x faster than the two-arg version of Array#splice()
+export declare function spliceOne(list: unknown[], index: number);

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

@@ -0,0 +1,7 @@
+// Source: https://github.com/nodejs/node/blob/v22.7.0/lib/internal/util.js
+// As of V8 6.6, depending on the size of the array, this is anywhere
+// between 1.5-10x faster than the two-arg version of Array#splice()
+export function spliceOne(list, index) {
+	for (; index + 1 < list.length; index++) list[index] = list[index + 1];
+	list.pop();
+}

package/dist/polyfills/unenv-runtime/node/internal/util/inherits.d.mts

@@ -0,0 +1 @@
+export declare function inherits(ctor: any, superCtor: any);

package/dist/polyfills/unenv-runtime/node/internal/util/inherits.mjs

@@ -0,0 +1,12 @@
+export function inherits(ctor, superCtor) {
+	if (!superCtor) {
+		return;
+	}
+	ctor.super_ = superCtor;
+	ctor.prototype = Object.create(superCtor.prototype, { constructor: {
+		value: ctor,
+		enumerable: false,
+		writable: true,
+		configurable: true
+	} });
+}

package/dist/polyfills/unenv-runtime/node/internal/util/legacy-types.d.mts

@@ -0,0 +1,19 @@
+import type nodeUtil from "node:util";
+export declare const isRegExp: typeof nodeUtil.isRegExp;
+export declare const isDate: typeof nodeUtil.isDate;
+export declare const isArray: typeof nodeUtil.isArray;
+export declare const isBoolean: typeof nodeUtil.isBoolean;
+export declare const isNull: typeof nodeUtil.isNull;
+export declare const isNullOrUndefined: typeof nodeUtil.isNullOrUndefined;
+export declare const isNumber: typeof nodeUtil.isNumber;
+export declare const isString: typeof nodeUtil.isString;
+export declare const isSymbol: typeof nodeUtil.isSymbol;
+export declare const isUndefined: typeof nodeUtil.isUndefined;
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+export declare const isFunction: typeof nodeUtil.isFunction;
+export declare const isBuffer: typeof nodeUtil.isBuffer;
+export declare const isDeepStrictEqual: typeof nodeUtil.isDeepStrictEqual;
+export declare const isObject: typeof nodeUtil.isObject;
+export declare const isError: typeof nodeUtil.isError;
+// Source https://github.com/jonschlinkert/is-primitive/blob/b22c524da5cbac075f14145780ec4b3637afd7dc/index.js
+export declare const isPrimitive: typeof nodeUtil.isPrimitive;

package/dist/polyfills/unenv-runtime/node/internal/util/legacy-types.mjs

@@ -0,0 +1,25 @@
+export const isRegExp = (val) => val instanceof RegExp;
+export const isDate = (val) => val instanceof Date;
+export const isArray = (val) => Array.isArray(val);
+export const isBoolean = (val) => typeof val === "boolean";
+export const isNull = (val) => val === null;
+export const isNullOrUndefined = (val) => val === null || val === undefined;
+export const isNumber = (val) => typeof val === "number";
+export const isString = (val) => typeof val === "string";
+export const isSymbol = (val) => typeof val === "symbol";
+export const isUndefined = (val) => val === undefined;
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+export const isFunction = (val) => typeof val === "function";
+export const isBuffer = (val) => {
+	return val && typeof val === "object" && typeof val.copy === "function" && typeof val.fill === "function" && typeof val.readUInt8 === "function";
+};
+export const isDeepStrictEqual = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+export const isObject = (val) => val !== null && typeof val === "object" && Object.getPrototypeOf(val).isPrototypeOf(Object);
+export const isError = (val) => val instanceof Error;
+// Source https://github.com/jonschlinkert/is-primitive/blob/b22c524da5cbac075f14145780ec4b3637afd7dc/index.js
+export const isPrimitive = (val) => {
+	if (typeof val === "object") {
+		return val === null;
+	}
+	return typeof val !== "function";
+};

package/dist/polyfills/unenv-runtime/node/internal/util/log.d.mts

@@ -0,0 +1,8 @@
+import type nodeUtil from "node:util";
+export declare const log: unknown;
+export declare const debuglog: typeof nodeUtil.debuglog;
+export declare const debug: typeof nodeUtil.debug;
+// @ts-ignore
+export declare const inspect: typeof nodeUtil.inspect;
+export declare const format: typeof nodeUtil.format;
+export declare const formatWithOptions: typeof nodeUtil.formatWithOptions;

package/dist/polyfills/unenv-runtime/node/internal/util/log.mjs

@@ -0,0 +1,55 @@
+export const log = (...args) => {
+	console.log(...args);
+};
+export const debuglog = (section, _cb) => {
+	const fn = (msg, ...params) => {
+		if (fn.enabled) {
+			console.debug(`[${section}] ${msg}`, ...params);
+		}
+	};
+	fn.enabled = true;
+	return fn;
+};
+export const debug = debuglog;
+// @ts-ignore
+export const inspect = (object) => JSON.stringify(object, null, 2);
+export const format = (...args) => _format(...args);
+export const formatWithOptions = (_options, ...args) => _format(...args);
+// Source: https://github.com/tmpfs/format-util/blob/0c989942c959b179eec294a4e725afd63e743f18/format.js
+function _format(fmt, ...args) {
+	const re = /(%?)(%([djos]))/g;
+	if (args.length > 0) {
+		fmt = fmt.replace(re, (match, escaped, ptn, flag) => {
+			let arg = args.shift();
+			switch (flag) {
+				case "o":
+					if (Array.isArray(arg)) {
+						arg = JSON.stringify(arg);
+						break;
+					}
+					break;
+				case "s":
+					arg = "" + arg;
+					break;
+				case "d":
+					arg = Number(arg);
+					break;
+				case "j":
+					arg = JSON.stringify(arg);
+					break;
+			}
+			if (!escaped) {
+				return arg;
+			}
+			args.unshift(arg);
+			return match;
+		});
+	}
+	// arguments remain after formatting
+	if (args.length > 0) {
+		fmt += " " + args.join(" ");
+	}
+	// update escaped %% values
+	fmt = fmt.replace(/%{2}/g, "%");
+	return "" + fmt;
+}

package/dist/polyfills/unenv-runtime/node/internal/util/mime.d.mts

@@ -0,0 +1,19 @@
+import type { MIMEType as MIMETypeT, MIMEParams as MIMEParamsT } from "node:util";
+// https://nodejs.org/api/util.html#class-utilmimetype
+export declare class MIMEType implements MIMETypeT {
+	readonly __unenv__: true;
+	params;
+	type: string;
+	subtype: string;
+	constructor(input: string | {
+		toString: () => string;
+	});
+	get essence();
+	toString();
+}
+// https://nodejs.org/api/util.html#util_class_util_mimeparams
+export declare class MIMEParams extends Map<string, string> implements MIMEParamsT {
+	readonly __unenv__: true;
+	get(name: string): any;
+	toString();
+}

package/dist/polyfills/unenv-runtime/node/internal/util/mime.mjs

@@ -0,0 +1,35 @@
+// https://nodejs.org/api/util.html#class-utilmimetype
+export class MIMEType {
+	__unenv__ = true;
+	params = new MIMEParams();
+	type;
+	subtype;
+	constructor(input) {
+		const [essence = "", ...params] = String(input).split(";");
+		const [type = "", subtype = ""] = essence.split("/");
+		this.type = type;
+		this.subtype = subtype;
+		this.params = new MIMEParams();
+		for (const param of params) {
+			const [name, value] = param.split("=");
+			this.params.set(name, value);
+		}
+	}
+	get essence() {
+		return this.type + "/" + this.subtype;
+	}
+	toString() {
+		const paramsStr = this.params.toString();
+		return this.essence + (paramsStr ? `;${paramsStr}` : "");
+	}
+}
+// https://nodejs.org/api/util.html#util_class_util_mimeparams
+export class MIMEParams extends Map {
+	__unenv__ = true;
+	get(name) {
+		return super.get(name) || null;
+	}
+	toString() {
+		return [...this.entries()].map(([name, value]) => `${name}=${value}`).join("&");
+	}
+}

package/dist/polyfills/unenv-runtime/node/internal/util/promisify.d.mts

@@ -0,0 +1,3 @@
+import type nodeUtil from "node:util";
+// @ts-ignore
+export declare const promisify: typeof nodeUtil.promisify;

package/dist/polyfills/unenv-runtime/node/internal/util/promisify.mjs

@@ -0,0 +1,23 @@
+const customSymbol = /* @__PURE__ */ Symbol("customPromisify");
+function _promisify(fn) {
+	if (fn[customSymbol]) {
+		return fn[customSymbol];
+	}
+	return function(...args) {
+		return new Promise((resolve, reject) => {
+			try {
+				// @ts-ignore
+				fn.call(this, ...args, (err, val) => {
+					if (err) {
+						return reject(err);
+					}
+					resolve(val);
+				});
+			} catch (error) {
+				reject(error);
+			}
+		});
+	};
+}
+// @ts-ignore
+export const promisify = /* @__PURE__ */ Object.assign(_promisify, { custom: customSymbol });

package/dist/polyfills/unenv-runtime/node/internal/util/types.d.mts

@@ -0,0 +1,45 @@
+import type nodeUtilTypes from "node:util/types";
+export declare const isExternal: typeof nodeUtilTypes.isExternal;
+export declare const isDate: typeof nodeUtilTypes.isDate;
+export declare const isArgumentsObject: unknown;
+export declare const isBigIntObject: (val: any) => val is bigint;
+export declare const isBooleanObject: typeof nodeUtilTypes.isBooleanObject;
+export declare const isNumberObject: typeof nodeUtilTypes.isNumberObject;
+export declare const isStringObject: typeof nodeUtilTypes.isStringObject;
+export declare const isSymbolObject: typeof nodeUtilTypes.isSymbolObject;
+export declare const isNativeError: unknown;
+export declare const isRegExp: typeof nodeUtilTypes.isRegExp;
+export declare const isAsyncFunction: unknown;
+export declare const isGeneratorFunction: unknown;
+export declare const isGeneratorObject: unknown;
+export declare const isPromise: typeof nodeUtilTypes.isPromise;
+// @ts-ignore
+export declare const isMap: typeof nodeUtilTypes.isMap;
+// @ts-ignore
+export declare const isSet: typeof nodeUtilTypes.isSet;
+export declare const isMapIterator: unknown;
+export declare const isSetIterator: unknown;
+export declare const isWeakMap: typeof nodeUtilTypes.isWeakMap;
+export declare const isWeakSet: typeof nodeUtilTypes.isWeakSet;
+export declare const isArrayBuffer: typeof nodeUtilTypes.isArrayBuffer;
+export declare const isDataView: typeof nodeUtilTypes.isDataView;
+export declare const isSharedArrayBuffer: typeof nodeUtilTypes.isSharedArrayBuffer;
+export declare const isProxy: unknown;
+export declare const isModuleNamespaceObject: unknown;
+export declare const isAnyArrayBuffer: unknown;
+export declare const isBoxedPrimitive: unknown;
+export declare const isArrayBufferView: unknown;
+export declare const isTypedArray: unknown;
+export declare const isUint8Array: unknown;
+export declare const isUint8ClampedArray: unknown;
+export declare const isUint16Array: unknown;
+export declare const isUint32Array: unknown;
+export declare const isInt8Array: unknown;
+export declare const isInt16Array: unknown;
+export declare const isInt32Array: unknown;
+export declare const isFloat32Array: unknown;
+export declare const isFloat64Array: unknown;
+export declare const isBigInt64Array: unknown;
+export declare const isBigUint64Array: unknown;
+export declare const isKeyObject: unknown;
+export declare const isCryptoKey: unknown;

package/dist/polyfills/unenv-runtime/node/internal/util/types.mjs

@@ -0,0 +1,45 @@
+import { notImplemented } from "../../../_internal/utils.mjs";
+export const isExternal = (_obj) => false;
+export const isDate = (val) => val instanceof Date;
+export const isArgumentsObject = /* @__PURE__ */ notImplemented("util.types.isArgumentsObject");
+export const isBigIntObject = (val) => typeof val === "bigint";
+export const isBooleanObject = (val) => typeof val === "boolean";
+export const isNumberObject = (val) => typeof val === "number";
+export const isStringObject = (val) => typeof val === "string";
+export const isSymbolObject = (val) => typeof val === "symbol";
+export const isNativeError = /* @__PURE__ */ notImplemented("util.types.isNativeError");
+export const isRegExp = (val) => val instanceof RegExp;
+export const isAsyncFunction = /* @__PURE__ */ notImplemented("util.types.isAsyncFunction");
+export const isGeneratorFunction = /* @__PURE__ */ notImplemented("util.types.isGeneratorFunction");
+export const isGeneratorObject = /* @__PURE__ */ notImplemented("util.types.isGeneratorObject");
+export const isPromise = (val) => val instanceof Promise;
+// @ts-ignore
+export const isMap = (val) => val instanceof Map;
+// @ts-ignore
+export const isSet = (val) => val instanceof Set;
+export const isMapIterator = /* @__PURE__ */ notImplemented("util.types.isMapIterator");
+export const isSetIterator = /* @__PURE__ */ notImplemented("util.types.isSetIterator");
+export const isWeakMap = (val) => val instanceof WeakMap;
+export const isWeakSet = (val) => val instanceof WeakSet;
+export const isArrayBuffer = (val) => val instanceof ArrayBuffer;
+export const isDataView = (val) => val instanceof DataView;
+export const isSharedArrayBuffer = (val) => val instanceof SharedArrayBuffer;
+export const isProxy = /* @__PURE__ */ notImplemented("util.types.isProxy");
+export const isModuleNamespaceObject = /* @__PURE__ */ notImplemented("util.types.isModuleNamespaceObject");
+export const isAnyArrayBuffer = /* @__PURE__ */ notImplemented("util.types.isAnyArrayBuffer");
+export const isBoxedPrimitive = /* @__PURE__ */ notImplemented("util.types.isBoxedPrimitive");
+export const isArrayBufferView = /* @__PURE__ */ notImplemented("util.types.isArrayBufferView");
+export const isTypedArray = /* @__PURE__ */ notImplemented("util.types.isTypedArray");
+export const isUint8Array = /* @__PURE__ */ notImplemented("util.types.isUint8Array");
+export const isUint8ClampedArray = /* @__PURE__ */ notImplemented("util.types.isUint8ClampedArray");
+export const isUint16Array = /* @__PURE__ */ notImplemented("util.types.isUint16Array");
+export const isUint32Array = /* @__PURE__ */ notImplemented("util.types.isUint32Array");
+export const isInt8Array = /* @__PURE__ */ notImplemented("util.types.isInt8Array");
+export const isInt16Array = /* @__PURE__ */ notImplemented("util.types.isInt16Array");
+export const isInt32Array = /* @__PURE__ */ notImplemented("util.types.isInt32Array");
+export const isFloat32Array = /* @__PURE__ */ notImplemented("util.types.isFloat32Array");
+export const isFloat64Array = /* @__PURE__ */ notImplemented("util.types.isFloat64Array");
+export const isBigInt64Array = /* @__PURE__ */ notImplemented("util.types.isBigInt64Array");
+export const isBigUint64Array = /* @__PURE__ */ notImplemented("util.types.isBigUint64Array");
+export const isKeyObject = /* @__PURE__ */ notImplemented("util.types.isKeyObject");
+export const isCryptoKey = /* @__PURE__ */ notImplemented("util.types.isCryptoKey");

package/dist/polyfills/unenv-runtime/node/internal/v8/deserializer.d.mts

@@ -0,0 +1,12 @@
+import type nodeV8 from "node:v8";
+export declare class Deserializer implements nodeV8.Deserializer {
+	readHeader(): boolean;
+	readValue();
+	transferArrayBuffer(id: number, arrayBuffer: ArrayBuffer);
+	getWireFormatVersion(): number;
+	readUint32(): number;
+	readUint64(): [number, number];
+	readDouble(): number;
+	readRawBytes(length: number): Buffer;
+}
+export declare class DefaultDeserializer extends Deserializer {}

package/dist/polyfills/unenv-runtime/node/internal/v8/deserializer.mjs

@@ -0,0 +1,23 @@
+export class Deserializer {
+	readHeader() {
+		return false;
+	}
+	readValue() {}
+	transferArrayBuffer(id, arrayBuffer) {}
+	getWireFormatVersion() {
+		return 0;
+	}
+	readUint32() {
+		return 0;
+	}
+	readUint64() {
+		return [0, 0];
+	}
+	readDouble() {
+		return 0;
+	}
+	readRawBytes(length) {
+		return Buffer.from("");
+	}
+}
+export class DefaultDeserializer extends Deserializer {}

package/dist/polyfills/unenv-runtime/node/internal/v8/profiler.d.mts

@@ -0,0 +1,10 @@
+import type nodeV8 from "node:v8";
+export declare class GCProfiler implements nodeV8.GCProfiler {
+	start();
+	stop(): {
+		version: number;
+		startTime: number;
+		endTime: number;
+		statistics: unknown;
+	};
+}

package/dist/polyfills/unenv-runtime/node/internal/v8/profiler.mjs

@@ -0,0 +1,11 @@
+export class GCProfiler {
+	start() {}
+	stop() {
+		return {
+			version: 1,
+			startTime: 0,
+			endTime: 0,
+			statistics: []
+		};
+	}
+}

package/dist/polyfills/unenv-runtime/node/internal/v8/serializer.d.mts

@@ -0,0 +1,12 @@
+import type nodeV8 from "node:v8";
+export declare class Serializer implements nodeV8.Serializer {
+	writeHeader();
+	writeValue(val: any): boolean;
+	releaseBuffer(): Buffer;
+	transferArrayBuffer(id: number, arrayBuffer: ArrayBuffer);
+	writeDouble(value: number);
+	writeUint32(value: number);
+	writeUint64(hi: number, lo: number);
+	writeRawBytes(buffer: NodeJS.TypedArray);
+}
+export declare class DefaultSerializer extends Serializer {}

package/dist/polyfills/unenv-runtime/node/internal/v8/serializer.mjs

@@ -0,0 +1,15 @@
+export class Serializer {
+	writeHeader() {}
+	writeValue(val) {
+		return false;
+	}
+	releaseBuffer() {
+		return Buffer.from("");
+	}
+	transferArrayBuffer(id, arrayBuffer) {}
+	writeDouble(value) {}
+	writeUint32(value) {}
+	writeUint64(hi, lo) {}
+	writeRawBytes(buffer) {}
+}
+export class DefaultSerializer extends Serializer {}

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

@@ -0,0 +1,2 @@
+export declare const USE_MAIN_CONTEXT_DEFAULT_LOADER: unknown;
+export declare const DONT_CONTEXTIFY: unknown;

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

@@ -0,0 +1,2 @@
+export const USE_MAIN_CONTEXT_DEFAULT_LOADER = /* @__PURE__ */ Symbol("vm_dynamic_import_main_context_default");
+export const DONT_CONTEXTIFY = /* @__PURE__ */ Symbol("vm_context_no_contextify");

package/dist/polyfills/unenv-runtime/node/internal/vm/script.d.mts

@@ -0,0 +1,7 @@
+import type nodeVm from "node:vm";
+export declare class Script implements nodeVm.Script {
+	runInContext(contextifiedObject: nodeVm.Context, options?: nodeVm.RunningScriptOptions | undefined);
+	runInNewContext(contextObject?: nodeVm.Context | undefined, options?: nodeVm.RunningScriptInNewContextOptions | undefined);
+	runInThisContext(options?: nodeVm.RunningScriptOptions | undefined);
+	createCachedData(): Buffer;
+}

package/dist/polyfills/unenv-runtime/node/internal/vm/script.mjs

@@ -0,0 +1,15 @@
+import { createNotImplementedError } from "../../../_internal/utils.mjs";
+export class Script {
+	runInContext(contextifiedObject, options) {
+		throw createNotImplementedError("Script.runInContext");
+	}
+	runInNewContext(contextObject, options) {
+		throw createNotImplementedError("Script.runInNewContext");
+	}
+	runInThisContext(options) {
+		throw createNotImplementedError("Script.runInThisContext");
+	}
+	createCachedData() {
+		throw createNotImplementedError("Script.createCachedData");
+	}
+}