@capsule-run/sdk 0.8.4 → 0.8.6

package/dist/polyfills/unenv-runtime/node/readline/promises.d.mts

@@ -0,0 +1,6 @@
+import type nodeReadline from "node:readline/promises";
+export { Interface } from "../internal/readline/promises/interface.mjs";
+export { Readline } from "../internal/readline/promises/readline.mjs";
+export declare const createInterface: typeof nodeReadline.createInterface;
+declare const _default: typeof nodeReadline;
+export default _default;

package/dist/polyfills/unenv-runtime/node/readline/promises.mjs

@@ -0,0 +1,10 @@
+import { Interface } from "../internal/readline/promises/interface.mjs";
+import { Readline } from "../internal/readline/promises/readline.mjs";
+export { Interface } from "../internal/readline/promises/interface.mjs";
+export { Readline } from "../internal/readline/promises/readline.mjs";
+export const createInterface = () => new Interface();
+export default {
+	Interface,
+	Readline,
+	createInterface
+};

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

@@ -0,0 +1,13 @@
+// https://nodejs.org/api/readline.html#readlineclearlinestream-dir-callback
+import type nodeReadline from "node:readline";
+import promises from "node:readline/promises";
+export { promises };
+export { Interface } from "./internal/readline/interface.mjs";
+export declare const clearLine: typeof nodeReadline.clearLine;
+export declare const clearScreenDown: typeof nodeReadline.clearScreenDown;
+export declare const createInterface: typeof nodeReadline.createInterface;
+export declare const cursorTo: typeof nodeReadline.cursorTo;
+export declare const emitKeypressEvents: typeof nodeReadline.emitKeypressEvents;
+export declare const moveCursor: typeof nodeReadline.moveCursor;
+declare const _default: {};
+export default _default;

package/dist/polyfills/unenv-runtime/node/readline.mjs

@@ -0,0 +1,21 @@
+import noop from "../mock/noop.mjs";
+import promises from "node:readline/promises";
+import { Interface } from "./internal/readline/interface.mjs";
+export { promises };
+export { Interface } from "./internal/readline/interface.mjs";
+export const clearLine = () => false;
+export const clearScreenDown = () => false;
+export const createInterface = () => new Interface();
+export const cursorTo = () => false;
+export const emitKeypressEvents = noop;
+export const moveCursor = () => false;
+export default {
+	clearLine,
+	clearScreenDown,
+	createInterface,
+	cursorTo,
+	emitKeypressEvents,
+	moveCursor,
+	Interface,
+	promises
+};

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

@@ -0,0 +1,10 @@
+export declare const writer: unknown;
+export declare const start: unknown;
+export declare const Recoverable: unknown;
+export declare const REPLServer: unknown;
+export declare const REPL_MODE_SLOPPY: unique symbol;
+export declare const REPL_MODE_STRICT: unique symbol;
+export declare const builtinModules: unknown;
+export declare const _builtinLibs: unknown;
+declare const _default: {};
+export default _default;

package/dist/polyfills/unenv-runtime/node/repl.mjs

@@ -0,0 +1,20 @@
+import { builtinModules as _builtinModules } from "node:module";
+import { notImplemented, notImplementedClass } from "../_internal/utils.mjs";
+export const writer = /* @__PURE__ */ notImplementedClass("repl.writer");
+export const start = /* @__PURE__ */ notImplemented("repl.start");
+export const Recoverable = /* @__PURE__ */ notImplementedClass("repl.Recoverable");
+export const REPLServer = /* @__PURE__ */ notImplementedClass("repl.REPLServer");
+export const REPL_MODE_SLOPPY = /* @__PURE__ */ Symbol("repl-sloppy");
+export const REPL_MODE_STRICT = /* @__PURE__ */ Symbol("repl-strict");
+export const builtinModules = /* @__PURE__ */ _builtinModules.filter((m) => m[0] !== "_");
+export const _builtinLibs = builtinModules;
+export default {
+	writer,
+	start,
+	Recoverable,
+	REPLServer,
+	builtinModules,
+	_builtinLibs,
+	REPL_MODE_SLOPPY,
+	REPL_MODE_STRICT
+};

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

