@capsule-run/sdk 0.8.4 → 0.8.6

package/dist/polyfills/unenv-runtime/node/internal/worker_threads/broadcast-channel.d.mts

@@ -0,0 +1,10 @@
+import type nodeWorkerThreads from "node:worker_threads";
+export declare class BroadcastChannel implements nodeWorkerThreads.BroadcastChannel {
+	name: string;
+	onmessage;
+	onmessageerror;
+	close();
+	postMessage(message: unknown);
+	ref();
+	unref();
+}

package/dist/polyfills/unenv-runtime/node/internal/worker_threads/broadcast-channel.mjs

@@ -0,0 +1,13 @@
+export class BroadcastChannel {
+	name = "";
+	onmessage = (message) => {};
+	onmessageerror = (message) => {};
+	close() {}
+	postMessage(message) {}
+	ref() {
+		return this;
+	}
+	unref() {
+		return this;
+	}
+}

package/dist/polyfills/unenv-runtime/node/internal/worker_threads/message-channel.d.mts

@@ -0,0 +1,5 @@
+import type nodeWorkerThreads from "node:worker_threads";
+export declare class MessageChannel implements nodeWorkerThreads.MessageChannel {
+	port1;
+	port2;
+}

package/dist/polyfills/unenv-runtime/node/internal/worker_threads/message-channel.mjs

@@ -0,0 +1,5 @@
+import { MessagePort } from "./message-port.mjs";
+export class MessageChannel {
+	port1 = new MessagePort();
+	port2 = new MessagePort();
+}

package/dist/polyfills/unenv-runtime/node/internal/worker_threads/message-port.d.mts

@@ -0,0 +1,12 @@
+import { EventEmitter } from "node:events";
+import type nodeWorkerThreads from "node:worker_threads";
+export declare class MessagePort extends EventEmitter implements nodeWorkerThreads.MessagePort {
+	close();
+	postMessage(value: any, transferList?: readonly nodeWorkerThreads.TransferListItem[] | undefined);
+	ref();
+	unref();
+	start();
+	addEventListener(type: string, listener: (...args: any[]) => void): void;
+	removeEventListener(type: string, listener: (...args: any[]) => void): void;
+	dispatchEvent(event: Event);
+}

package/dist/polyfills/unenv-runtime/node/internal/worker_threads/message-port.mjs

@@ -0,0 +1,17 @@
+import { EventEmitter } from "node:events";
+export class MessagePort extends EventEmitter {
+	close() {}
+	postMessage(value, transferList) {}
+	ref() {}
+	unref() {}
+	start() {}
+	addEventListener(type, listener) {
+		this.on(type, listener);
+	}
+	removeEventListener(type, listener) {
+		this.off(type, listener);
+	}
+	dispatchEvent(event) {
+		return this.emit(event.type, event);
+	}
+}

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

@@ -0,0 +1,21 @@
+import { EventEmitter } from "node:events";
+import type nodeWorkerThreads from "node:worker_threads";
+export declare class Worker extends EventEmitter implements nodeWorkerThreads.Worker {
+	stdin: null;
+	stdout;
+	stderr;
+	threadId: number;
+	performance: {
+		eventLoopUtilization: () => {
+			idle: number;
+			active: number;
+			utilization: number;
+		};
+	};
+	postMessage(_value: any, _transferList?: readonly nodeWorkerThreads.TransferListItem[] | undefined);
+	postMessageToThread(_threadId: unknown, _value: unknown, _transferList?: unknown, _timeout?: unknown): Promise<void>;
+	ref();
+	unref();
+	terminate();
+	getHeapSnapshot();
+}

package/dist/polyfills/unenv-runtime/node/internal/worker_threads/worker.mjs

