@capsule-run/sdk 0.8.4 → 0.8.5

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

@@ -0,0 +1,48 @@
+import { createNotImplementedError } from "../../../_internal/utils.mjs";
+import { Channel } from "./channel.mjs";
+export class TracingChannel {
+	__unenv__ = true;
+	asyncEnd = new Channel("asyncEnd");
+	asyncStart = new Channel("asyncStart");
+	end = new Channel("end");
+	error = new Channel("error");
+	start = new Channel("start");
+	constructor(nameOrChannels) {
+		if (typeof nameOrChannels === "string") {
+			this.asyncEnd = new Channel(`trace:${nameOrChannels}:asyncEnd`);
+			this.asyncStart = new Channel(`trace:${nameOrChannels}:asyncStart`);
+			this.end = new Channel(`trace:${nameOrChannels}:end`);
+			this.error = new Channel(`trace:${nameOrChannels}:error`);
+			this.start = new Channel(`trace:${nameOrChannels}:start`);
+		} else {
+			this.asyncStart = nameOrChannels.asyncStart;
+			this.asyncEnd = nameOrChannels.asyncEnd;
+			this.end = nameOrChannels.end;
+			this.error = nameOrChannels.error;
+			this.start = nameOrChannels.start;
+		}
+	}
+	subscribe(handlers) {
+		this.asyncEnd?.subscribe(handlers.asyncEnd);
+		this.asyncStart?.subscribe(handlers.asyncStart);
+		this.end?.subscribe(handlers.end);
+		this.error?.subscribe(handlers.error);
+		this.start?.subscribe(handlers.start);
+	}
+	unsubscribe(handlers) {
+		this.asyncEnd?.unsubscribe(handlers.asyncEnd);
+		this.asyncStart?.unsubscribe(handlers.asyncStart);
+		this.end?.unsubscribe(handlers.end);
+		this.error?.unsubscribe(handlers.error);
+		this.start?.unsubscribe(handlers.start);
+	}
+	traceSync() {
+		throw createNotImplementedError("TracingChannel.traceSync");
+	}
+	tracePromise() {
+		throw createNotImplementedError("TracingChannel.tracePromise");
+	}
+	traceCallback() {
+		throw createNotImplementedError("TracingChannel.traceCallback");
+	}
+}

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

@@ -0,0 +1,28 @@
+// npx -y node@22.14 -e 'const dns=require("dns");console.log(Object.entries(dns).filter(e => ["string", "number"].includes(typeof e[1])).map(([k,v]) => `export const ${k} = ${JSON.stringify(v)}`).join("\n"))'
+export declare const ADDRCONFIG = 1024;
+export declare const ALL = 256;
+export declare const V4MAPPED = 2048;
+export declare const NODATA = "ENODATA";
+export declare const FORMERR = "EFORMERR";
+export declare const SERVFAIL = "ESERVFAIL";
+export declare const NOTFOUND = "ENOTFOUND";
+export declare const NOTIMP = "ENOTIMP";
+export declare const REFUSED = "EREFUSED";
+export declare const BADQUERY = "EBADQUERY";
+export declare const BADNAME = "EBADNAME";
+export declare const BADFAMILY = "EBADFAMILY";
+export declare const BADRESP = "EBADRESP";
+export declare const CONNREFUSED = "ECONNREFUSED";
+export declare const TIMEOUT = "ETIMEOUT";
+export declare const EOF = "EOF";
+export declare const FILE = "EFILE";
+export declare const NOMEM = "ENOMEM";
+export declare const DESTRUCTION = "EDESTRUCTION";
+export declare const BADSTR = "EBADSTR";
+export declare const BADFLAGS = "EBADFLAGS";
+export declare const NONAME = "ENONAME";
+export declare const BADHINTS = "EBADHINTS";
+export declare const NOTINITIALIZED = "ENOTINITIALIZED";
+export declare const LOADIPHLPAPI = "ELOADIPHLPAPI";
+export declare const ADDRGETNETWORKPARAMS = "EADDRGETNETWORKPARAMS";
+export declare const CANCELLED = "ECANCELLED";

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