@@ -0,0 +1,6 @@
+import type * as nodeSqlite from "node:sqlite";
+export declare const DatabaseSync: typeof nodeSqlite.DatabaseSync;
+export declare const StatementSync: typeof nodeSqlite.StatementSync;
+export declare const constants: typeof nodeSqlite.constants;
+declare const _default: {};
+export default _default;

package/dist/polyfills/unenv-runtime/node/sqlite.mjs

@@ -0,0 +1,9 @@
+import { notImplementedClass } from "../_internal/utils.mjs";
+export const DatabaseSync = /* @__PURE__ */ notImplementedClass("sqlite.DatabaseSync");
+export const StatementSync = /* @__PURE__ */ notImplementedClass("sqlite.StatementSync");
+export const constants = {};
+export default {
+	DatabaseSync,
+	StatementSync,
+	constants
+};

package/dist/polyfills/unenv-runtime/node/stream/consumers.d.mts

@@ -0,0 +1,7 @@
+export declare const arrayBuffer: unknown;
+export declare const blob: unknown;
+export declare const buffer: unknown;
+export declare const text: unknown;
+export declare const json: unknown;
+declare const _default: {};
+export default _default;

package/dist/polyfills/unenv-runtime/node/stream/consumers.mjs

@@ -0,0 +1,13 @@
+import { notImplemented } from "../../_internal/utils.mjs";
+export const arrayBuffer = /* @__PURE__ */ notImplemented("stream.consumers.arrayBuffer");
+export const blob = /* @__PURE__ */ notImplemented("stream.consumers.blob");
+export const buffer = /* @__PURE__ */ notImplemented("stream.consumers.buffer");
+export const text = /* @__PURE__ */ notImplemented("stream.consumers.text");
+export const json = /* @__PURE__ */ notImplemented("stream.consumers.json");
+export default {
+	arrayBuffer,
+	blob,
+	buffer,
+	text,
+	json
+};

package/dist/polyfills/unenv-runtime/node/stream/promises.d.mts

@@ -0,0 +1,4 @@
+export declare const finished: unknown;
+export declare const pipeline: unknown;
+declare const _default: {};
+export default _default;

package/dist/polyfills/unenv-runtime/node/stream/promises.mjs

@@ -0,0 +1,7 @@
+import { notImplemented } from "../../_internal/utils.mjs";
+export const finished = /* @__PURE__ */ notImplemented("stream.promises.finished");
+export const pipeline = /* @__PURE__ */ notImplemented("stream.promises.pipeline");
+export default {
+	finished,
+	pipeline
+};

package/dist/polyfills/unenv-runtime/node/stream/web.d.mts

@@ -0,0 +1,24 @@
+import type nodeStreamWeb from "node:stream/web";
+export declare const ReadableStream: unknown;
+export declare const ReadableStreamDefaultReader: unknown;
+// @ts-ignore
+export declare const ReadableStreamBYOBReader: unknown;
+// @ts-ignore
+export declare const ReadableStreamBYOBRequest: unknown;
+// @ts-ignore
+export declare const ReadableByteStreamController: unknown;
+export declare const ReadableStreamDefaultController: unknown;
+export declare const TransformStream: unknown;
+export declare const TransformStreamDefaultController: unknown;
+export declare const WritableStream: unknown;
+export declare const WritableStreamDefaultWriter: unknown;
+export declare const WritableStreamDefaultController: unknown;
+export declare const ByteLengthQueuingStrategy: unknown;
+export declare const CountQueuingStrategy: unknown;
+export declare const TextEncoderStream: unknown;
+export declare const TextDecoderStream: unknown;
+export declare const DecompressionStream: unknown;
+export declare const CompressionStream: unknown;
+// @ts-ignore
+declare const _default: typeof nodeStreamWeb;
+export default _default;