@@ -0,0 +1,25 @@
+import { EventEmitter } from "node:events";
+import { Readable } from "node:stream";
+export class Worker extends EventEmitter {
+	stdin = null;
+	stdout = new Readable();
+	stderr = new Readable();
+	threadId = 0;
+	performance = { eventLoopUtilization: () => ({
+		idle: 0,
+		active: 0,
+		utilization: 0
+	}) };
+	postMessage(_value, _transferList) {}
+	postMessageToThread(_threadId, _value, _transferList, _timeout) {
+		return Promise.resolve();
+	}
+	ref() {}
+	unref() {}
+	terminate() {
+		return Promise.resolve(0);
+	}
+	getHeapSnapshot() {
+		return Promise.resolve(new Readable());
+	}
+}

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

@@ -0,0 +1,21 @@
+// import type nodeZlib from "node:zlib";
+export declare const codes: {
+	"0": string;
+	"1": string;
+	"2": string;
+	Z_OK: number;
+	Z_STREAM_END: number;
+	Z_NEED_DICT: number;
+	Z_ERRNO: number;
+	Z_STREAM_ERROR: number;
+	Z_DATA_ERROR: number;
+	Z_MEM_ERROR: number;
+	Z_BUF_ERROR: number;
+	Z_VERSION_ERROR: number;
+	"-1": string;
+	"-2": string;
+	"-3": string;
+	"-4": string;
+	"-5": string;
+	"-6": string;
+};

package/dist/polyfills/unenv-runtime/node/internal/zlib/codes.mjs

@@ -0,0 +1,21 @@
+// import type nodeZlib from "node:zlib";
+export const codes = {
+	"0": "Z_OK",
+	"1": "Z_STREAM_END",
+	"2": "Z_NEED_DICT",
+	Z_OK: 0,
+	Z_STREAM_END: 1,
+	Z_NEED_DICT: 2,
+	Z_ERRNO: -1,
+	Z_STREAM_ERROR: -2,
+	Z_DATA_ERROR: -3,
+	Z_MEM_ERROR: -4,
+	Z_BUF_ERROR: -5,
+	Z_VERSION_ERROR: -6,
+	"-1": "Z_ERRNO",
+	"-2": "Z_STREAM_ERROR",
+	"-3": "Z_DATA_ERROR",
+	"-4": "Z_MEM_ERROR",
+	"-5": "Z_BUF_ERROR",
+	"-6": "Z_VERSION_ERROR"
+};

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