@@ -0,0 +1,28 @@
+// npx -y node@22.14 -e 'const dns=require("dns");console.log(Object.entries(dns).filter(e => ["string", "number"].includes(typeof e[1])).map(([k,v]) => `export const ${k} = ${JSON.stringify(v)}`).join("\n"))'
+export const ADDRCONFIG = 1024;
+export const ALL = 256;
+export const V4MAPPED = 2048;
+export const NODATA = "ENODATA";
+export const FORMERR = "EFORMERR";
+export const SERVFAIL = "ESERVFAIL";
+export const NOTFOUND = "ENOTFOUND";
+export const NOTIMP = "ENOTIMP";
+export const REFUSED = "EREFUSED";
+export const BADQUERY = "EBADQUERY";
+export const BADNAME = "EBADNAME";
+export const BADFAMILY = "EBADFAMILY";
+export const BADRESP = "EBADRESP";
+export const CONNREFUSED = "ECONNREFUSED";
+export const TIMEOUT = "ETIMEOUT";
+export const EOF = "EOF";
+export const FILE = "EFILE";
+export const NOMEM = "ENOMEM";
+export const DESTRUCTION = "EDESTRUCTION";
+export const BADSTR = "EBADSTR";
+export const BADFLAGS = "EBADFLAGS";
+export const NONAME = "ENONAME";
+export const BADHINTS = "EBADHINTS";
+export const NOTINITIALIZED = "ENOTINITIALIZED";
+export const LOADIPHLPAPI = "ELOADIPHLPAPI";
+export const ADDRGETNETWORKPARAMS = "EADDRGETNETWORKPARAMS";
+export const CANCELLED = "ECANCELLED";

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

@@ -0,0 +1,13 @@
+import { EventEmitter } from "node:events";
+import type nodeDomain from "node:domain";
+export declare class Domain extends EventEmitter implements nodeDomain.Domain {
+	readonly __unenv__: true;
+	members: unknown;
+	add();
+	enter();
+	exit();
+	remove();
+	bind<T>(callback: T): T;
+	intercept<T>(callback: T): T;
+	run<T>(fn: (...args: any[]) => T, ...args: any[]): T;
+}

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

@@ -0,0 +1,19 @@
+import { createNotImplementedError } from "../../../_internal/utils.mjs";
+import { EventEmitter } from "node:events";
+export class Domain extends EventEmitter {
+	__unenv__ = true;
+	members = [];
+	add() {}
+	enter() {}
+	exit() {}
+	remove() {}
+	bind(callback) {
+		throw createNotImplementedError("Domain.bind");
+	}
+	intercept(callback) {
+		throw createNotImplementedError("Domain.intercept");
+	}
+	run(fn, ...args) {
+		throw createNotImplementedError("Domain.run");
+	}
+}

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