package/dist/polyfills/unenv-runtime/node/stream/web.mjs

@@ -0,0 +1,41 @@
+import { notImplemented } from "../../_internal/utils.mjs";
+export const ReadableStream = globalThis.ReadableStream || /* @__PURE__ */ notImplemented("stream.web.ReadableStream");
+export const ReadableStreamDefaultReader = globalThis.ReadableStreamDefaultReader || /* @__PURE__ */ notImplemented("stream.web.ReadableStreamDefaultReader");
+// @ts-ignore
+export const ReadableStreamBYOBReader = globalThis.ReadableStreamBYOBReader || /* @__PURE__ */ notImplemented("stream.web.ReadableStreamBYOBReader");
+// @ts-ignore
+export const ReadableStreamBYOBRequest = globalThis.ReadableStreamBYOBRequest || /* @__PURE__ */ notImplemented("stream.web.ReadableStreamBYOBRequest");
+// @ts-ignore
+export const ReadableByteStreamController = globalThis.ReadableByteStreamController || /* @__PURE__ */ notImplemented("stream.web.ReadableByteStreamController");
+export const ReadableStreamDefaultController = globalThis.ReadableStreamDefaultController || /* @__PURE__ */ notImplemented("stream.web.ReadableStreamDefaultController");
+export const TransformStream = globalThis.TransformStream || /* @__PURE__ */ notImplemented("stream.web.TransformStream");
+export const TransformStreamDefaultController = globalThis.TransformStreamDefaultController || /* @__PURE__ */ notImplemented("stream.web.TransformStreamDefaultController");
+export const WritableStream = globalThis.WritableStream || /* @__PURE__ */ notImplemented("stream.web.WritableStream");
+export const WritableStreamDefaultWriter = globalThis.WritableStreamDefaultWriter || /* @__PURE__ */ notImplemented("stream.web.WritableStreamDefaultWriter");
+export const WritableStreamDefaultController = globalThis.WritableStreamDefaultController || /* @__PURE__ */ notImplemented("stream.web.WritableStreamDefaultController");
+export const ByteLengthQueuingStrategy = globalThis.ByteLengthQueuingStrategy || /* @__PURE__ */ notImplemented("stream.web.ByteLengthQueuingStrategy");
+export const CountQueuingStrategy = globalThis.CountQueuingStrategy || /* @__PURE__ */ notImplemented("stream.web.CountQueuingStrategy");
+export const TextEncoderStream = globalThis.TextEncoderStream || /* @__PURE__ */ notImplemented("stream.web.TextEncoderStream");
+export const TextDecoderStream = globalThis.TextDecoderStream || /* @__PURE__ */ notImplemented("stream.web.TextDecoderStream");
+export const DecompressionStream = globalThis.DecompressionStream || /* @__PURE__ */ notImplemented("stream.web.DecompressionStream");
+export const CompressionStream = globalThis.DecompressionStream || /* @__PURE__ */ notImplemented("stream.web.CompressionStream");
+// @ts-ignore
+export default {
+	ReadableStream,
+	ReadableStreamDefaultReader,
+	ReadableStreamBYOBReader,
+	ReadableStreamBYOBRequest,
+	ReadableByteStreamController,
+	ReadableStreamDefaultController,
+	TransformStream,
+	TransformStreamDefaultController,
+	WritableStream,
+	WritableStreamDefaultWriter,
+	WritableStreamDefaultController,
+	ByteLengthQueuingStrategy,
+	CountQueuingStrategy,
+	TextEncoderStream,
+	TextDecoderStream,
+	DecompressionStream,
+	CompressionStream
+};

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

