@capsule-run/sdk 0.8.4 → 0.8.6

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

@@ -0,0 +1,320 @@
+// Source: https://github.com/nodejs/node/blob/v22.7.0/lib/internal/querystring.js
+class ERR_INVALID_URI extends URIError {
+	code = "ERR_INVALID_URI";
+	constructor() {
+		super("URI malformed");
+	}
+}
+const hexTable = Array.from({ length: 256 });
+for (let i = 0; i < 256; ++i) hexTable[i] = "%" + String.prototype.toUpperCase.call((i < 16 ? "0" : "") + Number.prototype.toString.call(i, 16));
+// prettier-ignore
+const isHexTable = new Int8Array([
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0
+]);
+/**
+* @param {string} str
+* @param {Int8Array} noEscapeTable
+* @param {string[]} hexTable
+* @returns {string}
+*/
+function encodeStr(str, noEscapeTable, hexTable) {
+	const len = str.length;
+	if (len === 0) return "";
+	let out = "";
+	let lastPos = 0;
+	let i = 0;
+	outer: for (; i < len; i++) {
+		let c = String.prototype.charCodeAt.call(str, i);
+		// ASCII
+		while (c < 128) {
+			if (noEscapeTable[c] !== 1) {
+				if (lastPos < i) out += String.prototype.slice.call(str, lastPos, i);
+				lastPos = i + 1;
+				out += hexTable[c];
+			}
+			if (++i === len) break outer;
+			c = String.prototype.charCodeAt.call(str, i);
+		}
+		if (lastPos < i) out += String.prototype.slice.call(str, lastPos, i);
+		// Multi-byte characters ...
+		if (c < 2048) {
+			lastPos = i + 1;
+			out += hexTable[192 | c >> 6] + hexTable[128 | c & 63];
+			continue;
+		}
+		if (c < 55296 || c >= 57344) {
+			lastPos = i + 1;
+			out += hexTable[224 | c >> 12] + hexTable[128 | c >> 6 & 63] + hexTable[128 | c & 63];
+			continue;
+		}
+		// Surrogate pair
+		++i;
+		// This branch should never happen because all URLSearchParams entries
+		// should already be converted to USVString. But, included for
+		// completion's sake anyway.
+		if (i >= len) throw new ERR_INVALID_URI();
+		const c2 = String.prototype.charCodeAt.call(str, i) & 1023;
+		lastPos = i + 1;
+		c = 65536 + ((c & 1023) << 10 | c2);
+		out += hexTable[240 | c >> 18] + hexTable[128 | c >> 12 & 63] + hexTable[128 | c >> 6 & 63] + hexTable[128 | c & 63];
+	}
+	if (lastPos === 0) return str;
+	if (lastPos < len) return out + String.prototype.slice.call(str, lastPos);
+	return out;
+}
+export { encodeStr, hexTable, isHexTable };

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

@@ -0,0 +1,20 @@
+import type nodeReadline from "node:readline";
+import type { Abortable } from "node:events";
+import { EventEmitter } from "node:events";
+export declare class Interface extends EventEmitter implements nodeReadline.Interface {
+	terminal: boolean;
+	line: string;
+	cursor: number;
+	getPrompt(): string;
+	setPrompt(prompt: string): void;
+	prompt(preserveCursor?: boolean | undefined): void;
+	question(query: string, callback: (answer: string) => void): void;
+	question(query: string, options: Abortable, callback: (answer: string) => void): void;
+	resume();
+	close();
+	write(data: string | Buffer, key?: nodeReadline.Key | undefined): void;
+	write(data: string | Buffer | null | undefined, key: nodeReadline.Key): void;
+	getCursorPos(): nodeReadline.CursorPos;
+	pause();
+	[Symbol.asyncIterator](): NodeJS.AsyncIterator<string>;
+}

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