@@ -0,0 +1,207 @@
+// 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.
+// Based on Node.js EventEmitter implementation
+// https://github.com/nodejs/node/blob/26f2cbdd59957e9a33a94ee2e0fdbeb9aadb0be6/lib/events.js
+import type nodeEvents from "node:events";
+import { EventEmitter as NodeEventEmitter } from "node:events";
+// Types
+type Listener = (...args: any[]) => void;
+// ----------------------------------------------------------------------------
+// EventEmitter
+// ----------------------------------------------------------------------------
+export declare class _EventEmitter implements NodeEventEmitter {
+	// Internal state
+	_events: any;
+	_eventsCount: number;
+	_maxListeners: number | undefined;
+	// Symbols
+	static captureRejectionSymbol;
+	static errorMonitor;
+	static kMaxEventTargetListeners;
+	static kMaxEventTargetListenersWarned;
+	// Static utils
+	static usingDomains: boolean;
+	static get on();
+	static get once();
+	static get getEventListeners();
+	static get getMaxListeners();
+	static get addAbortListener();
+	static get EventEmitterAsyncResource();
+	static get EventEmitter();
+	static setMaxListeners(n?, ...eventTargets: (_EventEmitter | EventTarget)[]);
+	static listenerCount(emitter: NodeEventEmitter, type: string);
+	static init();
+	static get captureRejections();
+	static set captureRejections(value);
+	static get defaultMaxListeners();
+	static set defaultMaxListeners(arg);
+	// Constructor
+	constructor(opts?: any);
+	/**
+	* Increases the max listeners of the event emitter.
+	* @param {number} n
+	* @returns {EventEmitter}
+	*/
+	setMaxListeners(n: number);
+	/**
+	* Returns the current max listener value for the event emitter.
+	* @returns {number}
+	*/
+	getMaxListeners();
+	/**
+	* Synchronously calls each of the listeners registered
+	* for the event.
+	* @param {...any} [args]
+	* @returns {boolean}
+	*/
+	emit(type: string | symbol, ...args: any[]);
+	/**
+	* Adds a listener to the event emitter.
+	* @returns {EventEmitter}
+	*/
+	addListener(type: string | symbol, listener: Listener);
+	on(type: string | symbol, listener: Listener);
+	/**
+	* Adds the `listener` function to the beginning of
+	* the listeners array.
+	*/
+	prependListener(type: string | symbol, listener: Listener);
+	/**
+	* Adds a one-time `listener` function to the event emitter.
+	*/
+	once(type: string | symbol, listener: Listener);
+	/**
+	* Adds a one-time `listener` function to the beginning of
+	* the listeners array.
+	*/
+	prependOnceListener(type: string | symbol, listener: Listener);
+	/**
+	* Removes the specified `listener` from the listeners array.
+	* @param {string | symbol} type
+	* @param {Function} listener
+	* @returns {EventEmitter}
+	*/
+	removeListener(type: string | symbol, listener: Listener);
+	off(type: string | symbol, listener: Listener);
+	/**
+	* Removes all listeners from the event emitter. (Only
+	* removes listeners for a specific event name if specified
+	* as `type`).
+	*/
+	removeAllListeners(type?: string | symbol);
+	/**
+	* Returns a copy of the array of listeners for the event name
+	* specified as `type`.
+	* @param {string | symbol} type
+	* @returns {Function[]}
+	*/
+	listeners(type: string | symbol);
+	/**
+	* Returns a copy of the array of listeners and wrappers for
+	* the event name specified as `type`.
+	* @returns {Function[]}
+	*/
+	rawListeners(type: string | symbol);
+	/**
+	* Returns an array listing the events for which
+	* the emitter has registered listeners.
+	* @returns {any[]}
+	*/
+	eventNames();
+	/**
+	* Returns the number of listeners listening to event name
+	*/
+	listenerCount(eventName: string | symbol, listener?: Listener): number;
+}
+// ----------------------------------------------------------------------------
+// EventEmitterAsyncResource
+// ----------------------------------------------------------------------------
+export declare class EventEmitterAsyncResource extends _EventEmitter {
+	/**
+	* @param {{
+	*   name?: string,
+	*   triggerAsyncId?: number,
+	*   requireManualDestroy?: boolean,
+	* }} [options]
+	*/
+	constructor(options: any);
+	/**
+	* @param {symbol,string} event
+	* @param  {...any} args
+	* @returns {boolean}
+	*/
+	emit(event: string | symbol, ...args: any[]): boolean;
+	/**
+	* @returns {void}
+	*/
+	emitDestroy();
+	/**
+	* @type {number}
+	*/
+	get asyncId();
+	/**
+	* @type {number}
+	*/
+	get triggerAsyncId();
+	/**
+	* @type {EventEmitterReferencingAsyncResource}
+	*/
+	get asyncResource();
+}
+// ----------------------------------------------------------------------------
+// Exported utils
+// ----------------------------------------------------------------------------
+/**
+* Returns an `AsyncIterator` that iterates `event` events.
+* @param {EventEmitter} emitter
+* @param {string | symbol} event
+* @param {{
+*    signal: AbortSignal;
+*    close?: string[];
+*    highWaterMark?: number,
+*    lowWaterMark?: number
+*   }} [options]
+* @returns {AsyncIterator}
+*/
+export declare const on: typeof nodeEvents.on;
+/**
+* Creates a `Promise` that is fulfilled when the emitter
+* emits the given event.
+* @param {EventEmitter} emitter
+* @param {string} name
+* @param {{ signal: AbortSignal; }} [options]
+* @returns {Promise}
+*/
+export declare const once: typeof nodeEvents.once;
+export declare const addAbortListener: typeof nodeEvents.addAbortListener;
+/**
+* Returns a copy of the array of listeners for the event name
+* specified as `type`.
+* @returns {Function[]}
+*/
+export declare const getEventListeners: typeof nodeEvents.getEventListeners;
+/**
+* Returns the max listeners set.
+* @param {EventEmitter | EventTarget} emitterOrTarget
+* @returns {number}
+*/
+export declare const getMaxListeners: typeof nodeEvents.getMaxListeners;
+export {};