@@ -0,0 +1,108 @@
+// npx -y node@22.14 -e 'const{constants}=require("zlib");console.log(Object.entries(constants).map(([k,v]) => `export const ${k} = ${JSON.stringify(v)}`).join("\n"))'
+export declare const Z_NO_FLUSH = 0;
+export declare const Z_PARTIAL_FLUSH = 1;
+export declare const Z_SYNC_FLUSH = 2;
+export declare const Z_FULL_FLUSH = 3;
+export declare const Z_FINISH = 4;
+export declare const Z_BLOCK = 5;
+export declare const Z_OK = 0;
+export declare const Z_STREAM_END = 1;
+export declare const Z_NEED_DICT = 2;
+export declare const Z_ERRNO = -1;
+export declare const Z_STREAM_ERROR = -2;
+export declare const Z_DATA_ERROR = -3;
+export declare const Z_MEM_ERROR = -4;
+export declare const Z_BUF_ERROR = -5;
+export declare const Z_VERSION_ERROR = -6;
+export declare const Z_NO_COMPRESSION = 0;
+export declare const Z_BEST_SPEED = 1;
+export declare const Z_BEST_COMPRESSION = 9;
+export declare const Z_DEFAULT_COMPRESSION = -1;
+export declare const Z_FILTERED = 1;
+export declare const Z_HUFFMAN_ONLY = 2;
+export declare const Z_RLE = 3;
+export declare const Z_FIXED = 4;
+export declare const Z_DEFAULT_STRATEGY = 0;
+export declare const ZLIB_VERNUM = 4865;
+export declare const DEFLATE = 1;
+export declare const INFLATE = 2;
+export declare const GZIP = 3;
+export declare const GUNZIP = 4;
+export declare const DEFLATERAW = 5;
+export declare const INFLATERAW = 6;
+export declare const UNZIP = 7;
+export declare const BROTLI_DECODE = 8;
+export declare const BROTLI_ENCODE = 9;
+export declare const Z_MIN_WINDOWBITS = 8;
+export declare const Z_MAX_WINDOWBITS = 15;
+export declare const Z_DEFAULT_WINDOWBITS = 15;
+export declare const Z_MIN_CHUNK = 64;
+export declare const Z_MAX_CHUNK: unknown;
+export declare const Z_DEFAULT_CHUNK = 16384;
+export declare const Z_MIN_MEMLEVEL = 1;
+export declare const Z_MAX_MEMLEVEL = 9;
+export declare const Z_DEFAULT_MEMLEVEL = 8;
+export declare const Z_MIN_LEVEL = -1;
+export declare const Z_MAX_LEVEL = 9;
+export declare const Z_DEFAULT_LEVEL = -1;
+export declare const BROTLI_OPERATION_PROCESS = 0;
+export declare const BROTLI_OPERATION_FLUSH = 1;
+export declare const BROTLI_OPERATION_FINISH = 2;
+export declare const BROTLI_OPERATION_EMIT_METADATA = 3;
+export declare const BROTLI_PARAM_MODE = 0;
+export declare const BROTLI_MODE_GENERIC = 0;
+export declare const BROTLI_MODE_TEXT = 1;
+export declare const BROTLI_MODE_FONT = 2;
+export declare const BROTLI_DEFAULT_MODE = 0;
+export declare const BROTLI_PARAM_QUALITY = 1;
+export declare const BROTLI_MIN_QUALITY = 0;
+export declare const BROTLI_MAX_QUALITY = 11;
+export declare const BROTLI_DEFAULT_QUALITY = 11;
+export declare const BROTLI_PARAM_LGWIN = 2;
+export declare const BROTLI_MIN_WINDOW_BITS = 10;
+export declare const BROTLI_MAX_WINDOW_BITS = 24;
+export declare const BROTLI_LARGE_MAX_WINDOW_BITS = 30;
+export declare const BROTLI_DEFAULT_WINDOW = 22;
+export declare const BROTLI_PARAM_LGBLOCK = 3;
+export declare const BROTLI_MIN_INPUT_BLOCK_BITS = 16;
+export declare const BROTLI_MAX_INPUT_BLOCK_BITS = 24;
+export declare const BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING = 4;
+export declare const BROTLI_PARAM_SIZE_HINT = 5;
+export declare const BROTLI_PARAM_LARGE_WINDOW = 6;
+export declare const BROTLI_PARAM_NPOSTFIX = 7;
+export declare const BROTLI_PARAM_NDIRECT = 8;
+export declare const BROTLI_DECODER_RESULT_ERROR = 0;
+export declare const BROTLI_DECODER_RESULT_SUCCESS = 1;
+export declare const BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT = 2;
+export declare const BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT = 3;
+export declare const BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION = 0;
+export declare const BROTLI_DECODER_PARAM_LARGE_WINDOW = 1;
+export declare const BROTLI_DECODER_NO_ERROR = 0;
+export declare const BROTLI_DECODER_SUCCESS = 1;
+export declare const BROTLI_DECODER_NEEDS_MORE_INPUT = 2;
+export declare const BROTLI_DECODER_NEEDS_MORE_OUTPUT = 3;
+export declare const BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE = -1;
+export declare const BROTLI_DECODER_ERROR_FORMAT_RESERVED = -2;
+export declare const BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE = -3;
+export declare const BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET = -4;
+export declare const BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME = -5;
+export declare const BROTLI_DECODER_ERROR_FORMAT_CL_SPACE = -6;
+export declare const BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE = -7;
+export declare const BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT = -8;
+export declare const BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1 = -9;
+export declare const BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2 = -10;
+export declare const BROTLI_DECODER_ERROR_FORMAT_TRANSFORM = -11;
+export declare const BROTLI_DECODER_ERROR_FORMAT_DICTIONARY = -12;
+export declare const BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS = -13;
+export declare const BROTLI_DECODER_ERROR_FORMAT_PADDING_1 = -14;
+export declare const BROTLI_DECODER_ERROR_FORMAT_PADDING_2 = -15;
+export declare const BROTLI_DECODER_ERROR_FORMAT_DISTANCE = -16;
+export declare const BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET = -19;
+export declare const BROTLI_DECODER_ERROR_INVALID_ARGUMENTS = -20;
+export declare const BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES = -21;
+export declare const BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS = -22;
+export declare const BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP = -25;
+export declare const BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1 = -26;
+export declare const BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2 = -27;
+export declare const BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES = -30;
+export declare const BROTLI_DECODER_ERROR_UNREACHABLE = -31;

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