@@ -0,0 +1,31 @@
+import { EventEmitter } from "node:events";
+export class Interface extends EventEmitter {
+	terminal = false;
+	line = "";
+	cursor = 0;
+	getPrompt() {
+		return "";
+	}
+	setPrompt(prompt) {}
+	prompt(preserveCursor) {}
+	question(query, options, callback) {
+		callback && typeof callback === "function" && callback("");
+	}
+	resume() {
+		return this;
+	}
+	close() {}
+	write(data, key) {}
+	getCursorPos() {
+		return {
+			rows: 0,
+			cols: 0
+		};
+	}
+	pause() {
+		return this;
+	}
+	async *[Symbol.asyncIterator]() {
+		yield "";
+	}
+}

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

@@ -0,0 +1,7 @@
+import type nodeReadlinePromises from "node:readline/promises";
+import type { Abortable } from "node:events";
+import { Interface as _Interface } from "../interface.mjs";
+export declare class Interface extends _Interface implements nodeReadlinePromises.Interface {
+	question(query: string): Promise<string>;
+	question(query: string, options: Abortable): Promise<string>;
+}

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

@@ -0,0 +1,6 @@
+import { Interface as _Interface } from "../interface.mjs";
+export class Interface extends _Interface {
+	question(query, options) {
+		return Promise.resolve("");
+	}
+}

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

@@ -0,0 +1,10 @@
+import type nodeReadlinePromises from "node:readline/promises";
+import type { Direction } from "node:readline";
+export declare class Readline implements nodeReadlinePromises.Readline {
+	clearLine(dir: Direction);
+	clearScreenDown();
+	commit(): Promise<void>;
+	cursorTo(x: number, y?: number | undefined);
+	moveCursor(dx: number, dy: number);
+	rollback();
+}

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

@@ -0,0 +1,20 @@
+export class Readline {
+	clearLine(dir) {
+		return this;
+	}
+	clearScreenDown() {
+		return this;
+	}
+	commit() {
+		return Promise.resolve();
+	}
+	cursorTo(x, y) {
+		return this;
+	}
+	moveCursor(dx, dy) {
+		return this;
+	}
+	rollback() {
+		return this;
+	}
+}

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

@@ -0,0 +1,3 @@
+import type nodeStream from "node:stream";
+export declare const _Duplex: unknown;
+export declare const Duplex: typeof nodeStream.Duplex;

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

@@ -0,0 +1,19 @@
+import { mergeFns } from "../../../_internal/utils.mjs";
+import { Readable } from "./readable.mjs";
+import { Writable } from "./writable.mjs";
+const __Duplex = class {
+	allowHalfOpen = true;
+	_destroy;
+	constructor(readable = new Readable(), writable = new Writable()) {
+		Object.assign(this, readable);
+		Object.assign(this, writable);
+		this._destroy = mergeFns(readable._destroy, writable._destroy);
+	}
+};
+function getDuplex() {
+	Object.assign(__Duplex.prototype, Readable.prototype);
+	Object.assign(__Duplex.prototype, Writable.prototype);
+	return __Duplex;
+}
+export const _Duplex = /* @__PURE__ */ getDuplex();
+export const Duplex = globalThis.Duplex || _Duplex;

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