@@ -0,0 +1,42 @@
+// https://nodejs.org/api/stream.html
+import type nodeStream from "node:stream";
+import promises from "node:stream/promises";
+export { promises };
+export { Readable } from "./internal/stream/readable.mjs";
+export { Writable } from "./internal/stream/writable.mjs";
+export { Duplex } from "./internal/stream/duplex.mjs";
+export { Transform } from "./internal/stream/transform.mjs";
+export declare const Stream: nodeStream.Stream;
+export declare const PassThrough: nodeStream.PassThrough;
+export declare const pipeline: any;
+export declare const finished: any;
+export declare const addAbortSignal: unknown;
+export declare const isDisturbed: unknown;
+export declare const isReadable: unknown;
+export declare const compose: unknown;
+export declare const isErrored: unknown;
+export declare const destroy: unknown;
+export declare const _isUint8Array: unknown;
+export declare const _uint8ArrayToBuffer: unknown;
+export declare const _isArrayBufferView: unknown;
+export declare const duplexPair: unknown;
+export declare const getDefaultHighWaterMark: unknown;
+export declare const isDestroyed: unknown;
+export declare const isWritable: unknown;
+export declare const setDefaultHighWaterMark: unknown;
+declare const _default: typeof nodeStream & {
+	isDisturbed: any;
+	isReadable: any;
+	compose: any;
+	isErrored: any;
+	destroy: any;
+	_isUint8Array: any;
+	_uint8ArrayToBuffer: any;
+	_isArrayBufferView: any;
+	duplexPair: any;
+	getDefaultHighWaterMark: any;
+	isDestroyed: any;
+	isWritable: any;
+	setDefaultHighWaterMark: any;
+};
+export default _default;

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

@@ -0,0 +1,54 @@
+import { notImplemented, notImplementedClass } from "../_internal/utils.mjs";
+import { Readable } from "./internal/stream/readable.mjs";
+import { Writable } from "./internal/stream/writable.mjs";
+import { Duplex } from "./internal/stream/duplex.mjs";
+import { Transform } from "./internal/stream/transform.mjs";
+import promises from "node:stream/promises";
+export { promises };
+export { Readable } from "./internal/stream/readable.mjs";
+export { Writable } from "./internal/stream/writable.mjs";
+export { Duplex } from "./internal/stream/duplex.mjs";
+export { Transform } from "./internal/stream/transform.mjs";
+export const Stream = /* @__PURE__ */ notImplementedClass("stream.Stream");
+export const PassThrough = /* @__PURE__ */ notImplementedClass("PassThrough");
+export const pipeline = /* @__PURE__ */ notImplemented("stream.pipeline");
+export const finished = /* @__PURE__ */ notImplemented("stream.finished");
+export const addAbortSignal = /* @__PURE__ */ notImplemented("stream.addAbortSignal");
+export const isDisturbed = /* @__PURE__ */ notImplemented("stream.isDisturbed");
+export const isReadable = /* @__PURE__ */ notImplemented("stream.isReadable");
+export const compose = /* @__PURE__ */ notImplemented("stream.compose");
+export const isErrored = /* @__PURE__ */ notImplemented("stream.isErrored");
+export const destroy = /* @__PURE__ */ notImplemented("stream.destroy");
+export const _isUint8Array = /* @__PURE__ */ notImplemented("stream._isUint8Array");
+export const _uint8ArrayToBuffer = /* @__PURE__ */ notImplemented("stream._uint8ArrayToBuffer");
+export const _isArrayBufferView = /* @__PURE__ */ notImplemented("stream._isArrayBufferView");
+export const duplexPair = /* @__PURE__ */ notImplemented("stream.duplexPair");
+export const getDefaultHighWaterMark = /* @__PURE__ */ notImplemented("stream.getDefaultHighWaterMark");
+export const isDestroyed = /* @__PURE__ */ notImplemented("stream.isDestroyed");
+export const isWritable = /* @__PURE__ */ notImplemented("stream.isWritable");
+export const setDefaultHighWaterMark = /* @__PURE__ */ notImplemented("stream.setDefaultHighWaterMark");
+export default {
+	Readable,
+	Writable,
+	Duplex,
+	Transform,
+	Stream,
+	PassThrough,
+	pipeline,
+	finished,
+	addAbortSignal,
+	promises,
+	isDisturbed,
+	isReadable,
+	compose,
+	_uint8ArrayToBuffer,
+	isErrored,
+	destroy,
+	_isUint8Array,
+	_isArrayBufferView,
+	duplexPair,
+	getDefaultHighWaterMark,
+	isDestroyed,
+	isWritable,
+	setDefaultHighWaterMark
+};

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