@@ -0,0 +1,108 @@
+// npx -y node@22.14 -e 'const{constants}=require("zlib");console.log(Object.entries(constants).map(([k,v]) => `export const ${k} = ${JSON.stringify(v)}`).join("\n"))'
+export const Z_NO_FLUSH = 0;
+export const Z_PARTIAL_FLUSH = 1;
+export const Z_SYNC_FLUSH = 2;
+export const Z_FULL_FLUSH = 3;
+export const Z_FINISH = 4;
+export const Z_BLOCK = 5;
+export const Z_OK = 0;
+export const Z_STREAM_END = 1;
+export const Z_NEED_DICT = 2;
+export const Z_ERRNO = -1;
+export const Z_STREAM_ERROR = -2;
+export const Z_DATA_ERROR = -3;
+export const Z_MEM_ERROR = -4;
+export const Z_BUF_ERROR = -5;
+export const Z_VERSION_ERROR = -6;
+export const Z_NO_COMPRESSION = 0;
+export const Z_BEST_SPEED = 1;
+export const Z_BEST_COMPRESSION = 9;
+export const Z_DEFAULT_COMPRESSION = -1;
+export const Z_FILTERED = 1;
+export const Z_HUFFMAN_ONLY = 2;
+export const Z_RLE = 3;
+export const Z_FIXED = 4;
+export const Z_DEFAULT_STRATEGY = 0;
+export const ZLIB_VERNUM = 4865;
+export const DEFLATE = 1;
+export const INFLATE = 2;
+export const GZIP = 3;
+export const GUNZIP = 4;
+export const DEFLATERAW = 5;
+export const INFLATERAW = 6;
+export const UNZIP = 7;
+export const BROTLI_DECODE = 8;
+export const BROTLI_ENCODE = 9;
+export const Z_MIN_WINDOWBITS = 8;
+export const Z_MAX_WINDOWBITS = 15;
+export const Z_DEFAULT_WINDOWBITS = 15;
+export const Z_MIN_CHUNK = 64;
+export const Z_MAX_CHUNK = Number.POSITIVE_INFINITY;
+export const Z_DEFAULT_CHUNK = 16384;
+export const Z_MIN_MEMLEVEL = 1;
+export const Z_MAX_MEMLEVEL = 9;
+export const Z_DEFAULT_MEMLEVEL = 8;
+export const Z_MIN_LEVEL = -1;
+export const Z_MAX_LEVEL = 9;
+export const Z_DEFAULT_LEVEL = -1;
+export const BROTLI_OPERATION_PROCESS = 0;
+export const BROTLI_OPERATION_FLUSH = 1;
+export const BROTLI_OPERATION_FINISH = 2;
+export const BROTLI_OPERATION_EMIT_METADATA = 3;
+export const BROTLI_PARAM_MODE = 0;
+export const BROTLI_MODE_GENERIC = 0;
+export const BROTLI_MODE_TEXT = 1;
+export const BROTLI_MODE_FONT = 2;
+export const BROTLI_DEFAULT_MODE = 0;
+export const BROTLI_PARAM_QUALITY = 1;
+export const BROTLI_MIN_QUALITY = 0;
+export const BROTLI_MAX_QUALITY = 11;
+export const BROTLI_DEFAULT_QUALITY = 11;
+export const BROTLI_PARAM_LGWIN = 2;
+export const BROTLI_MIN_WINDOW_BITS = 10;
+export const BROTLI_MAX_WINDOW_BITS = 24;
+export const BROTLI_LARGE_MAX_WINDOW_BITS = 30;
+export const BROTLI_DEFAULT_WINDOW = 22;
+export const BROTLI_PARAM_LGBLOCK = 3;
+export const BROTLI_MIN_INPUT_BLOCK_BITS = 16;
+export const BROTLI_MAX_INPUT_BLOCK_BITS = 24;
+export const BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING = 4;
+export const BROTLI_PARAM_SIZE_HINT = 5;
+export const BROTLI_PARAM_LARGE_WINDOW = 6;
+export const BROTLI_PARAM_NPOSTFIX = 7;
+export const BROTLI_PARAM_NDIRECT = 8;
+export const BROTLI_DECODER_RESULT_ERROR = 0;
+export const BROTLI_DECODER_RESULT_SUCCESS = 1;
+export const BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT = 2;
+export const BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT = 3;
+export const BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION = 0;
+export const BROTLI_DECODER_PARAM_LARGE_WINDOW = 1;
+export const BROTLI_DECODER_NO_ERROR = 0;
+export const BROTLI_DECODER_SUCCESS = 1;
+export const BROTLI_DECODER_NEEDS_MORE_INPUT = 2;
+export const BROTLI_DECODER_NEEDS_MORE_OUTPUT = 3;
+export const BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE = -1;
+export const BROTLI_DECODER_ERROR_FORMAT_RESERVED = -2;
+export const BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE = -3;
+export const BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET = -4;
+export const BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME = -5;
+export const BROTLI_DECODER_ERROR_FORMAT_CL_SPACE = -6;
+export const BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE = -7;
+export const BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT = -8;
+export const BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1 = -9;
+export const BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2 = -10;
+export const BROTLI_DECODER_ERROR_FORMAT_TRANSFORM = -11;
+export const BROTLI_DECODER_ERROR_FORMAT_DICTIONARY = -12;
+export const BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS = -13;
+export const BROTLI_DECODER_ERROR_FORMAT_PADDING_1 = -14;
+export const BROTLI_DECODER_ERROR_FORMAT_PADDING_2 = -15;
+export const BROTLI_DECODER_ERROR_FORMAT_DISTANCE = -16;
+export const BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET = -19;
+export const BROTLI_DECODER_ERROR_INVALID_ARGUMENTS = -20;
+export const BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES = -21;
+export const BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS = -22;
+export const BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP = -25;
+export const BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1 = -26;
+export const BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2 = -27;
+export const BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES = -30;
+export const BROTLI_DECODER_ERROR_UNREACHABLE = -31;