@@ -0,0 +1,67 @@
+import type nodeStream from "node:stream";
+import type { BufferEncoding, Callback } from "../../../_internal/types.mjs";
+import { EventEmitter } from "node:events";
+// Docs: https://nodejs.org/api/stream.html#stream_readable_streams
+// Implementation: https://github.com/nodejs/node/blob/master/lib/internal/streams/readable.js
+interface ArrayOptions {
+	/** the maximum concurrent invocations of `fn` to call on the stream at once. **Default: 1**. */
+	concurrency?: number;
+	/** allows destroying the stream if the signal is aborted. */
+	signal?: AbortSignal;
+}
+export declare class _Readable extends EventEmitter implements nodeStream.Readable {
+	__unenv__: unknown;
+	readonly readableEncoding: BufferEncoding | null;
+	readonly readableEnded: boolean;
+	readonly readableFlowing: boolean | null;
+	readonly readableHighWaterMark: number;
+	readonly readableLength: number;
+	readonly readableObjectMode: boolean;
+	readonly readableAborted: boolean;
+	readonly readableDidRead: boolean;
+	readonly closed: boolean;
+	readonly errored: Error | null;
+	readable: boolean;
+	destroyed: boolean;
+	static from(_iterable: Iterable<any> | AsyncIterable<any>, options?: nodeStream.ReadableOptions);
+	constructor(_opts?: nodeStream.ReadableOptions);
+	_read(_size: number);
+	read(_size?: number);
+	setEncoding(_encoding: BufferEncoding);
+	pause();
+	resume();
+	isPaused(): boolean;
+	unpipe(_destination?: any);
+	unshift(_chunk: any, _encoding?: BufferEncoding);
+	wrap(_oldStream: any);
+	push(_chunk: any, _encoding?: BufferEncoding): boolean;
+	_destroy(_error?: any, _callback?: Callback<any>);
+	destroy(error?: Error);
+	pipe<T>(_destenition: T, _options?: {
+		end?: boolean;
+	}): T;
+	compose<T extends NodeJS.ReadableStream>(stream: T | ((source: any) => void) | Iterable<T> | AsyncIterable<T>, options?: {
+		signal: AbortSignal;
+	} | undefined): T;
+	[Symbol.asyncDispose]();
+	// eslint-disable-next-line require-yield
+	[Symbol.asyncIterator](): NodeJS.AsyncIterator<any>;
+	iterator(options?: {
+		destroyOnReturn?: boolean | undefined;
+	} | undefined): NodeJS.AsyncIterator<any>;
+	map(fn: (data: any, options?: Pick<ArrayOptions, "signal"> | undefined) => any, options?: ArrayOptions | undefined): nodeStream.Readable;
+	filter(fn: (data: any, options?: Pick<ArrayOptions, "signal"> | undefined) => boolean, options?: ArrayOptions | undefined): nodeStream.Readable;
+	forEach(fn: (data: any, options?: Pick<ArrayOptions, "signal"> | undefined) => void | Promise<void>, options?: ArrayOptions | undefined): Promise<void>;
+	reduce(fn: (accumulator: any, data: any, options?: Pick<ArrayOptions, "signal"> | undefined) => any, initialValue?: any, options?: ArrayOptions | undefined): Promise<any>;
+	find(fn: (data: any, options?: Pick<ArrayOptions, "signal"> | undefined) => boolean, options?: ArrayOptions | undefined): Promise<any>;
+	findIndex(fn: (data: any, options?: Pick<ArrayOptions, "signal"> | undefined) => boolean, options?: ArrayOptions | undefined): Promise<number>;
+	some(fn: (data: any, options?: Pick<ArrayOptions, "signal"> | undefined) => boolean, options?: ArrayOptions | undefined): Promise<boolean>;
+	toArray(options?: Pick<ArrayOptions, "signal"> | undefined): Promise<any[]>;
+	every(fn: (data: any, options?: Pick<ArrayOptions, "signal"> | undefined) => boolean | Promise<boolean>, options?: ArrayOptions | undefined): Promise<boolean>;
+	flatMap(fn: (data: any, options?: Pick<ArrayOptions, "signal"> | undefined) => any, options?: ArrayOptions | undefined): nodeStream.Readable;
+	drop(limit: number, options?: Pick<ArrayOptions, "signal"> | undefined): nodeStream.Readable;
+	take(limit: number, options?: Pick<ArrayOptions, "signal"> | undefined): nodeStream.Readable;
+	asIndexedPairs(options?: Pick<ArrayOptions, "signal"> | undefined): nodeStream.Readable;
+}
+export declare const Readable: typeof nodeStream.Readable;
+export {};

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