@@ -0,0 +1,5 @@
+// https://nodejs.org/api/string_decoder.html
+import type nodeStringDecoder from "node:string_decoder";
+export declare const StringDecoder: typeof nodeStringDecoder.StringDecoder;
+declare const _default: {};
+export default _default;

package/dist/polyfills/unenv-runtime/node/string_decoder.mjs

@@ -0,0 +1,3 @@
+import { notImplementedClass } from "../_internal/utils.mjs";
+export const StringDecoder = globalThis.StringDecoder || /* @__PURE__ */ notImplementedClass("string_decoder.StringDecoder");
+export default { StringDecoder };

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

@@ -0,0 +1,2 @@
+export * from "./util.mjs";
+export { default } from "./util.mjs";

package/dist/polyfills/unenv-runtime/node/sys.mjs

@@ -0,0 +1,2 @@
+export * from "./util.mjs";
+export { default } from "./util.mjs";

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

@@ -0,0 +1,6 @@
+export { setTimeoutFallbackPromises as setTimeout } from "../internal/timers/set-timeout.mjs";
+export { setIntervalFallbackPromises as setInterval } from "../internal/timers/set-interval.mjs";
+export { setImmediateFallbackPromises as setImmediate } from "../internal/timers/set-immediate.mjs";
+export declare const scheduler: unknown;
+declare const _default: {};
+export default _default;

package/dist/polyfills/unenv-runtime/node/timers/promises.mjs

@@ -0,0 +1,14 @@
+import { Scheduler } from "../internal/timers/scheduler.mjs";
+import { setTimeoutFallbackPromises } from "../internal/timers/set-timeout.mjs";
+import { setIntervalFallbackPromises } from "../internal/timers/set-interval.mjs";
+import { setImmediateFallbackPromises } from "../internal/timers/set-immediate.mjs";
+export { setTimeoutFallbackPromises as setTimeout } from "../internal/timers/set-timeout.mjs";
+export { setIntervalFallbackPromises as setInterval } from "../internal/timers/set-interval.mjs";
+export { setImmediateFallbackPromises as setImmediate } from "../internal/timers/set-immediate.mjs";
+export const scheduler = new Scheduler();
+export default {
+	scheduler,
+	setImmediate: setImmediateFallbackPromises,
+	setInterval: setIntervalFallbackPromises,
+	setTimeout: setTimeoutFallbackPromises
+};

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

@@ -0,0 +1,15 @@
+import type nodeTimers from "node:timers";
+import promises from "node:timers/promises";
+export { promises };
+export declare const clearImmediate: typeof nodeTimers.clearImmediate;
+export declare const clearInterval: typeof nodeTimers.clearInterval;
+export declare const clearTimeout: typeof nodeTimers.clearTimeout;
+export declare const setImmediate: typeof nodeTimers.setImmediate;
+export declare const setTimeout: typeof nodeTimers.setTimeout;
+export declare const setInterval: typeof nodeTimers.setInterval;
+export declare const active: unknown;
+export declare const _unrefActive: unknown;
+export declare const enroll: unknown;
+export declare const unenroll: unknown;
+declare const _default: {};
+export default _default;

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