package/dist/polyfills/unenv-runtime/node/internal/zlib/formats/_shared.d.mts

@@ -0,0 +1,22 @@
+import type nodeZlib from "node:zlib";
+import { Transform, type TransformOptions } from "node:stream";
+// Compression
+export declare abstract class ZlibCompress extends Transform {
+	readonly __unenv__: true;
+	readonly bytesRead = 0;
+	readonly bytesWritten = 0;
+	abstract readonly _format: undefined | "deflate" | "gzip" | "zlib" | "brotli" | "zip";
+	constructor(opts?: TransformOptions);
+	close(callback?: () => void);
+	flush(kind?: number | undefined, callback?: (() => void) | undefined): void;
+	flush(callback?: (() => void) | undefined): void;
+}
+// Decompression
+export declare abstract class ZLibDecompress extends ZlibCompress {}
+// Mock Compress/Decompress Function factory
+export interface CompressFunction {
+	(buf: nodeZlib.InputType, options?: any, callback?: nodeZlib.CompressCallback): void;
+	(buf: Buffer, callback?: nodeZlib.CompressCallback): void;
+	__promisify__(buffer: nodeZlib.InputType, options?: any): Promise<Buffer>;
+}
+export declare function notImplementedCompress(format: string): CompressFunction;

package/dist/polyfills/unenv-runtime/node/internal/zlib/formats/_shared.mjs