@@ -0,0 +1,112 @@
+import { createNotImplementedError } from "../../../_internal/utils.mjs";
+import { EventEmitter } from "node:events";
+export class _Readable extends EventEmitter {
+	__unenv__ = true;
+	readableEncoding = null;
+	readableEnded = true;
+	readableFlowing = false;
+	readableHighWaterMark = 0;
+	readableLength = 0;
+	readableObjectMode = false;
+	readableAborted = false;
+	readableDidRead = false;
+	closed = false;
+	errored = null;
+	readable = false;
+	destroyed = false;
+	static from(_iterable, options) {
+		return new _Readable(options);
+	}
+	constructor(_opts) {
+		super();
+	}
+	_read(_size) {}
+	read(_size) {}
+	setEncoding(_encoding) {
+		return this;
+	}
+	pause() {
+		return this;
+	}
+	resume() {
+		return this;
+	}
+	isPaused() {
+		return true;
+	}
+	unpipe(_destination) {
+		return this;
+	}
+	unshift(_chunk, _encoding) {}
+	wrap(_oldStream) {
+		return this;
+	}
+	push(_chunk, _encoding) {
+		return false;
+	}
+	_destroy(_error, _callback) {
+		this.removeAllListeners();
+	}
+	destroy(error) {
+		this.destroyed = true;
+		this._destroy(error);
+		return this;
+	}
+	pipe(_destenition, _options) {
+		return {};
+	}
+	compose(stream, options) {
+		throw new Error("[unenv] Method not implemented.");
+	}
+	[Symbol.asyncDispose]() {
+		this.destroy();
+		return Promise.resolve();
+	}
+	// eslint-disable-next-line require-yield
+	async *[Symbol.asyncIterator]() {
+		throw createNotImplementedError("Readable.asyncIterator");
+	}
+	iterator(options) {
+		throw createNotImplementedError("Readable.iterator");
+	}
+	map(fn, options) {
+		throw createNotImplementedError("Readable.map");
+	}
+	filter(fn, options) {
+		throw createNotImplementedError("Readable.filter");
+	}
+	forEach(fn, options) {
+		throw createNotImplementedError("Readable.forEach");
+	}
+	reduce(fn, initialValue, options) {
+		throw createNotImplementedError("Readable.reduce");
+	}
+	find(fn, options) {
+		throw createNotImplementedError("Readable.find");
+	}
+	findIndex(fn, options) {
+		throw createNotImplementedError("Readable.findIndex");
+	}
+	some(fn, options) {
+		throw createNotImplementedError("Readable.some");
+	}
+	toArray(options) {
+		throw createNotImplementedError("Readable.toArray");
+	}
+	every(fn, options) {
+		throw createNotImplementedError("Readable.every");
+	}
+	flatMap(fn, options) {
+		throw createNotImplementedError("Readable.flatMap");
+	}
+	drop(limit, options) {
+		throw createNotImplementedError("Readable.drop");
+	}
+	take(limit, options) {
+		throw createNotImplementedError("Readable.take");
+	}
+	asIndexedPairs(options) {
+		throw createNotImplementedError("Readable.asIndexedPairs");
+	}
+}
+export const Readable = globalThis.Readable || _Readable;

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

@@ -0,0 +1,10 @@
+import type nodeStream from "node:stream";
+import { Duplex } from "./duplex.mjs";
+// Docs: https://nodejs.org/api/stream.html#stream_duplex_and_transform_streams
+// Implementation: https://github.com/nodejs/node/blob/master/lib/internal/streams/transform.js
+export declare class _Transform extends Duplex implements nodeStream.Transform {
+	readonly __unenv__: true;
+	_transform(chunk: any, encoding: globalThis.BufferEncoding, callback: nodeStream.TransformCallback): void;
+	_flush(callback: nodeStream.TransformCallback): void;
+}
+export declare const Transform: typeof nodeStream.Transform;

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

@@ -0,0 +1,9 @@
+import { Duplex } from "./duplex.mjs";
+// Docs: https://nodejs.org/api/stream.html#stream_duplex_and_transform_streams
+// Implementation: https://github.com/nodejs/node/blob/master/lib/internal/streams/transform.js
+export class _Transform extends Duplex {
+	__unenv__ = true;
+	_transform(chunk, encoding, callback) {}
+	_flush(callback) {}
+}
+export const Transform = globalThis.Transform || _Transform;

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

@@ -0,0 +1,2 @@
+import type nodeStream from "node:stream";
+export declare const Writable: typeof nodeStream.Writable;