@@ -0,0 +1,32 @@
+import { notImplemented } from "../_internal/utils.mjs";
+import noop from "../mock/noop.mjs";
+import promises from "node:timers/promises";
+import { setTimeoutFallback } from "./internal/timers/set-timeout.mjs";
+import { setImmediateFallback, clearImmediateFallback } from "./internal/timers/set-immediate.mjs";
+import { setIntervalFallback } from "./internal/timers/set-interval.mjs";
+export { promises };
+export const clearImmediate = globalThis.clearImmediate?.bind(globalThis) || clearImmediateFallback;
+export const clearInterval = globalThis.clearInterval?.bind(globalThis) || noop;
+export const clearTimeout = globalThis.clearTimeout?.bind(globalThis) || noop;
+export const setImmediate = globalThis.setImmediate?.bind(globalThis) || setImmediateFallback;
+export const setTimeout = globalThis.setTimeout?.bind(globalThis) || setTimeoutFallback;
+export const setInterval = globalThis.setInterval?.bind(globalThis) || setIntervalFallback;
+export const active = function active(timeout) {
+	timeout?.refresh?.();
+};
+export const _unrefActive = active;
+export const enroll = /* @__PURE__ */ notImplemented("timers.enroll");
+export const unenroll = /* @__PURE__ */ notImplemented("timers.unenroll");
+export default {
+	_unrefActive,
+	active,
+	clearImmediate,
+	clearInterval,
+	clearTimeout,
+	enroll,
+	promises,
+	setImmediate,
+	setInterval,
+	setTimeout,
+	unenroll
+};

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

@@ -0,0 +1,15 @@
+import type nodeTls from "node:tls";
+export * from "./internal/tls/constants.mjs";
+export { TLSSocket } from "./internal/tls/tls-socket.mjs";
+export { Server } from "./internal/tls/server.mjs";
+export { SecureContext } from "./internal/tls/secure-context.mjs";
+export declare const connect: typeof nodeTls.connect;
+export declare const createServer: typeof nodeTls.createServer;
+export declare const checkServerIdentity: typeof nodeTls.checkServerIdentity;
+export declare const convertALPNProtocols: unknown;
+export declare const createSecureContext: typeof nodeTls.createSecureContext;
+export declare const createSecurePair: typeof nodeTls.createSecurePair;
+export declare const getCiphers: typeof nodeTls.getCiphers;
+export declare const rootCertificates: typeof nodeTls.rootCertificates;
+declare const _default: typeof nodeTls;
+export default _default;

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

@@ -0,0 +1,41 @@
+import { notImplemented } from "../_internal/utils.mjs";
+import { TLSSocket } from "./internal/tls/tls-socket.mjs";
+import { Server } from "./internal/tls/server.mjs";
+import { SecureContext } from "./internal/tls/secure-context.mjs";
+// prettier-ignore
+import { CLIENT_RENEG_LIMIT, CLIENT_RENEG_WINDOW, DEFAULT_CIPHERS, DEFAULT_ECDH_CURVE, DEFAULT_MAX_VERSION, DEFAULT_MIN_VERSION } from "./internal/tls/constants.mjs";
+export * from "./internal/tls/constants.mjs";
+export { TLSSocket } from "./internal/tls/tls-socket.mjs";
+export { Server } from "./internal/tls/server.mjs";
+export { SecureContext } from "./internal/tls/secure-context.mjs";
+export const connect = function connect() {
+	return new TLSSocket();
+};
+export const createServer = function createServer() {
+	return new Server();
+};
+export const checkServerIdentity = /* @__PURE__ */ notImplemented("tls.checkServerIdentity");
+export const convertALPNProtocols = /* @__PURE__ */ notImplemented("tls.convertALPNProtocols");
+export const createSecureContext = /* @__PURE__ */ notImplemented("tls.createSecureContext");
+export const createSecurePair = /* @__PURE__ */ notImplemented("tls.createSecurePair");
+export const getCiphers = /* @__PURE__ */ notImplemented("tls.getCiphers");
+export const rootCertificates = [];
+export default {
+	CLIENT_RENEG_LIMIT,
+	CLIENT_RENEG_WINDOW,
+	DEFAULT_CIPHERS,
+	DEFAULT_ECDH_CURVE,
+	DEFAULT_MAX_VERSION,
+	DEFAULT_MIN_VERSION,
+	SecureContext,
+	Server,
+	TLSSocket,
+	checkServerIdentity,
+	connect,
+	convertALPNProtocols,
+	createSecureContext,
+	createSecurePair,
+	createServer,
+	getCiphers,
+	rootCertificates
+};

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