@@ -0,0 +1,40 @@
+import { Transform } from "node:stream";
+import { createNotImplementedError } from "../../../../_internal/utils.mjs";
+// Compression
+export class ZlibCompress extends Transform {
+	__unenv__ = true;
+	bytesRead = 0;
+	bytesWritten = 0;
+	constructor(opts) {
+		super(opts);
+		throw createNotImplementedError("zlib is not implemented yet!");
+	}
+	close(callback) {
+		if (typeof callback === "function") {
+			callback();
+		}
+	}
+	flush(kind, callback) {
+		if (typeof callback === "function") {
+			callback();
+		}
+	}
+}
+// Decompression
+export class ZLibDecompress extends ZlibCompress {}
+export function notImplementedCompress(format) {
+	const fn = function(_buf, arg2, arg3) {
+		const cb = typeof arg2 === "function" ? arg2 : arg3;
+		const err = new Error(`[unenv] zlib ${format} compression not supported.`);
+		if (typeof cb === "function") {
+			cb(err, Buffer.from(""));
+		} else {
+			throw err;
+		}
+	};
+	return Object.assign(fn, { __promisify__: (buffer, options) => {
+		return new Promise((resolve, reject) => {
+			fn(buffer, options, (err, result) => err ? reject(err) : resolve(result));
+		});
+	} });
+}

package/dist/polyfills/unenv-runtime/node/internal/zlib/formats/brotli.d.mts

@@ -0,0 +1,16 @@
+import type nodeZlib from "node:zlib";
+import { ZlibCompress, ZLibDecompress } from "./_shared.mjs";
+// Brotli Compression
+export declare class BrotliCompress extends ZlibCompress {
+	readonly _format = "brotli";
+}
+export declare const brotliCompress: typeof nodeZlib.brotliCompress;
+export declare const createBrotliCompress: typeof nodeZlib.createBrotliCompress;
+export declare const brotliCompressSync: typeof nodeZlib.brotliCompressSync;
+// Brotli Decompression
+export declare class BrotliDecompress extends ZLibDecompress {
+	readonly _format = "brotli";
+}
+export declare const brotliDecompress: typeof nodeZlib.brotliDecompress;
+export declare const createBrotliDecompress: typeof nodeZlib.createBrotliDecompress;
+export declare const brotliDecompressSync: typeof nodeZlib.brotliDecompressSync;

package/dist/polyfills/unenv-runtime/node/internal/zlib/formats/brotli.mjs

@@ -0,0 +1,16 @@
+import { notImplemented } from "../../../../_internal/utils.mjs";
+import { ZlibCompress, ZLibDecompress, notImplementedCompress } from "./_shared.mjs";
+// Brotli Compression
+export class BrotliCompress extends ZlibCompress {
+	_format = "brotli";
+}
+export const brotliCompress = notImplementedCompress("brotliCompress");
+export const createBrotliCompress = () => new BrotliCompress();
+export const brotliCompressSync = /* @__PURE__ */ notImplemented("zlib.brotliCompressSync");
+// Brotli Decompression
+export class BrotliDecompress extends ZLibDecompress {
+	_format = "brotli";
+}
+export const brotliDecompress = notImplementedCompress("brotliDecompress");
+export const createBrotliDecompress = () => new BrotliDecompress();
+export const brotliDecompressSync = /* @__PURE__ */ notImplemented("zlib.brotliDecompressSync");

package/dist/polyfills/unenv-runtime/node/internal/zlib/formats/deflate.d.mts

@@ -0,0 +1,29 @@
+import type nodeZlib from "node:zlib";
+import { ZlibCompress, ZLibDecompress } from "./_shared.mjs";
+// Deflate Compression
+export declare class Deflate extends ZlibCompress {
+	readonly _format = "deflate";
+	params(level: number, strategy: number, callback: () => void);
+	reset();
+}
+export declare const deflate: typeof nodeZlib.deflate;
+export declare const createDeflate: typeof nodeZlib.createDeflate;
+export declare const deflateSync: typeof nodeZlib.deflateSync;
+// Deflate Decompress(Inflate)
+export declare class Inflate extends ZLibDecompress {
+	readonly _format = "deflate";
+	reset();
+}
+export declare const inflate: typeof nodeZlib.inflate;
+export declare const createInflate: typeof nodeZlib.createInflate;
+export declare const inflateSync: typeof nodeZlib.inflateSync;
+// Deflate Raw Compression
+export declare class DeflateRaw extends Deflate {}
+export declare const deflateRaw: typeof nodeZlib.deflateRaw;
+export declare const createDeflateRaw: typeof nodeZlib.createDeflateRaw;
+export declare const deflateRawSync: typeof nodeZlib.deflateRawSync;
+// Inflate Raw Decompress (Inflate Raw)
+export declare class InflateRaw extends Inflate {}
+export declare const inflateRaw: typeof nodeZlib.inflateRaw;
+export declare const createInflateRaw: typeof nodeZlib.createInflateRaw;
+export declare const inflateRawSync: typeof nodeZlib.inflateRawSync;

package/dist/polyfills/unenv-runtime/node/internal/zlib/formats/deflate.mjs

@@ -0,0 +1,36 @@
+import { createNotImplementedError } from "../../../../_internal/utils.mjs";
+import { notImplemented } from "../../../../_internal/utils.mjs";
+import { ZlibCompress, ZLibDecompress, notImplementedCompress } from "./_shared.mjs";
+// Deflate Compression
+export class Deflate extends ZlibCompress {
+	_format = "deflate";
+	params(level, strategy, callback) {
+		throw createNotImplementedError("Deflate.params");
+	}
+	reset() {
+		throw createNotImplementedError("Deflate.reset");
+	}
+}
+export const deflate = notImplementedCompress("deflate");
+export const createDeflate = () => new Deflate();
+export const deflateSync = /* @__PURE__ */ notImplemented("zlib.deflateSync");
+// Deflate Decompress(Inflate)
+export class Inflate extends ZLibDecompress {
+	_format = "deflate";
+	reset() {
+		throw createNotImplementedError("Inflate.reset");
+	}
+}
+export const inflate = notImplementedCompress("inflate");
+export const createInflate = () => new Inflate();
+export const inflateSync = /* @__PURE__ */ notImplemented("zlib.inflateSync");
+// Deflate Raw Compression
+export class DeflateRaw extends Deflate {}
+export const deflateRaw = notImplementedCompress("deflateRaw");
+export const createDeflateRaw = () => new DeflateRaw();
+export const deflateRawSync = /* @__PURE__ */ notImplemented("zlib.deflateRawSync");
+// Inflate Raw Decompress (Inflate Raw)
+export class InflateRaw extends Inflate {}
+export const inflateRaw = notImplementedCompress("inflateRaw");
+export const createInflateRaw = () => new InflateRaw();
+export const inflateRawSync = /* @__PURE__ */ notImplemented("zlib.inflateRawSync");

package/dist/polyfills/unenv-runtime/node/internal/zlib/formats/gzip.d.mts

@@ -0,0 +1,16 @@
+import type nodeZlib from "node:zlib";
+import { ZlibCompress, ZLibDecompress } from "./_shared.mjs";
+// Gzip Compression
+export declare class Gzip extends ZlibCompress {
+	readonly _format = "gzip";
+}
+export declare const gzip: typeof nodeZlib.gzip;
+export declare const createGzip: typeof nodeZlib.createGzip;
+export declare const gzipSync: typeof nodeZlib.gzipSync;
+// Gzip Decompression
+export declare class Gunzip extends ZLibDecompress {
+	readonly _format = "gzip";
+}
+export declare const gunzip: typeof nodeZlib.gunzip;
+export declare const createGunzip: typeof nodeZlib.createGunzip;
+export declare const gunzipSync: typeof nodeZlib.gunzipSync;

package/dist/polyfills/unenv-runtime/node/internal/zlib/formats/gzip.mjs