@@ -0,0 +1,5 @@
+import type nodeTraceEvents from "node:trace_events";
+export declare const createTracing: typeof nodeTraceEvents.createTracing;
+export declare const getEnabledCategories: typeof nodeTraceEvents.getEnabledCategories;
+declare const _default: {};
+export default _default;

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

@@ -0,0 +1,9 @@
+import { Tracing } from "./internal/trace_events/tracing.mjs";
+export const createTracing = function() {
+	return new Tracing();
+};
+export const getEnabledCategories = () => "";
+export default {
+	createTracing,
+	getEnabledCategories
+};

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

@@ -0,0 +1,9 @@
+import type nodeTty from "node:tty";
+export { ReadStream } from "./internal/tty/read-stream.mjs";
+export { WriteStream } from "./internal/tty/write-stream.mjs";
+export declare const isatty: typeof nodeTty.isatty;
+declare const _default: {
+	ReadStream: typeof nodeTty.ReadStream;
+	WriteStream: typeof nodeTty.WriteStream;
+};
+export default _default;

package/dist/polyfills/unenv-runtime/node/tty.mjs

@@ -0,0 +1,12 @@
+import { ReadStream } from "./internal/tty/read-stream.mjs";
+import { WriteStream } from "./internal/tty/write-stream.mjs";
+export { ReadStream } from "./internal/tty/read-stream.mjs";
+export { WriteStream } from "./internal/tty/write-stream.mjs";
+export const isatty = function() {
+	return false;
+};
+export default {
+	ReadStream,
+	WriteStream,
+	isatty
+};

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

@@ -0,0 +1,61 @@
+// Source: https://github.com/nodejs/node/blob/v22.7.0/lib/url.js
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+import type nodeUrl from "node:url";
+import * as querystring from "node:querystring";
+import { fileURLToPath, urlToHttpOptions } from "./internal/url/url.mjs";
+declare class Url implements nodeUrl.Url {
+	auth: string | null;
+	hash: string | null;
+	host: string | null;
+	hostname: string | null;
+	href: string;
+	path: string | null;
+	pathname: string | null;
+	protocol: string | null;
+	search: string | null;
+	slashes: boolean | null;
+	port: string | null;
+	query: string | querystring.ParsedUrlQuery | null;
+	parse(url: string, parseQueryString?: boolean, slashesDenoteHost?: boolean);
+	format();
+	resolve(relative: string);
+	resolveObject(relative: nodeUrl.Url);
+	parseHost();
+}
+declare function urlParse(url: string | Url, parseQueryString?: boolean, slashesDenoteHost?: boolean): Url;
+// Format a parsed object into a url string
+declare function urlFormat(urlObject: string | Url, options: nodeUrl.URLFormatOptions);
+declare function urlResolve(source: string, relative: string);
+declare function urlResolveObject(source: string, relative: nodeUrl.Url);
+// When used internally, we are not obligated to associate TypeError with
+// this function, so non-strings can be rejected by underlying implementation.
+// Public API has to validate input and throw appropriate error.
+declare function pathToFileURL(path: string, options?: {
+	windows?: boolean;
+});
+declare const URL: unknown;
+declare const URLSearchParams: unknown;
+declare const domainToASCII: unknown;
+declare const domainToUnicode: unknown;
+export { Url, urlParse as parse, urlResolve as resolve, urlResolveObject as resolveObject, urlFormat as format, URL, URLSearchParams, domainToASCII, domainToUnicode, pathToFileURL, fileURLToPath, urlToHttpOptions };
+declare const _default: {};
+export default _default;