@@ -0,0 +1,16 @@
+import { notImplemented } from "../../../../_internal/utils.mjs";
+import { ZlibCompress, ZLibDecompress, notImplementedCompress } from "./_shared.mjs";
+// Gzip Compression
+export class Gzip extends ZlibCompress {
+	_format = "gzip";
+}
+export const gzip = notImplementedCompress("gzip");
+export const createGzip = () => new Gzip();
+export const gzipSync = /* @__PURE__ */ notImplemented("zlib.gzipSync");
+// Gzip Decompression
+export class Gunzip extends ZLibDecompress {
+	_format = "gzip";
+}
+export const gunzip = notImplementedCompress("gunzip");
+export const createGunzip = () => new Gunzip();
+export const gunzipSync = /* @__PURE__ */ notImplemented("zlib.gunzipSync");

package/dist/polyfills/unenv-runtime/node/internal/zlib/formats/zip.d.mts

@@ -0,0 +1,9 @@
+import type nodeZlib from "node:zlib";
+import { ZlibCompress } from "./_shared.mjs";
+// Zip Decompression
+export declare class Unzip extends ZlibCompress {
+	readonly _format = "zip";
+}
+export declare const createUnzip: typeof nodeZlib.createUnzip;
+export declare const unzip: typeof nodeZlib.unzip;
+export declare const unzipSync: typeof nodeZlib.unzipSync;

package/dist/polyfills/unenv-runtime/node/internal/zlib/formats/zip.mjs

@@ -0,0 +1,9 @@
+import { notImplemented } from "../../../../_internal/utils.mjs";
+import { ZlibCompress } from "./_shared.mjs";
+// Zip Decompression
+export class Unzip extends ZlibCompress {
+	_format = "zip";
+}
+export const createUnzip = () => new Unzip();
+export const unzip = /* @__PURE__ */ notImplemented("zlib.unzip");
+export const unzipSync = /* @__PURE__ */ notImplemented("zlib.unzipSync");

package/dist/polyfills/unenv-runtime/node/module.d.mts

@@ -0,0 +1,54 @@
+// https://nodejs.org/api/module.html
+import type nodeModule from "node:module";
+export declare const _cache: unknown;
+export declare const _extensions: {};
+export declare const createRequire: unknown;
+export declare const getCompileCacheDir: typeof nodeModule.getCompileCacheDir;
+export declare const enableCompileCache: typeof nodeModule.enableCompileCache;
+export declare const constants: typeof nodeModule.constants;
+// prettier-ignore
+export declare const builtinModules: typeof nodeModule.builtinModules;
+export declare const isBuiltin: typeof nodeModule.isBuiltin;
+export declare const runMain: typeof nodeModule.runMain;
+export declare const register: typeof nodeModule.register;
+export declare const syncBuiltinESMExports: typeof nodeModule.syncBuiltinESMExports;
+export declare const findSourceMap: typeof nodeModule.findSourceMap;
+export declare const flushCompileCache: typeof nodeModule.flushCompileCache;
+export declare const wrap: typeof nodeModule.wrap;
+export declare const wrapper: unknown;
+export declare const stripTypeScriptTypes: typeof nodeModule.stripTypeScriptTypes;
+export declare const SourceMap: typeof nodeModule.SourceMap;
+export declare const _debug: unknown;
+export declare const _findPath: unknown;
+export declare const _initPaths: unknown;
+export declare const _load: unknown;
+export declare const _nodeModulePaths: unknown;
+export declare const _preloadModules: unknown;
+export declare const _resolveFilename: unknown;
+export declare const _resolveLookupPaths: unknown;
+export declare const _stat: unknown;
+export declare const _readPackage: unknown;
+export declare const findPackageJSON: unknown;
+export declare const getSourceMapsSupport: unknown;
+export declare const setSourceMapsSupport: unknown;
+export declare const _pathCache: unknown;
+export declare const globalPaths: unknown;
+// export class _Module implements NodeJS.Module {
+//   require: NodeJS.Require;
+//   id: string;
+//   filename: string;
+//   exports = Object.create(null);
+//   parent = undefined;
+//   loaded = true;
+//   children = [];
+//   isPreloading: boolean = false;
+//   path: string = "/";
+//   paths: string[] = [];
+//   constructor(id = "index.js") {
+//     this.id = id;
+//     this.filename = id;
+//     this.require = createRequire(id);
+//   }
+// }
+export declare const Module: {};
+export default Module;